serialize all of python

The UQ Foundation

Last update: Jan 7, 2023

Related tags

Data Serialization dill

Overview

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 a 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 issues is located at https://github.com/uqfoundation/dill/issues, with a legacy list maintained at https://uqfoundation.github.io/pathos-issues.html.

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

The latest released version of dill is available from: https://pypi.org/project/dill

dill is distributed under a 3-clause BSD 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.

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- ;
https://uqfoundation.github.io/pathos.html

Please see https://uqfoundation.github.io/pathos.html or http://arxiv.org/pdf/1202.1056 for further information.

Comments

Support recursive and empty closure cells

This PR uses a better workaround for super objects. Instead of forcing _byref to False, this PR keeps track of what classes are in the process of being created. When a cell whose value is an incomplete class is encountered, it is saved to a list. Its initial value is None to prevent infinite recursion. Once a class is fully created, all of the cells that recursively reference the class are updated with the completed class.

This PR adds generalized machinery to handle thunks by saving a list of postprocessing steps for each potentially recursive object, like changing the value of a cell. The _postproc can be used for other operations, like registering ABCs and updating the __globals__ and __dict__ of recursive functions and enum classes.

This PR also adds a _shims module to handle version incompatibilities in Python and dill more seamlessly.

Fixes #229, fixes #239, fixes #300, fixes #344, fixes #399, fixes #211
enhancement

opened by anivegesana 61
Implement changes in #57: improve behaviour of dumped files
Here's a start on #57. Questions:

When a file in read or append mode does not exists, the file currently points to os.devnull. Is this acceptable?

Do you think the test file is enough?

Should the IOErrors be replaced by UnpicklingErrors?

When the position is off the end of the file, in safe mode, should an exception be raised, or the position moved to the end?

enhancement
opened by matsjoyce 48
dump fails with RuntimeError (recursion depth) for class with super
The following code fails for me using Python 3.4. (works under 2.7, and also with standard pickle module under 3.4)

import dill class obj(object): def __init__(self): pass class obj2(obj): def __init__(self): super(obj2, self).__init__() dill.dumps(obj2())
bug
opened by zentol 43
regression from 0.3.4 to 0.3.5.x - class decorators

dear @anivegesana ,

I am the author of the wrapt_timeout_decorator

since version 0.3.5 of dill, two of our tests are failing under windows.

In those tests we use our decorator to decorate some Class Methods, which are then called in a process via multiprocess (which is using implicitely dill). (see this test )

Those tests are just fine with version 0.3.4 on windows/linux/macos, or 0.3.5.x on linux/macos, but the fail with dill > 0.3.4 on windows.

What seems to happen is, that the decorator recursively seem to call itself, creating a chain of subprocesses. In order to debug that behaviour You might set the timeout to 3600 seconds in that tests and print some debug information to stderr.

I really struggle to make a minimal version to show that regression, therefore I would please ask You for help, in order to be able to use dill 0.3.5 upwards for my community.

you can find the failed jobs with dill 0.3.5.1 here and the same tests passing with dill 0.3.4.0 here

yours sincerely

Robert, Vienna
duplicate

opened by bitranox 41
compatibility with pypy
Looks like there are some compatibility issues with dill and pypy: see https://github.com/uqfoundation/pathos/issues/50. Apparently ctypes in pypy does not have a CellType… or at least this import fails:

>>> import ctypes >>> ctypes.pythonapi.PyCell_New Traceback (most recent call last): File "<stdin>", line 1, in <module> AttributeError: 'module' object has no attribute 'pythonapi'

Initial fix will be to disable the CellType for pypy
compatibility
opened by mmckerns 33
Fixes some bugs when using `dump_session()` with `byref=True`

Here are the proposed fixes for bugs reported in https://github.com/uqfoundation/dill/issues/462.

You can review the changes already, but please don't merge it yet as I'm still tracking a strange third bug in dump_session(). And I spotted yet another possible bug, but need to test it first. I'll probably append more commits in the next days.

I'm working on this feature for it to be used as the cache mechanism for the reticulate R package —knitr's Python engine. It's mostly functional by now. (Related discussion: https://github.com/yihui/knitr/issues/1505)

