alpcentaur
/
basabuuka_prototyp


								Metadata-Version: 2.1

								Name: dill

								Version: 0.2.8.2

								Summary: serialize all of python

								Home-page: https://pypi.org/project/dill

								Author: Mike McKerns

								Maintainer: Mike McKerns

								License: 3-clause BSD

								Download-URL: https://github.com/uqfoundation/dill/releases/download/dill-0.2.8.2/dill-0.2.8.2.tar.gz

								Platform: Linux

								Platform: Windows

								Platform: Mac

								Classifier: Development Status :: 5 - Production/Stable

								Classifier: Intended Audience :: Developers

								Classifier: Intended Audience :: Science/Research

								Classifier: License :: OSI Approved :: BSD License

								Classifier: Programming Language :: Python :: 2

								Classifier: Programming Language :: Python :: 3

								Classifier: Topic :: Scientific/Engineering

								Classifier: Topic :: Software Development


								-----------------------------

								dill: serialize all of python

								-----------------------------


								About Dill

								==========


								``dill`` extends python's ``pickle`` module for serializing and de-serializing

								python objects to the majority of the built-in python types. Serialization

								is the process of converting an object to a byte stream, and the inverse

								of which is converting a byte stream back to on python object hierarchy.


								``dill`` provides the user the same interface as the ``pickle`` module, and

								also includes some additional features. In addition to pickling python

								objects, ``dill`` provides the ability to save the state of an interpreter

								session in a single command.  Hence, it would be feasable to save a

								interpreter session, close the interpreter, ship the pickled file to

								another computer, open a new interpreter, unpickle the session and

								thus continue from the 'saved' state of the original interpreter

								session.


								``dill`` can be used to store python objects to a file, but the primary

								usage is to send python objects across the network as a byte stream.

								``dill`` is quite flexible, and allows arbitrary user defined classes

								and functions to be serialized.  Thus ``dill`` is not intended to be

								secure against erroneously or maliciously constructed data. It is

								left to the user to decide whether the data they unpickle is from

								a trustworthy source.


								``dill`` is part of ``pathos``, a python framework for heterogeneous computing.

								``dill`` is in active development, so any user feedback, bug reports, comments,

								or suggestions are highly appreciated.  A list of known issues is maintained

								at http://trac.mystic.cacr.caltech.edu/project/pathos/query.html, with a public

								ticket list at https://github.com/uqfoundation/dill/issues.


								Major Features

								==============


								``dill`` can pickle the following standard types:


								    - none, type, bool, int, long, float, complex, str, unicode,

								    - tuple, list, dict, file, buffer, builtin,

								    - both old and new style classes,

								    - instances of old and new style classes,

								    - set, frozenset, array, functions, exceptions


								``dill`` can also pickle more 'exotic' standard types:


								    - functions with yields, nested functions, lambdas,

								    - cell, method, unboundmethod, module, code, methodwrapper,

								    - dictproxy, methoddescriptor, getsetdescriptor, memberdescriptor,

								    - wrapperdescriptor, xrange, slice,

								    - notimplemented, ellipsis, quit


								``dill`` cannot yet pickle these standard types:


								    - frame, generator, traceback


								``dill`` also provides the capability to:


								    - save and load python interpreter sessions

								    - save and extract the source code from functions and classes

								    - interactively diagnose pickling errors


								Current Release

								===============


								This documentation is for version ``dill-0.2.8.2``.


								The latest released version of ``dill`` is available from:


								    https://pypi.org/project/dill


								``dill`` is distributed under a 3-clause BSD license.


								    >>> import dill

								    >>> print (dill.license())


								Development Version

								===================


								You can get the latest development version with all the shiny new features at:


								    https://github.com/uqfoundation


								If you have a new contribution, please submit a pull request.


								Installation

								============


								``dill`` is packaged to install from source, so you must

								download the tarball, unzip, and run the installer::


								    [download]

								    $ tar -xvzf dill-0.2.8.2.tar.gz

								    $ cd dill-0.2.8.2

								    $ python setup py build

								    $ python setup py install


								You will be warned of any missing dependencies and/or settings

								after you run the "build" step above.


								Alternately, ``dill`` can be installed with ``pip`` or ``easy_install``::


								    $ pip install dill


								Requirements

								============


								``dill`` requires:


								    - ``python``, **version >= 2.5** or **version >= 3.1**, or ``pypy``

								    - ``pyreadline``, **version >= 1.7.1** (on windows)


								Optional requirements:


								    - ``setuptools``, **version >= 0.6**

								    - ``objgraph``, **version >= 1.7.2**


								More Information

								================


								Probably the best way to get started is to look at the documentation at

								http://dill.rtfd.io. Also see ``dill.tests`` for a set of scripts that

								demonstrate how ``dill`` can serialize different python objects. You can

								run the test suite with ``python -m dill.tests``. The contents of any

								pickle file can be examined with ``undill``.  As ``dill`` conforms to

								the ``pickle`` interface, the examples and documentation found at

								http://docs.python.org/library/pickle.html also apply to ``dill``

								if one will ``import dill as pickle``. The source code is also generally

								well documented, so further questions may be resolved by inspecting the

								code itself. Please feel free to submit a ticket on github, or ask a

								question on stackoverflow (**@Mike McKerns**).

								If you would like to share how you use ``dill`` in your work, please send

								an email (to **mmckerns at uqfoundation dot org**).


								Citation

								========


								If you use ``dill`` to do research that leads to publication, we ask that you

								acknowledge use of ``dill`` by citing the following in your publication::


								    M.M. McKerns, L. Strand, T. Sullivan, A. Fang, M.A.G. Aivazis,

								    "Building a framework for predictive science", Proceedings of

								    the 10th Python in Science Conference, 2011;

								    http://arxiv.org/pdf/1202.1056


								    Michael McKerns and Michael Aivazis,

								    "pathos: a framework for heterogeneous computing", 2010- ;

								    http://trac.mystic.cacr.caltech.edu/project/pathos


								Please see http://trac.mystic.cacr.caltech.edu/project/pathos or

								http://arxiv.org/pdf/1202.1056 for further information.