Metadata-Version: 2.2
Name: multiprocessing_on_dill
Version: 3.5.0a4
Summary: A friendly fork of multiprocessing which uses dill instead of pickle
Home-page: https://github.com/sixty-north/multiprocessing_on_dill
Author: Robert Smallshire
Author-email: rob@sixty-north.com
License: PSFL
Keywords: multiprocessing parallel
Classifier: Development Status :: 5 - Production/Stable
Classifier: Intended Audience :: Developers
Classifier: Topic :: Software Development :: Libraries :: Python Modules
Classifier: License :: OSI Approved :: Python Software Foundation License
Classifier: Programming Language :: Python :: 3 :: Only
Requires-Dist: dill
Provides-Extra: dev
Requires-Dist: check-manifest; extra == "dev"
Requires-Dist: wheel; extra == "dev"
Dynamic: author
Dynamic: author-email
Dynamic: classifier
Dynamic: description
Dynamic: home-page
Dynamic: keywords
Dynamic: license
Dynamic: provides-extra
Dynamic: requires-dist
Dynamic: summary

Multiprocessing on Dill
=======================

This project is a friendly fork – for Python 3 – of the Python Standard Library `multiprocessing
<https://docs.python.org/3/library/multiprocessing.html>`_ module, which uses the third-party
`dill <https://pypi.python.org/pypi/dill>`_ serializer instead of the standard ``pickle`` serializer.  This overcomes
many shortcomings of ``pickle`` which prevent multiprocessing being used with lambdas, closures and other useful Python
objects.

The easiest way to use ``multiprocessing_on_dill`` in place of ``multiprocessing`` is simply to replace any import
statements like this::

    import multiprocessing

with::

    import multiprocessing_on_dill as multiprocessing

and import statements like this::

    from multiprocessing import Pool

with::

    from multiprocessing_on_dill import Pool

With such import changes in place, it will now be possible to use functions like ``Pool.map()`` with lambdas::

    pool = Pool(12)
    result = pool.map(lambda x: x*x, range(10000))

Everything else should be identical to the Python version.

You can determine from which version of the Python Standard Library ``multiprocessing_on_dill`` has been forked, by
examining the ``multiprocessing_on_dill.__version__`` attribute.


Future
======

It is our hope that one day the Python Standard Library ``pickle`` module will gain the additional capabilities of
``dill`` and there will no longer be a need for ``multiprocessing_on_dill`` to exist.