By the way, could you clarify a thing for me? Why is it that, even when the byref parameter is set to True, after the imported objects are identified and stored in the __dill_imported object, the Pickler is called with the _byref attribute set to False. What's the rationale? Is it because the session is saved as a whole module and then pickle would try to store everything inside it by name reference?

Fixes #462
bugfix

opened by leogama 30
handle failures for corner cases if recurse=True in dump

If certain corner cases can be handled, then recurse=True could be the default setting for dump, which would be more robust.

Failure with recurse=True noted in some tests: (test_classdef and others).
bug

opened by mmckerns 28
Can't dump_session with inline plots

dump_session() seems to fail when used with ipython notebook set up for inline plots. When the %matplotlib inline magic is used you get a traceback resulting in PicklingError: Can't pickle 'RendererAgg' object: <RendererAgg object at 0x42a2bb8> and when using the --pylab=inline option at start up you get a traceback resulting in PicklingError: Can't pickle <class 'matplotlib.axes.AxesSubplot'>: it's not found as matplotlib.axes.AxesSubplot

Using Dill 0.2a.dev, ipython 1.1.0
compatibility

opened by niallrobinson 23
pickles from 0.3.1.1 are not guaranteed to unpickle with 0.3.0
We observed in https://issues.apache.org/jira/browse/BEAM-8324 that main sessions pickled with dill==0.3.1.1 cannot be unpickled with dill==0.3.0.

... return dill.load_session(file_path) File "/usr/local/lib/python3.7/site-packages/dill/_dill.py", line 410, in load_session module = unpickler.load() TypeError: _create_function() takes from 2 to 6 positional arguments but 7 were given

This is due to changes https://github.com/uqfoundation/dill/pull/336 that happened between 0.3.0 and 0.3.1.1.

The changes https://github.com/uqfoundation/dill/pull/336 improve dill functionality, however they also open a question whether such changes should be implemented in a backwards-compatible way, when minor version is not increased.

@mmckerns - does dill intend to have any backwards-compatibility guarantees between versions?

cc:@lazylynx
compatibility
opened by tvalentyn 22

Saving a modules dict attribute

Possibly a follow up for #35, but saving a session doesn't save the state of the modules:

Python 3.4.1 (default, May 19 2014, 17:23:49) 
[GCC 4.9.0 20140507 (prerelease)] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import dill
>>> import test
>>> test.a = 2
>>> dill.dump_session()
>>> 
==========================Restart==========================
Python 3.4.1 (default, May 19 2014, 17:23:49) 
[GCC 4.9.0 20140507 (prerelease)] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import dill
>>> dill.load_session()
>>> test
<module 'test' from 'test.py'>
>>> test.a
1
>>>

test.py:

def f():
    print(x)
a = 1

I think this code does the job, but it may need a few adjustments, depending which modules need to be pickled.

enhancement

opened by matsjoyce 22

Fix problem with pickling file instances

I was trying to pickle files earlier and I think I've found a bug:

Traceback (most recent call last):
  File "example.py", line 2, in <module>
    dill.dumps(open(__file__))
  File "/home/matthew/Programming/C++/Python/eggs/dill/dill.py", line 135, in dumps
    dump(obj, file, protocol, byref)
  File "/home/matthew/Programming/C++/Python/eggs/dill/dill.py", line 128, in dump
    pik.dump(obj)
  File "/usr/lib/python3.3/pickle.py", line 235, in dump
    self.save(obj)
  File "/usr/lib/python3.3/pickle.py", line 317, in save
    rv = reduce(self.proto)
TypeError: cannot serialize '_io.TextIOWrapper' object

It can be fixed by adding type for the file type definitions.

bug

opened by matsjoyce 21

Recursion error on classes using getattr

The below MWE is extracted from qiskit, i.e. this is a MWE for why qiskit.Aer cannot be serialized.

import dill

class AerWrapper:
    """Lazy loading wrapper for Aer provider."""

    def __init__(self):
        self.aer = None

    def __getattr__(self, attr):
        if not self.aer:
            self.aer = "Hi"
        return getattr(self.aer, attr)

Aer = AerWrapper()

def func(): # Hide Aer object in function, to justify recurse=True
    print(Aer)

