FM / multiprocess-0.70.12.2.dist-info

/usr/local/lib/python3.6/site-packages/multiprocess-0.70.12.2.dist-info/

/usr/local/lib/python3.6/site-packages/multiprocess-0.70.12.2.dist-info

Name	Size	Mode	Actions
DESCRIPTION.rst	5871	0644	edit dl rm
INSTALLER	4	0644	edit dl rm
METADATA	6919	0644	edit dl rm
metadata.json	1200	0644	edit dl rm
RECORD	5180	0644	edit dl rm
top_level.txt	27	0644	edit dl rm
WHEEL	93	0644	edit dl rm

Edit: /usr/local/lib/python3.6/site-packages/multiprocess-0.70.12.2.dist-info/METADATA (6919B)

Metadata-Version: 2.0
Name: multiprocess
Version: 0.70.12.2
Summary: better multiprocessing and multithreading in python
Home-page: https://github.com/uqfoundation/multiprocess
Author: Mike McKerns
Maintainer: Mike McKerns
License: BSD
Download-URL: https://github.com/uqfoundation/multiprocess/releases/download/multiprocess-0.70.12.2/multiprocess-0.70.12.2.tar.gz
Platform: UNKNOWN
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 :: 2.7
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.6
Classifier: Programming Language :: Python :: 3.7
Classifier: Programming Language :: Python :: 3.8
Classifier: Programming Language :: Python :: 3.9
Classifier: Topic :: Scientific/Engineering
Classifier: Topic :: Software Development
Requires-Dist: dill (>=0.3.4)

-----------------------------------------------------------------
multiprocess: better multiprocessing and multithreading in python
-----------------------------------------------------------------

About Multiprocess
====================

``multiprocess`` is a fork of ``multiprocessing``, and is developed as part of ``pathos``: 
https://github.com/uqfoundation/pathos

``multiprocessing`` is a package for the Python language which supports the
spawning of processes using the API of the standard library's
``threading`` module. ``multiprocessing`` has been distributed in the standard
library since python 2.6.

Features:

- Objects can be transferred between processes using pipes or multi-producer/multi-consumer queues.
    - Objects can be shared between processes using a server process or (for simple data) shared memory.
    - Equivalents of all the synchronization primitives in ``threading`` are available.
    - A ``Pool`` class makes it easy to submit tasks to a pool of worker processes.

``multiprocess`` is part of ``pathos``,  a python framework for heterogeneous computing.
``multiprocess`` 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/multiprocess/issues, with a legacy list maintained at https://uqfoundation.github.io/project/pathos/query.

NOTE: A C compiler is required to build the included extension module. For python 3.3 and above, a C compiler is suggested, but not required.

Major Changes
==============

- enhanced serialization, using ``dill``

Current Release
===============

This documentation is for version ``multiprocess-0.70.12.2`` (a fork of ``multiprocessing-0.70a1``).

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

https://pypi.org/project/multiprocess

``Multiprocessing`` is distributed under a 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.

Installation
============

``multiprocess`` is packaged to install from source, so you must
download the tarball, unzip, and run the installer::

[download]
    $ tar -xvzf multiprocess-0.70.12.2.tgz
    $ cd multiprocess-0.70.12.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, ``multiprocess`` can be installed with ``pip`` or ``easy_install``::

$ pip install multiprocess

NOTE: A C compiler is required to build the included extension module from source. For python 3.3 and above, a C compiler is suggested, but not required. Binary installs do not require a C compiler.

Requirements
============

``multiprocess`` requires::

- ``python``, **version == 2.7** or **version >= 3.6**, or ``pypy``
    - ``dill``, **version >= 0.3.4**

Optional requirements::

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

Basic Usage
===========

The ``multiprocess.Process`` class follows the API of ``threading.Thread``.
For example ::

from multiprocess import Process, Queue

def f(q):
        q.put('hello world')

if __name__ == '__main__':
        q = Queue()
        p = Process(target=f, args=[q])
        p.start()
        print (q.get())
        p.join()

Synchronization primitives like locks, semaphores and conditions are
available, for example ::

>>> from multiprocess import Condition
    >>> c = Condition()
    >>> print (c)
    <Condition(<RLock(None, 0)>), 0>
    >>> c.acquire()
    True
    >>> print (c)
    <Condition(<RLock(MainProcess, 1)>), 0>

One can also use a manager to create shared objects either in shared
memory or in a server process, for example ::

>>> from multiprocess import Manager
    >>> manager = Manager()
    >>> l = manager.list(range(10))
    >>> l.reverse()
    >>> print (l)
    [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
    >>> print (repr(l))
    <Proxy[list] object at 0x00E1B3B0>

Tasks can be offloaded to a pool of worker processes in various ways,
for example ::

>>> from multiprocess import Pool
    >>> def f(x): return x*x
    ...
    >>> p = Pool(4)
    >>> result = p.map_async(f, range(10))
    >>> print (result.get(timeout=1))
    [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

When ``dill`` is installed, serialization is extended to most objects,
for example ::

>>> from multiprocess import Pool
    >>> p = Pool(4)
    >>> print (p.map(lambda x: (lambda y:y**2)(x) + x, xrange(10)))
    [0, 2, 6, 12, 20, 30, 42, 56, 72, 90]

More Information
================

Probably the best way to get started is to look at the documentation at
http://multiprocess.rtfd.io. See ``multiprocess.examples`` for a set of example
scripts. You can also run the test suite with ``python -m multiprocess.tests``.
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
``multiprocess`` in your work, please post send an email
(to **mmckerns at uqfoundation dot org**).

Citation
========

If you use ``multiprocess`` to do research that leads to publication, we ask that you
acknowledge use of ``multiprocess`` 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/project/pathos

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

cmd: