Free pickle software for linux

Alice is a functional programming language based on Standard ML, extended with rich support for concurrent, distributed, and constraint programming.
Main features:
- Futures: laziness and light-weight concurrency with data-flow synchronisation
- Higher-order modules: higher-order functors and abstract signatures
- Packages: integrating static with dynamic typing and first class modules
- Pickling: higher-order type-safe, generic & platform-independent persistence
- Components: platform-independence and type-safe dynamic loading of modules
- Distribution: type-safe cross-platform remote functions and network mobility
- Constraints: solving combinatorical problems using constraint propagation and programmable search
The Alice System is a rich open-source programming system featuring the following tools:
- Virtual machine: a portable VM with support for just-in-time compilation
- Interactive system: an interpreter-like interactive toplevel
- Batch compiler: separate compilation
- Static linker: type-safe bundling of components
- Inspector: a tool for interactively inspecting data structures
- Explorer: a tool for interactively investigating search problems
- Gtk+: a binding for the Gnome toolkit GUI library
- SQL: a library for accessing SQL databases
- XML: a simple library for parsing XML documents
Enhancements:
- Alice now incorporates some of the proposed extensions for Successor ML.
- The bytecode jitter is now the default execution unit.
- The documentation includes a constraint programming tutorial, and the constraint library now uses the current stable version of Gecode.

PyYAML project is a YAML emitter and parser for Python. PyYAML features a complete YAML 1.1 parser, Unicode support, pickle support, capable extension API, and sensible error messages.
PyYAML supports standard YAML tags and provides Python-specific tags that allow the representation of an arbitrary Python object. PyYAML is applicable for a broad range of tasks from complex configuration files to object serialization and persistence.
Main features:
- a complete YAML 1.1 parser. In particular, PyYAML can parse all examples from the specification. The parsing algorithm is simple enough to be a reference for YAML parser implementors.
- Unicode support including UTF-8/UTF-16 input/output and u escape sequences.
- low-level event-based parser and emitter API (like SAX).
- high-level API for serializing and deserializing native Python objects (like DOM or pickle).
- support for all types from the YAML types repository. A simple extension API is provided.
- relatively sensible error messages.

Leonardo is an extensible content management system written in Python. Leonardo is architected in a REST-like style and initially focused on providing for personal websites with a password-protected wiki and blog (including Atom feed).
It can be run as CGI and uses the filesystem as a database.
Enhancements:
- support for Atom 1.0
- comments optionally can require answering a simple question to reduce spamming
- site owner can optionally be emailed when new comments are made
- pages now record their author which is displayed on the page, in blog lists and atom feeds
- there is now a provider which lists blog months
- it is now possible to update a page or its properties without the last modified changing
- comments can be deleted if logged in
- formatting of comments is improved by translating newlines to br
- the main page template is now in LFS
- home page link is now part of menu rather than template to give user more control
- subtitle is now completely formatted in page template to give user more control
- copyright_holder changed to general rights statement
- removed stray ) in draft template causing malformed html
- delete page no longer has duplicate headings
- template files now have provider name in the filename
- leonardo library now in Python package to avoid name clashes
- after delete there is now a link to return to deleted resources parent
- switched from using shelve to pickle (shelve was causing problems for people moving between different systems with different anydbm implementations)
- files are now written in binary mode to avoid problems on Windows
- fixed bug where question mark in permalink wasnt getting escaped

Gnosis Utils contains several Python modules for XML processing. Gnosis Utils has other generally useful tools:
- xml.pickle (serializes objects to/from XML
- API compatible with the standard pickle module)
- xml.objectify (turns arbitrary XML documents into Python objects)
- xml.validity (enforces XML validity constraints via DTD or Schema)
- xml.indexer (full text indexing/searching), and many more.
Enhancements:
- This release fixes a bug in XML pickling of mx.DateTime objects.

SQLAlchemy is a SQL toolkit and object relational mapper for Python.
The Python SQL toolkit and Object Relational Mapper that gives application developers the full power and flexibility of SQL. SQLAlchemy provides a full suite of well known enterprise-level persistence patterns, designed for efficient and high-performing database access, adapted into a simple and Pythonic domain language.
- extremely easy to use for all the basic tasks, such as: accessing thread-safe and pooled connections, constructing SQL from Python expressions, finding object instances, and commiting object modifications back to the database.
- powerful enough for complicated tasks, such as: eager load a graph of objects and their dependencies via joins; map recursive adjacency structures automatically; map objects to not just tables but to any arbitrary join or select statement; combine multiple tables together to load whole sets of otherwise unrelated objects from a single result set; commit entire graphs of object changes in one step.
- built to conform to what DBAs demand, including the ability to swap out generated SQL with hand-optimized statements, full usage of bind parameters for all literal values, fully transactionalized and consistent updates using Unit of Work.
- modular. Different parts of SQLAlchemy can be used independently of the rest, including the connection pool, SQL construction, and ORM. SQLAlchemy is constructed in an open style that allows plenty of customization, with an architecture that supports custom datatypes, custom SQL extensions, and ORM plugins which can augment or extend mapping functionality.
SQLAlchemys Philosophy:
- SQL databases behave less and less like object collections the more size and performance start to matter; object collections behave less and less like tables and rows the more abstraction starts to matter. SQLAlchemy aims to accomodate both of these principles.
- Your classes arent tables, and your objects arent rows. Databases arent just collections of tables; theyre relational algebra engines. You dont have to select from just tables, you can select from joins, subqueries, and unions. Database and domain concepts should be visibly decoupled from the beginning, allowing both sides to develop to their full potential.
- For example, table metadata (objects that describe tables) are declared distinctly from the classes theyre designed to store. That way database relationship concepts dont interfere with your object design concepts, and vice-versa; the transition from table-mapping to selectable-mapping is seamless; a class can be mapped against the database in more than one way. SQLAlchemy provides a powerful mapping layer that can work as automatically or as manually as you choose, determining relationships based on foreign keys or letting you define the join conditions explicitly, to bridge the gap between database and domain.
SQLAlchemys Advantages:
- The Unit Of Work system organizes pending CRUD operations into queues and commits them all in one batch. It then performs a topological "dependency sort" of all items to be committed and deleted and groups redundant statements together. This produces the maxiumum efficiency and transaction safety, and minimizes chances of deadlocks. Modeled after Fowlers "Unit of Work" pattern as well as Java Hibernate.
- Function-based query construction allows boolean expressions, operators, functions, table aliases, selectable subqueries, create/update/insert/delete queries, correlated updates, correlated EXISTS clauses, UNION clauses, inner and outer joins, bind parameters, free mixing of literal text within expressions, as little or as much as desired. Query-compilation is vendor-specific; the same query object can be compiled into any number of resulting SQL strings depending on its compilation algorithm.
- Database mapping and class design are totally separate. Persisted objects have no subclassing requirement (other than object) and are POPOs : plain old Python objects. They retain serializability (pickling) for usage in various caching systems and session objects. SQLAlchemy "decorates" classes with non-intrusive property accessors to automatically log object creates and modifications with the UnitOfWork engine, to lazyload related data, as well as to track attribute change histories.
- Custom list classes can be used with eagerly or lazily loaded child object lists, allowing rich relationships to be created on the fly as SQLAlchemy appends child objects to an object attribute.
- Composite (multiple-column) primary keys are supported, as are "association" objects that represent the middle of a "many-to-many" relationship.
- Self-referential tables and mappers are supported. Adjacency list structures can be created, saved, and deleted with proper cascading, with no extra programming.
- Data mapping can be used in a row-based manner. Any bizarre hyper-optimized query that you or your DBA can cook up, you can run in SQLAlchemy, and as long as it returns the expected columns within a rowset, you can get your objects from it. For a rowset that contains more than one kind of object per row, multiple mappers can be chained together to return multiple object instance lists from a single database round trip.
- The type system allows pre- and post- processing of data, both at the bind parameter and the result set level. User-defined types can be freely mixed with built-in types. Generic types as well as SQL-specific types are available.

BOTEC project is a simple astrophysical and orbital mechanics calculator, including a database of all named Solar System objects.

BOTEC is intended as a simple but useful calculator to assist with making astrophysical, orbital mechanics, and space navigation calculations. As the origin of the acronym applies, BOTEC is more of a "back-of-the-envelope calculator" rather than an industrial-strength calculator, although this may change in the future.

BOTEC is primarily intended for people familiar with physics and Python, and as such is unlikely to be useful to the average enduser.

BOTEC really consists of two parts: The BOTEC software, which knows what to do with the data, and the Solar System data itself, which is represented in a large data file (a Python pickle, actually).

This is deliberately modularized so that the Solar System data BOTEC uses can be updated independently of thet software, and also that alternative data files (e.g., hypothetical stellar systems for fictional purposes) can be supported.

All values are strictly in SI units.

lib_rharris is a modest Python library for pulling, parsing, and pickling remote Web page data and for related net-aware tasks.
Enhancements:
- Documentation and installation fixes.

Myghty is a Python based web and templating framework originally based on HTML::Mason, the enterprise-level framework used by Amazon.com, del.icio.us and Salon.com, among many others.
Myghty fully implements Masons templating language, component-based architecture, and caching system, and goes beyond, adding new paradigms such as Module Components, full Python whitespace syntax, threading support, WSGI support, session support, and much more.
Main features:
- Session object support.
- Direct connectors for mod_python, CGI, WSGI, Python Paste, SimpleHTTPServer. As the Interpreter object is a lightweight object with no external dependencies whatsoever, any Python application or application server can invoke any series of Myghty components with just one line of code.
- A super-configurable ruleset driven URI resolution architecture allowing many options for resolving URIs both externally and within templates. Allows any combination of resolution directly to templates, Module Components, or any plain Python function or object instance. Special rules exist to route non-existent URIs to specific components, to cache the results of URI resolution for higher performance, and to execute conditionally based on contextual information.
- Cache API and implementation, can cache component output and any other data structure in memory or in pickled files. Includes a "busy lock" feature that allows a slow re-generation method to execute while the old data continues to be returned to other threads and processes. New cache implementations can be added fairly easily.
- Flexible global namespaces allow components to have any number of custom "global" variables.
- Special code blocks allow the construction of code that is local to the current request, or local to the current thread. A ThreadLocal object is supplied as well for safe management of thread-sensitive resources such as databases.
- Fine grained control of buffering - the buffering of textual output as it is delivered to the client can controlled at the application, page, or component level.
- Custom filtering functions can be defined for the output any component, within the source of the component via the