with open("temp.dill", 'wb') as f:
    dill.dump(func, f, recurse=True)

del Aer

with open("temp.dill", "rb") as f:
    g = dill.load(f)

Executing this in any of the latest dill versions (0.3.5-0.3.6) leads to a RecursionError.

Traceback (most recent call last):
  File "test.py", line 27, in <module>
    g = dill.load(f)
  File ".../python3.8/site-packages/dill/_dill.py", line 272, in load
    return Unpickler(file, ignore=ignore, **kwds).load()
  File ".../python3.8/site-packages/dill/_dill.py", line 419, in load
    obj = StockUnpickler.load(self)
  File "test.py", line 12, in __getattr__
    if not self.aer:
  File "test.py", line 12, in __getattr__
    if not self.aer:
  File "test.py", line 12, in __getattr__
    if not self.aer:
  [Previous line repeated 993 more times]
RecursionError: maximum recursion depth exceeded

This might be related to Issues #362 and #405, but I'm not sure, so I created a new issue.

opened by Sola85 2

dill can't serialize classmethod packaged with cython
I create a class like

class Fly: @classmethod def say(cls): print("hello world")

it's saved in tool.py file and placed under tt directory package it with cython and will get .so file

The test code is here

from tt.tool import Fly from pathos.pools import _ProcessPool as Pool def f(c): c() pool = Pool(1) t = pool.apply_async(func=f, args=(Fly.say,)) t.get()

this will generate exception can't pickle <cyfunction xxxx>: it's not the same object as xxx

I have tried pickle and it can deal with this scenario, can it be solved in dill?
opened by luckqk 0
Massive performance loss from 0.3.5 to 0.3.6

I am seeing some massive performance loss going from dill==0.3.5 to dill==0.3.6.

Profiling the program with which I discovered this problem looks like this with 0.3.6:

With 0.3.5 less than 2% of the runtime are spent in this branch.

The fact that _dill:343 save is called an enormously large number of times looks suspicious...

opened by cvjjm 3

Error on saving notebook containing Holoviews Panel objects

Get the following error on saving notebook session if notebook has aholoview panel object

File c:\Users\test\AppData\Local\Programs\Python\Python39\lib\site-packages\dill\_dill.py:503, in dump_session(filename, main, byref, **kwds)
    501     pickler._first_pass = True
    502     pickler._main_modified = main is not pickler._original_main
--> 503     pickler.dump(main)
    504 finally:
    505     if f is not filename:  # If newly opened file

File c:\Users\test\AppData\Local\Programs\Python\Python39\lib\site-packages\dill\_dill.py:620, in Pickler.dump(self, obj)
    618     raise PicklingError(msg)
    619 else:
--> 620     StockPickler.dump(self, obj)
    621 return

File c:\Users\test\AppData\Local\Programs\Python\Python39\lib\pickle.py:487, in _Pickler.dump(self, obj)
    485 if self.proto >= 4:
    486     self.framer.start_framing()
--> 487 self.save(obj)
    488 self.write(STOP)
    489 self.framer.end_framing()
...
    580     reduce = getattr(obj, "__reduce__", None)

File stringsource:2, in zmq.backend.cython.context.Context.__reduce_cython__()

TypeError: no default __reduce__ due to non-trivial __cinit__

opened by jj-github-jj 4

Releases(dill-0.3.6)

dill-0.3.6(Oct 23, 2022)
With dill, you can serialize almost anything in python, even an entire interpreter session. If you encounter any pickling failures, dill also has some good tools to help you discover why your object fails to pickle.

dill installs with pip: $ pip install dill

dill requires: - python or pypy, >=3.7

Optional requirements: - pyreadline, >=1.7.1 (install with $ pip install dill[readline]) - objgraph, >=1.7.2 (install with $ pip install dill[graph])

dill is licensed under 3-clause BSD:

>>> import dill >>> print (dill.license())

To cite dill:

