Metadata-Version: 1.0
Name: billiard
Version: 2.7.3.7
Summary: Python multiprocessing fork
Home-page: http://github.com/ask/billiard
Author: Ask Solem',
Author-email: ask@celeryproject.org
License: BSD
Description: ==================================
        python-multiprocessing
        ==================================
        
        About
        -----
        
        `billiard` is a fork of the Python 2.7 `multiprocessing <http://docs.python.org/library/multiprocessing.html>`_
        package. The multiprocessing package itself is a renamed and updated version of
        R Oudkerk's `pyprocessing <http://pypi.python.org/pypi/processing/>`_ package.
        This standalone variant is intended to be compatible with Python 2.4 and 2.5,
        and will draw it's fixes/improvements from python-trunk.
        
        - This package would not be possible if not for the contributions of not only
        the current maintainers but all of the contributors to the original pyprocessing
        package listed `here <http://pyprocessing.berlios.de/doc/THANKS.html>`_
        
        - Also it is a fork of the multiprocessin backport package by Christian Heims.
        
        - It includes the no-execv patch contributed by sbt.
        
        - And the Pool improvements previously located in `Celery`_.
        
        .. _`Celery`: http://celeryproject.org
        
        
        Bug reporting
        -------------
        
        Please report bugs related to multiprocessing at the
        `Python bug tracker <http://bugs.python.org/>`_. Issues related to billiard
        should be reported at http://github.com/ask/billiard/issues.
        
        
        ===========
        Changes
        ===========
        
        2.7.3.7 - 2012-05-21
        --------------------
        
        - Fixes Python 2.5 support.
        
        2.7.3.6 - 2012-05-21
        --------------------
        
        - Pool: Can now be used in an event loop, without starting the supporting
        threads (TimeoutHandler still not supported)
        
        To facilitate this the pool has gained the following keyword arguments:
        
        - ``with_task_thread``
        - ``with_result_thread``
        - ``with_supervisor_thread``
        - ``on_process_up``
        
        Callback called with Process instance as argument
        whenever a new worker process is added.
        
        Used to add new process fds to the eventloop::
        
        def on_process_up(proc):
        hub.add_reader(proc.sentinel, pool.maintain_pool)
        
        - ``on_process_down``
        
        Callback called with Process instance as argument
        whenever a new worker process is found dead.
        
        Used to remove process fds from the eventloop::
        
        def on_process_down(proc):
        hub.remove(proc.sentinel)
        
        - ``semaphore``
        
        Sets the semaphore used to protect from adding new items to the
        pool when no processes available.  The default is a threaded
        one, so this can be used to change to an async semaphore.
        
        And the following attributes::
        
        - ``readers``
        
        A map of ``fd`` -> ``callback``, to be registered in an eventloop.
        Currently this is only the result outqueue with a callback
        that processes all currently incoming results.
        
        And the following methods::
        
        - ``did_start_ok``
        
        To be called after starting the pool, and after setting up the
        eventloop with the pool fds, to ensure that the worker processes
        didn't immediately exit caused by an error (internal/memory).
        
        - ``maintain_pool``
        
        Public version of ``_maintain_pool`` that handles max restarts.
        
        - Pool: Process too frequent restart protection now only counts if the process
        had a non-successful exitcode.
        
        This to take into account the maxtasksperchild option, and allowing
        processes to exit cleanly on their own.
        
        - Pool: New options max_restart + max_restart_freq
        
        This means that the supervisor can't restart processes
        faster than max_restart' times per max_restart_freq seconds
        (like the Erlang supervisor maxR & maxT settings).
        
        The pool is closed and joined if the max restart
        frequency is exceeded, where previously it would keep restarting
        at an unlimited rate, possibly crashing the system.
        
        The current default value is to stop if it exceeds
        100 * process_count restarts in 1 seconds.  This may change later.
        
        It will only count processes with an unsuccessful exit code,
        this is to take into account the ``maxtasksperchild`` setting
        and code that voluntarily exits.
        
        - Pool: The ``WorkerLostError`` message now includes the exitcode of the
        process that disappeared.
        
        
        2.7.3.5 - 2012-05-09
        --------------------
        
        - Now always cleans up after ``sys.exc_info()`` to avoid
        cyclic references.
        
        - ExceptionInfo without arguments now defaults to ``sys.exc_info``.
        
        - Forking can now be disabled using the
        ``MULTIPROCESSING_FORKING_DISABLE`` environment variable.
        
        Also this envvar is set so that the behavior is inherited
        after execv.
        
        - The semaphore cleanup process started when execv is used
        now sets a useful process name if the ``setproctitle``
        module is installed.
        
        - Sets the ``FORKED_BY_MULTIPROCESSING``
        environment variable if forking is disabled.
        
        
        2.7.3.4 - 2012-04-27
        --------------------
        
        - Added `billiard.ensure_multiprocessing()`
        
        Raises NotImplementedError if the platform does not support
        multiprocessing (e.g. Jython).
        
        
        2.7.3.3 - 2012-04-23
        --------------------
        
        - PyPy now falls back to using its internal _multiprocessing module,
        so everything works except for forking_enable(False) (which
        silently degrades).
        
        - Fixed Python 2.5 compat issues.
        
        - Uses more with statements
        
        - Merged some of the changes from the Python 3 branch.
        
        2.7.3.2 - 2012-04-20
        --------------------
        
        - Now installs on PyPy/Jython (but does not work).
        
        2.7.3.1 - 2012-04-20
        --------------------
        
        - Python 2.5 support added.
        
        2.7.3.0 - 2012-04-20
        --------------------
        
        - Updated from Python 2.7.3
        
        - Python 2.4 support removed, now only supports 2.5, 2.6 and 2.7.
        (may consider py3k support at some point).
        
        - Pool improvments from Celery.
        
        - no-execv patch added (http://bugs.python.org/issue8713)
        
Platform: UNKNOWN
Classifier: Development Status :: 5 - Production/Stable
Classifier: Intended Audience :: Developers
Classifier: Programming Language :: Python
Classifier: Programming Language :: C
Classifier: Operating System :: Microsoft :: Windows
Classifier: Operating System :: POSIX
Classifier: License :: OSI Approved :: BSD License
Classifier: Topic :: Software Development :: Libraries :: Python Modules
