Package logfmt implements utilities to marshal and unmarshal data in the logfmt format. The logfmt format records key/value pairs in a way that balances readability for humans and simplicity of computer parsing. It is most commonly used as a more human friendly alternative to JSON for structured logging.
AWS S3 fake server and testing library for extensive S3 test integrations. Either by running a test-server, e.g. for testing of AWS Lambda functions accessing S3. Or, to have a simple and convenience S3 mock- and test-server. It's an alternative fork of https://github.com/johannesboyne/gofakes3.
Package channels provides a collection of helper functions, interfaces and implementations for working with and extending the capabilities of golang's existing channels. The main interface of interest is Channel, though sub-interfaces are also provided for cases where the full Channel interface cannot be met (for example, InChannel for write-only channels).
Package flags provides an extensive command line option parser. The flags package is similar in functionality to the go built-in flag package but provides more options and uses reflection to provide a convenient and succinct way of specifying command line options. It's an alternative fork of https://github.com/jessevdk/go-flags.
goprocess introduces a way to manage process lifecycles in Go. It is much like go.net/context (it actually uses a Context), but it is more like a Context-WaitGroup hybrid. goprocess is about being able to start and stop units of work, which may receive Close signals from many clients.
This package contains code that supplements the time package from the Go standard library.
In particular:
a Clock interface, with a fake implementation that can be used in tests
implementations of oglematchers.Matcher for time values
This package contains code that supplements the sync package from the Go standard library.
In particular:
Bundle, which makes it easy to write code that spawns multiple cancellation-aware workers that may fail
invariantMutex, which makes it possible to automatically check your invariants at lock and unlock time
This package provides a library for conversion between Hebrew and Gregorian dates, and generation of lists of Jewish holidays for a given year. Shabbat and holiday candle lighting and havdalah times are approximated based on location.
Torah readings, Daf Yomi, and counting of the Omer can also be specified. Algorithms are included to calculate yahrzeits, birthdays, and anniversaries.
This is a modified version of the standard base64 decoder from encoding/base64.
Key differences:
Accepts both Standard and URL-safe encoding, no need to specify it explicitly.
Works for both padded and raw inputs.
The input can be a string or a
[]byte, no allocation or copy is performed for either.
Package throttler fills the gap between sync.WaitGroup and manually monitoring goroutines with channels. The API is almost identical to Wait Groups, but it allows user to set a max number of workers that can be running simultaneously. It uses channels internally to block until a job completes by calling Done(err) or until all jobs have been completed.
This package implements functionality to initialize structs with default values. It supports almost all kind of types: int/8/16/32/64, uint/8/16/32/64, float32/64, uintptr, bool, string, map, slice, struct, f,map[K1]map[K2]Struct, []map[K1]Struct[]
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
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.
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
xcliporxselorwl-copy/wl-pasteMacOS via
pbcopy/pbpasteWindows via the Windows clipboard API
WSL via clip.exe/powershell.exe
Android Termux via
termux-clipboard-set/termux-clipboard-getPlan9 via
/dev/snarfAnything 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 withgoexif/exiftiff- 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 filesparser/diff- a parser for OSM diff files (.osc)parser/pbf- an efficient parser for OpenStreetMap PBF filesreplication- basic types for replication of OSM datareplication/changeset- functions for downloading OSM changeset filesreplication/diff- functions for downloading OSM diff filesstate- 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
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.
This package implements a functionality which can be used in instrument code, expose application metrics, and profile runtime performance in a flexible manner. It makes use of a MetricSink interface to support delivery to any type of backend.
Currently the following sinks are provided:
StatsiteSink : Sinks to a statsite instance (TCP)
StatsdSink: Sinks to a StatsD / statsite instance (UDP)
PrometheusSink: Sinks to a Prometheus metrics endpoint (exposed via HTTP for scrapes)
InmemSink : Provides in-memory aggregation, can be used to export stats
FanoutSink : Sinks to multiple sinks. Enables writing to multiple statsite instances for example
BlackholeSink : Sinks to nowhere
Juniper is a library of extensions to the Go standard library using generics, including containers, iterators, and streams.
container/treecontains aMapandSetthat keep elements in sorted order. They are implemented using a B-tree, which performs better than a binary search tree.container/dequecontains a double-ended queue implemented with a ring buffer.container/xheapcontains a min-heap similar to the standard library'scontainer/heapbut more ergonomic, along with aPriorityQueuethat allows setting priorities by key.container/xlistcontains a linked-list similar to the standard library'scontainer/list, but type-safe.xslicescontains some commonly-used slice operations, likeChunk,Reverse,Clear, andJoin.iteratorcontains an iterator interface used by the containers, along with functions to manipulate them, likeMap,While, andReduce.streamcontains 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 asiterator, plus some extras likePipeandBatch.parallelcontains some shorthand for common uses of goroutines to process slices, iterators, and streams in parallel, likeparallel.MapStream.xsortcontains extensions to the standard library packagesort. Notably, it also has the definition forxsort.Less, which is how custom orderings can be defined for sorting and also for ordered collections like fromcontainer/tree.You can probably guess what's in the packages
xerrors,xmath,xmath/xrand,xsync, andxtime.