>>> import dill >>> print (dill.citation())
Source code(tar.gz)
Source code(zip)
dill-0.3.6-py3-none-any.whl(107.92 KB)
dill-0.3.6.tar.gz(174.83 KB)
dill-0.3.6.zip(207.25 KB)
dill-0.3.5.1(May 20, 2022)
With dill, you can serialize almost anything in python, even an entire interpreter session. If you encounter any pickling failures, dill also has some good tools to help you discover why your object fails to pickle.

dill installs with pip: $ pip install dill

dill requires: - python or pypy, ==2.7 or >=3.7

Optional requirements: - pyreadline, >=1.7.1 (install with $ pip install dill[readline]) - objgraph, >=1.7.2 (install with $ pip install dill[graph])

dill is licensed under 3-clause BSD:

>>> import dill >>> print (dill.license())

To cite dill:

>>> import dill >>> print (dill.citation())
Source code(tar.gz)
Source code(zip)
dill-0.3.5.1-py2.py3-none-any.whl(93.58 KB)
dill-0.3.5.1.tar.gz(163.34 KB)
dill-0.3.5.1.zip(191.65 KB)
dill-0.3.5(May 19, 2022)
With dill, you can serialize almost anything in python, even an entire interpreter session. If you encounter any pickling failures, dill also has some good tools to help you discover why your object fails to pickle.

dill installs with pip: $ pip install dill

dill requires: - python or pypy, ==2.7 or >=3.7

Optional requirements: - pyreadline, >=1.7.1 (install with $ pip install dill[readline]) - objgraph, >=1.7.2 (install with $ pip install dill[graph])

dill is licensed under 3-clause BSD:

>>> import dill >>> print (dill.license())

To cite dill:

>>> import dill >>> print (dill.citation())
Source code(tar.gz)
Source code(zip)
dill-0.3.5-py2.py3-none-any.whl(93.55 KB)
dill-0.3.5.tar.gz(163.30 KB)
dill-0.3.5.zip(191.39 KB)
dill-0.3.4(Jun 13, 2021)
With dill, you can serialize almost anything in python, even an entire interpreter session. If you encounter any pickling failures, dill also has some good tools to help you discover why your object fails to pickle.

dill installs with easy_install or pip: $ pip install dill

dill requires: - python, version == 2.7 *or* version >= 3.6 *or* pypy

Optional requirements: - pyreadline, version >= 1.7.1 (install with $ pip install dill[readline]) - objgraph, version >= 1.7.2 (install with $ pip install dill[graph])

dill is licensed under 3-clause BSD:

>>> import dill >>> print (dill.license())

To cite dill:

>>> import dill >>> print (dill.citation())
Source code(tar.gz)
Source code(zip)
dill-0.3.4-py2.py3-none-any.whl(84.88 KB)
dill-0.3.4.tar.gz(154.71 KB)
dill-0.3.4.zip(182.44 KB)
dill-0.3.3(Nov 2, 2020)
With dill, you can serialize almost anything in python, even an entire interpreter session. If you encounter any pickling failures, dill also has some good tools to help you discover why your object fails to pickle.

dill installs with easy_install or pip: $ pip install dill

dill requires: - python, version == 2.7 *or* version >= 3.5 *or* pypy

Optional requirements: - pyreadline, version >= 1.7.1 (install with $ pip install dill[readline]) - objgraph, version >= 1.7.2 (install with $ pip install dill[graph])

dill is licensed under 3-clause BSD:

>>> import dill >>> print (dill.license())

To cite dill:

>>> import dill >>> print (dill.citation())
Source code(tar.gz)
Source code(zip)
dill-0.3.3-py2.py3-none-any.whl(79.40 KB)
dill-0.3.3.tar.gz(149.73 KB)
dill-0.3.3.zip(173.52 KB)
dill-0.3.2(Jun 15, 2020)
With dill, you can serialize almost anything in python, even an entire interpreter session. If you encounter any pickling failures, dill also has some good tools to help you discover why your object fails to pickle.

dill installs with easy_install or pip: $ pip install dill

dill requires: - python, version == 2.7 *or* version >= 3.5 *or* pypy

Optional requirements: - pyreadline, version >= 1.7.1 (install with $ pip install dill[readline]) - objgraph, version >= 1.7.2 (install with $ pip install dill[graph])

dill is licensed under 3-clause BSD:

>>> import dill >>> print (dill.license())

