BorgBackup is a deduplicating archiver which stores deltas. It
supports compression and authenticated encryption as well,
facilitating frequent backups and storing to not fully trusted
targets.

google-drive-ocamlfuse is a FUSE-based file system backed by Google Drive,
written in OCaml. It lets you mount your Google Drive on Linux.

On the first time, just run google-drive-ocamlfuse, which will open a
browser for authentication. If that process succeeds, it will print
"Access token retrieved correctly.". Now run google-drive-ocamlfuse
with an empty directory supplied, which is the mount point for your Google
Drive. You can optionally unmount with fusermount -u mount-point.

Further documentation is available here:

https://github.com/astrada/google-drive-ocamlfuse/wiki

Biniou (pronounced "be new") is a binary data format designed for speed,
safety, ease of use and backward compatibility as protocols evolve. Biniou is
vastly equivalent to JSON in terms of functionality but allows implementations
several times faster (4 times faster than yojson), with 25-35% space savings.

Biniou data can be decoded into human-readable form without knowledge of type
definitions except for field and variant names which are represented by 31-bit
hashes. A program named bdump is provided for routine visualization of biniou
data files.

The program atdgen can be used to derive OCaml-Biniou serializers and
deserializers from type definitions.

CamlIDL is a stub code generator and COM binding for Objective Caml.

CamlIDL comprises two parts:

* A stub code generator that generates the C stub code required for
the Caml/C interface, based on an MIDL specification. (MIDL stands
for Microsoft's Interface Description Language; it looks like C
header files with some extra annotations, plus a notion of object
interfaces that look like C++ classes without inheritance.)

* A (currently small) library of functions and tools to import COM
components in Caml applications, and export Caml code as COM
components.

This OCaml library provides easy access to compressed files in ZIP
and GZIP format, as well as to Java JAR files. It provides functions
for reading from and writing to compressed files in these formats.

Cppo is an equivalent of the C preprocessor targeted at the OCaml language and
its variants.

The main purpose of cppo is to provide a lightweight tool for simple macro
substitution (#define) and file inclusion (#include) for the occasional case
when this is useful in OCaml. Processing specific sections of files by calling
external programs is also possible via #ext directives.

The implementation of cppo relies on the standard library of OCaml and on the
standard parsing tools Ocamllex and Ocamlyacc, which contribute to the
robustness of cppo across OCaml versions.

A library of cryptographic primitive -- block ciphers (AES, DES, 3DES),
stream ciphers (ARCfour), public-key crypto (RSA, DH), hashes
(SHA-1, SHA-256), MACs, random number generation -- all presented with a
compositional, extensible interface.

This module offers a high-level and functional interface to the Format module
of the OCaml standard library. It is a pretty-printing facility, i.e. it takes
as input some code represented as a tree and formats this code into the most
visually satisfying result, breaking and indenting lines of code where
appropriate.

Input data must be first modelled and converted into a tree using 3 kinds of
nodes:

atoms lists labelled nodes

Atoms represent any text that is guaranteed to be printed as-is. Lists can
model any sequence of items such as arrays of data or lists of definitions that
are labelled with something like "int main", "let x =" or "x:".

This is a binding to fuse for the ocaml programming language, enabling
you to write multithreaded filesystems in the ocaml language. It has
been designed with simplicity as a goal, as you can see by looking at
example/fusexmp.ml. Efficiency has also been a separate goal. The
Bigarray library is used for read and writes, allowing the library to
do zero-copy in ocaml land.

gapi-ocaml is a simple, unofficial, OCaml client for Google Services. The
library supports ClientLogin, OAuth 1.0a, and OAuth 2.0 authentication.
Supported RESTful APIs:

* Calendar APIs v3
* Google+ API v1
* Tasks API v1
* APIs Discovery Service v1
* URL Shortener API v1
* OAuth2 API v2
* Custom Search API v1
* Google Analytics API v3
* Page Speed Online API v1
* Blogger API v2
* Site Verification API v1
* AdSense Management API v1.1
* BigQuery API v2
* Drive API v2
* Drive API v3
* Gmail API v1

Features

* Monadic interface
* [Functional lenses](http://astrada.github.com/gapi-ocaml/GapiLens.html) to
access data structures
* Service generator (experimental): a tool for generating client libraries for
APIs based on the Google API Discovery format

Ocaml bindings to libcurl http://curl.haxx.se/libcurl/. This is a continuation
of http://ocurl.sourceforge.net/, with multi API wrappers and pluggable
asynchronous interface.

SQLite 3 database library wrapper for OCaml.

Xmlm is an OCaml module for streaming XML input/output. It aims
at making XML processing robust and painless. The streaming interface
can process documents without building an in-memory representation. It
lets the programmer translate its data structures to XML documents and
vice-versa. Functions are provided to easily transform arborescent
data structures to/from XML documents.

Yojson is an optimized parsing and printing library for the JSON format. It
addresses a few shortcomings of json-wheel including 2x speedup, polymorphic
variants and optional syntax for tuples and variants.

ydump is a pretty-printing command-line program provided with the yojson
package.

The program atdgen can be used to derive OCaml-JSON serializers and
deserializers from type definitions.

This package contains a set of persistent object containers built around a modified BTree data structure. The trees are optimized for use inside ZODB's "optimistic concurrency" paradigm, and include explicit resolution of conflicts detected by that mechanism.

Chameleon is an HTML/XML template engine for Python. It uses the *page templates* language.

You can use it in any Python web application with just about any version of Python (2.5 and up, including 3.x and pypy).

Manuel lets you build tested documentation

Parsley is a parsing library for people who find parsers scary or annoying. I wrote it because I wanted to parse a programming language, and tools like PLY or ANTLR or Bison were very hard to understand and integrate into my Python code. Most parser generators are based on LL or LR parsing algorithms that compile to big state machine tables. It was like I had to wake up a different section of my brain to understand or work on grammar rules.

Parsley, like pyparsing and ZestyParser, uses the PEG algorithm, so each expression in the grammar rules works like a Python expression. In particular, alternatives are evaluated in order, unlike table-driven parsers such as yacc, bison or PLY.

Parsley is an implementation of OMeta, an object-oriented pattern-matching language developed by Alessandro Warth at http://tinlizzie.org/ometa/ . For further reading, see Warth's PhD thesis, which provides a detailed description of OMeta: http://www.vpri.org/pdf/tr2008003_experimenting.pdf

This tool provides code to load WSGI applications and servers from URIs; these
URIs can refer to Python Eggs for INI-style configuration files. Paste Script
provides commands to serve applications based on this configuration file.

This module implements the password-based key derivation function, PBKDF2, specified in RSA PKCS#5 v2.0.

A library for converting a token stream into a data structure comprised of sequences, mappings, and scalars, developed primarily for converting HTTP form post data into a richer data structure.

Please see http://docs.pylonsproject.org/projects/peppercorn/en/latest/ for the documentation.

This package contains a generic persistence implementation for Python. It forms the core protocol for making objects interact "transparently" with a database such as the ZODB.

Please see the Sphinx documentation (docs/index.rst) for further information.

This Python 2.4+ extension module allows you to manipulate the POSIX.1e Access Control Lists present in some OS/file-systems combinations.