This package implements encoding and decoding of JSON as defined in RFC 4627 and provides interfaces with identical syntax of standard lib encoding/json. Converting from encoding/json to jsoniter is no more than replacing the package with jsoniter and variable type declarations (if any). jsoniter interfaces gives 100% compatibility with code using standard lib.

This package provides a client library in go for mega.co.nz storage service. Features:

• User login

• Fetch filesystem tree

• Upload file

• Download file

• Create directory

• Move file or directory

• Rename file or directory

• Delete file or directory

• Parallel split download and upload

• Filesystem events auto sync

• Unit tests

Package jsoniter implements encoding and decoding of JSON as defined in RFC 4627 and provides interfaces with identical syntax of standard lib encoding/json. Converting from encoding/json to jsoniter is no more than replacing the package with jsoniter and variable type declarations (if any). jsoniter interfaces gives 100% compatibility with code using standard lib.

This package is a Graylog Extended Log Format (specification) library for Go. GELF is an application-level logging protocol that avoids many of the shortcomings of syslog. While it can be run over any stream or datagram transport protocol, it has special support to allow long messages to be split over multiple datagrams.

This package provides a cross-platform clipboard library.

Platforms supported:

• Linux via xclip or xsel or wl-copy/wl-paste

• MacOS via pbcopy/pbpaste

• Windows via the Windows clipboard API

• WSL via clip.exe/powershell.exe

• Android Termux via termux-clipboard-set/termux-clipboard-get

• Plan9 via /dev/snarf

• Anything else via a user-defined script

This package provides decoding of basic EXIF and TIFF encoded data. Functionality is split into packages:

• exif - implements decoding of EXIF data as defined in the EXIF 2.2 specification (http://www.exif.org/Exif2-2.PDF)

• mknote - provides makernote parsers that can be used with goexif/exif

• tiff - implements TIFF decoding as defined in TIFF 6.0 specification at http://partners.adobe.com/public/developer/en/tiff/TIFF6.pdf

This package provides basic types for OSM elements (nodes/ways/relations/etc).

It include the following submodules:

• parser/changeset - a parser for OSM changeset files

• parser/diff - a parser for OSM diff files (.osc)

• parser/pbf - an efficient parser for OpenStreetMap PBF files

• replication - basic types for replication of OSM data

• replication/changeset - functions for downloading OSM changeset files

• replication/diff - functions for downloading OSM diff files

• state - functions for reading and writing diff status files

Package echo implements a high performance, minimalist Go web framework. Features:

• optimized HTTP router which smartly prioritize routes

• build robust and scalable RESTful APIs

• group APIs

• extensible middleware framework

• define middleware at root, group or route level

• data binding for JSON, XML and form payload

• handy functions to send variety of HTTP responses

• centralized HTTP error handling

• template rendering with any template engine

• define your format for the logger

• highly customizable

• automatic TLS via Let’s Encrypt

• HTTP/2 support

This package provides is a Machine Learning library written in pure Go designed to support relevant neural architectures in Natural Language Processing.

It is self-contained, in that it uses its own lightweight computational graph both for training and inference, easy to understand from start to finish.

It provides:

• automatic differentiation via dynamic define-by-run execution

• feed-forward layers (Linear, Highway, Convolution...)

• recurrent layers (LSTM, GRU, BiLSTM...)

• attention layers (Self-Attention, Multi-Head Attention...)

• gradient descent optimizers (Adam, RAdam, RMS-Prop, AdaGrad, SGD)

• gob compatible neural models for serialization

Dstream is a package for manipulating streams of typed, multivariate data in Go. A Dstream is a dataframe-like container that holds a rectangular array of data in which the columns are variables and the rows are cases or observations.

Dstream is designed to handle large datasets, where it is not possible to load all data for all variables into memory at once. To achieve this, Dstream utilizes a chunked, column-based storage format. A chunk contains the data for a contiguous block of rows. The data are stored by variable (column-wise) in typed Go slices. Only one chunk of the Dstream is held in memory at one time.

Juniper is a library of extensions to the Go standard library using generics, including containers, iterators, and streams.

• container/tree contains a Map and Set that keep elements in sorted order. They are implemented using a B-tree, which performs better than a binary search tree.

• container/deque contains a double-ended queue implemented with a ring buffer.

• container/xheap contains a min-heap similar to the standard library's container/heap but more ergonomic, along with a PriorityQueue that allows setting priorities by key.

• container/xlist contains a linked-list similar to the standard library's container/list, but type-safe.

• xslices contains some commonly-used slice operations, like Chunk, Reverse, Clear, and Join.

• iterator contains an iterator interface used by the containers, along with functions to manipulate them, like Map, While, and Reduce.

• stream contains a stream interface, which is an iterator that can fail. Useful for iterating over collections that require I/O. It has most of the same combinators as iterator, plus some extras like Pipe and Batch.

• parallel contains some shorthand for common uses of goroutines to process slices, iterators, and streams in parallel, like parallel.MapStream.

• xsort contains extensions to the standard library package sort. Notably, it also has the definition for xsort.Less, which is how custom orderings can be defined for sorting and also for ordered collections like from container/tree.

• You can probably guess what's in the packages xerrors, xmath, xmath/xrand, xsync, and xtime.

Package githubv4 is a client library for accessing GitHub GraphQL API v4.

File system notifications for Go