Metadata-Version: 1.2
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
Description: -----------------------------------------------------------------
        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.
        
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