To cite dill:

>>> import dill >>> print (dill.citation())
Source code(tar.gz)
Source code(zip)
dill-0.3.2.zip(173.40 KB)
dill-0.3.2.tar.gz(149.59 KB)
dill-0.3.1.1(Sep 28, 2019)
With dill, you can serialize almost anything in python, even an entire interpreter session. If you encounter any pickling failures, dill also has some good tools to help you discover why your object fails to pickle.

dill installs with easy_install or pip: $ pip install dill

dill requires: - python, version >=2.6 *or* version >= 3.1 *or* pypy

Optional requirements: - pyreadline, version >= 1.7.1 (install with $ pip install dill[readline]) - objgraph, version >= 1.7.2 (install with $ pip install dill[graph])

dill is licensed under 3-clause BSD:

>>> import dill >>> print (dill.license())

To cite dill:

>>> import dill >>> print (dill.citation())
Source code(tar.gz)
Source code(zip)
dill-0.3.1.1.tar.gz(148.42 KB)
dill-0.3.1.1.zip(173.91 KB)
dill-0.3.0(Jun 26, 2019)
With dill, you can serialize almost anything in python, even an entire interpreter session. If you encounter any pickling failures, dill also has some good tools to help you discover why your object fails to pickle.

dill installs with easy_install or pip: $ pip install dill

dill requires: - python, version >=2.6 *or* version >= 3.1 *or* pypy

Optional requirements: - pyreadline, version >= 1.7.1 (install with $ pip install dill[readline]) - objgraph, version >= 1.7.2 (install with $ pip install dill[graph])

dill is licensed under 3-clause BSD:

>>> import dill >>> print (dill.license())

To cite dill:

>>> import dill >>> print (dill.citation())
Source code(tar.gz)
Source code(zip)
dill-0.3.0.tar.gz(147.82 KB)
dill-0.3.0.zip(172.60 KB)
dill-0.2.9(Jan 21, 2019)
With dill, you can serialize almost anything in python, even an entire interpreter session. If you encounter any pickling failures, dill also has some good tools to help you discover why your object fails to pickle.

dill installs with easy_install or pip: $ pip install dill

dill requires: - python, version >=2.5 *or* version >= 3.1 *or* pypy

Optional requirements: - pyreadline, version >= 1.7.1 (install with $ pip install dill[readline]) - objgraph, version >= 1.7.2 (install with $ pip install dill[graph])

dill is licensed under 3-clause BSD:

>>> import dill >>> print (dill.license())

To cite dill:

>>> import dill >>> print (dill.citation())
Source code(tar.gz)
Source code(zip)
dill-0.2.9.tar.gz(147.20 KB)
dill-0.2.9.zip(85.05 KB)
dill-0.2.8.2(Jun 22, 2018)
With dill, you can serialize almost anything in python, even an entire interpreter session. If you encounter any pickling failures, dill also has some good tools to help you discover why your object fails to pickle.

dill installs with easy_install or pip: $ pip install dill

dill requires: - python, version >=2.5 *or* version >= 3.1 *or* pypy

Optional requirements: - objgraph, version >= 1.7.2

dill is licensed under 3-clause BSD:

>>> import dill >>> print (dill.license())

To cite dill:

>>> import dill >>> print (dill.citation())
Source code(tar.gz)
Source code(zip)
dill-0.2.8.2.tar.gz(146.56 KB)
dill-0.2.8.2.zip(84.00 KB)
dill-0.2.8.1(Jun 21, 2018)
With dill, you can serialize almost anything in python, even an entire interpreter session. If you encounter any pickling failures, dill also has some good tools to help you discover why your object fails to pickle.

dill installs with easy_install or pip: $ pip install dill

dill requires: - python, version >=2.5 *or* version >= 3.1 *or* pypy

Optional requirements: - objgraph, version >= 1.7.2

dill is licensed under 3-clause BSD:

>>> import dill >>> print (dill.license())

To cite dill:

>>> import dill >>> print (dill.citation())
Source code(tar.gz)
Source code(zip)
dill-0.2.8.1.tar.gz(146.56 KB)
dill-0.2.8.1.zip(83.99 KB)
dill-0.2.8(Jun 21, 2018)
With dill, you can serialize almost anything in python, even an entire interpreter session. If you encounter any pickling failures, dill also has some good tools to help you discover why your object fails to pickle.

dill installs with easy_install or pip: $ pip install dill

dill requires: - python, version >=2.5 *or* version >= 3.1 *or* pypy

Optional requirements: - objgraph, version >= 1.7.2

dill is licensed under 3-clause BSD:

>>> import dill >>> print (dill.license())

To cite dill:

>>> import dill >>> print (dill.citation())
Source code(tar.gz)
Source code(zip)
dill-0.2.8.tar.gz(579.87 KB)
dill-0.2.8.zip(83.80 KB)
dill-0.2.7.1(Jul 18, 2017)
With dill, you can serialize almost anything in python, even an entire interpreter session. If you encounter any pickling failures, dill also has some good tools to help you discover why your object fails to pickle.

dill installs with easy_install or pip: $ easy_install dill

dill requires: - python, version >=2.5 *or* version >= 3.1 *or* pypy

Optional requirements: - objgraph, version >= 1.7.2

dill is licensed under 3-clause BSD:

>>> import dill >>> print (dill.license())

To cite dill:

>>> import dill >>> print (dill.citation())
Source code(tar.gz)
Source code(zip)
dill-0.2.7.1.tar.gz(62.97 KB)
dill-0.2.7.1.zip(83.04 KB)
dill-0.2.7(Jul 7, 2017)
With dill, you can serialize almost anything in python, even an entire interpreter session. If you encounter any pickling failures, dill also has some good tools to help you discover why your object fails to pickle.

dill installs with easy_install or pip: $ easy_install dill

dill requires: - python, version >=2.5 *or* version >= 3.1 *or* pypy

Optional requirements: - objgraph, version >= 1.7.2

dill is licensed under 3-clause BSD:

>>> import dill >>> print (dill.license())

To cite dill:

>>> import dill >>> print (dill.citation())
Source code(tar.gz)
Source code(zip)
dill-0.2.7.tar.gz(62.56 KB)
dill-0.2.7.zip(82.37 KB)
0.2.6(Feb 1, 2017)
With dill, you can serialize almost anything in python, even an entire interpreter session. If you encounter any pickling failures, dill also has some good tools to help you discover why your object fails to pickle.

dill installs with easy_install or pip: $ easy_install dill

dill requires: - python, version >=2.5 *or* version >= 3.1 *or* pypy

Optional requirements: - objgraph, version >= 1.7.2

dill is licensed under 3-clause BSD:

>>> import dill >>> print (dill.license())

To cite dill:

>>> import dill >>> print (dill.citation())
Source code(tar.gz)
Source code(zip)
dill-0.2.6.zip(81.41 KB)
dill-0.2.6.tgz(60.94 KB)
dill-0.2.5(Feb 6, 2016)
With dill, you can serialize almost anything in python, even an entire interpreter session. If you encounter any pickling failures, dill also has some good tools to help you discover why your object fails to pickle.

dill installs with easy_install or pip: $ easy_install dill

dill requires: - python, version >=2.5 *or* version >= 3.1

Optional requirements: - objgraph, version >= 1.7.2

dill is licensed under 3-clause BSD:

>>> import dill >>> print (dill.license())

To cite dill:

>>> import dill >>> print (dill.citation())
Source code(tar.gz)
Source code(zip)
dill-0.2.5.tgz(59.15 KB)
dill-0.2.5.zip(79.79 KB)
dill-0.2.4(Aug 5, 2015)
With dill, you can serialize almost anything in python, even an entire interpreter session. If you encounter any pickling failures, dill also has some good tools to help you discover why your object fails to pickle.

dill installs with easy_install or pip: $ easy_install dill

dill requires: - python, version >=2.5 *or* version >= 3.1

Optional requirements: - objgraph, version >= 1.7.2

dill is licensed under 3-clause BSD:

>>> import dill >>> print (dill.license())

To cite dill:

>>> import dill >>> print (dill.citation())
Source code(tar.gz)
Source code(zip)
dill-0.2.4.tgz(57.23 KB)
dill-0.2.4.zip(77.19 KB)
dill-0.2.3(Jun 22, 2015)
With dill, you can serialize almost anything in python, even an entire interpreter session. If you encounter any pickling failures, dill also has some good tools to help you discover why your object fails to pickle.

Dill installs with easy_install or pip: $ easy_install dill

Dill requires: - python, version >=2.5 *or* version >= 3.1

Optional requirements: - objgraph, version >= 1.7.2

Dill is licensed under 3-clause BSD:

>>> import dill >>> print (dill.license())

To cite dill:

>>> import dill >>> print (dill.citation())
Source code(tar.gz)
Source code(zip)
dill-0.2.3.zip(76.47 KB)
dill-0.2.3.tgz(56.26 KB)
dill-0.2.2(Dec 26, 2014)
With dill, you can serialize almost anything in python, even an entire interpreter session. If you encounter any pickling failures, dill also has some good tools to help you discover why your object fails to pickle.

Dill installs with easy_install or pip: $ easy_install dill

Dill requires: - python, version >=2.5 *or* version >= 3.1

Optional requirements: - objgraph, version >= 1.7.2

Dill is licensed under 3-clause BSD:

>>> import dill >>> print (dill.license())

To cite dill:

>>> import dill >>> print (dill.citation())
Source code(tar.gz)
Source code(zip)
dill-0.2.2.tgz(53.57 KB)
dill-0.2.2.zip(72.59 KB)
0.2.1(Jun 1, 2014)
With dill, you can serialize almost anything in python, even an entire interpreter session. If you encounter any pickling failures, dill also has some good tools to help you discover why your object fails to pickle.

Dill installs with easy_install or pip: $ easy_install dill

Dill requires: - python, version >=2.5 *or* version >= 3.1

Optional requirements: - objgraph, version >= 1.7.2

Dill is licensed under 3-clause BSD:

>>> import dill >>> print (dill.license())

To cite dill:

>>> import dill >>> print (dill.citation())
Source code(tar.gz)
Source code(zip)
dill-0.2.1.tgz(44.72 KB)
dill-0.2.1.zip(62.48 KB)
0.2(May 17, 2014)
With dill, you can serialize almost anything in python, even an entire interpreter session. If you encounter any pickling failures, dill also has some good tools to help you discover why your object fails to pickle.

Dill installs with easy_install or pip: $ easy_install dill

Dill requires: - python, version >=2.5 *or* version >= 3.1

Optional requirements: - objgraph, version >= 1.7.2

Dill is licensed under 3-clause BSD:

>>> import dill >>> print (dill.license())

To cite dill:

>>> import dill >>> print (dill.citation())
Source code(tar.gz)
Source code(zip)
dill-0.2.tgz(44.20 KB)
dill-0.2.zip(61.41 KB)
0.2b1(Nov 27, 2013)

With dill, you can serialize almost anything in python, even an entire interpreter session. If you encounter any pickling failures, dill also has some good tools to help you discover why your object fails to pickle.

Dill installs with easy_install or pip: $ easy_install dill

Dill requires: - python, version >=2.5 *or* version >= 3.1

Optional requirements: - objgraph, version >= 1.7.2

Dill is licensed under 3-clause BSD:>>> import dill >>> print (dill.license()) To cite dill:>>> import dill >>> print (dill.citation())
Source code(tar.gz)
Source code(zip)
dill-0.2b1.tgz(23.50 KB)
dill-0.2b1.zip(35.89 KB)
dill-0.2b1.win32.exe(90.52 KB)
0.2a1(Oct 20, 2013)

With dill, you can serialize almost anything in python, even an entire interpreter session. If you encounter any pickling failures, dill also has some good tools to help you discover why your object fails to pickle.

Dill installs with easy_install or pip: $ easy_install dill

Dill requires: - python, version >=2.5 *or* version >= 3.1

Optional requirements: - objgraph, version >= 1.7.2

Dill is licensed under 3-clause BSD:>>> import dill >>> print (dill.license()) To cite dill:>>> import dill >>> print (dill.citation())
Source code(tar.gz)
Source code(zip)
dill-0.2a1.zip(32.91 KB)
dill-0.2a1.tgz(23.66 KB)