python-billiard-3.5.0.2-bp150.1.3

- update to version 3.5.0.2:
  * max_memory_per_child was measured in kilobytes on Linux, but
    bytes on *BSD/MacOS, it's now always kilobytes.
  * Windows: Adds support for max_memory_per_child, but requires
    the psutil package to be installed.
  * Fixed bug in ForkingPickler.loadbuf, where it tried to pass
    a BytesIO instance directly to ``pickle.loads`` on Python 2.7.
- additional changes from version 3.5.0.1:
  * Connection: Properly handle EINTR (Issue #191).
  * Fixed bug with missing CreateProcess for Windows on Python 2.7.
  * Adds Process._counter for compatibility with Python <3.5.
- additional changes from version 3.5.0.0:
  * No longer supports Python 2.6
    You need Python 2.7 or later to use this version of billiard.
  * Merged changes from CPython 3.5
- convert the package to singlespec and import changes from
  python3-billiard
- change the source URL to pythonhosted.org
- update the BuildRequires for test:
  * remove mock, nose and unittest2
  * add case and pytest
- split the documentation to a separate package
- remove the shebang cleanup: not needed anymore

- Update to version 3.3.0.22:
  * Wheel packages for Windows now available.
- Changes from 3.3.0.21:
  * Pool: Fixed semaphore error on Python3.
  * Fixed libSystem error on OS X El Capitan.

- update to version 3.3.0.20:
  * Pool: Timeouts will attempt to send SIGKILL, but this signal
    does not exist on Windows.  Replaced with SIGTERM.
- additional changes from version 3.3.0.19:
  * Pool: Exceptions in user timeout callbacks are now logged
    instead of crashing the pool. Contributed by Pierre Fersing.
  * Pool: Exit codes in errors were improperly being represented
    as signals.
  * Pool: ``.map``. and ``.imap`` now working again.
  * Now builds on FreeBSD 10. Contributed by Michael Fladischer.
- update project URL
- add fdupes as BuildRequires and call it after install
- remove BuildRequires python-nose-cover3, not needed by the tests
  anymore
- set a minimum version for python-nose
- remove unwanted shebang of funtests/setup.py
- add -fno-strict-aliasing to CFLAGS to avoid potential breakage

- Update to 3.3.0.18
  - see https://pypi.python.org/pypi/billiard for complete changelog

- Update to version 3.3.0.8:
  + Now also sets ``multiprocessing.current_process`` for compatibility
    with loggings ``processName`` field

- Update to version 3.3.0.6
  + Now works without C extension again.
  + New ``_billiard.read(fd, buffer, [len, ])` function
    implements os.read with buffer support (new buffer API)
  + New pure-python implementation of ``Connection.send_offset``.
- Changes from 3.3.0.5
  + All platforms except for Windows/PyPy/Jython now requires the C extension.
- Changes from 3.3.0.4
  + Fixed problem with Python3 and setblocking.
- Changes from 3.3.0.3
  + Now works on Windows again.
- Changes from 3.3.0.2
  + ApplyResult.terminate() may be set to signify that the job
    must not be executed.  It can be used in combination with
    Pool.terminate_job.
  + Pipe/_SimpleQueue: Now supports rnonblock/wnonblock arguments
    to set the read or write end of the pipe to be nonblocking.
  + Pool: Log message included exception info but exception happened
    in another process so the resulting traceback was wrong.
  + Pool: Worker process can now prepare results before they are sent
    back to the main process (using ``Worker.prepare_result``).
- Changes from 3.3.0.1
  + Pool: New ``correlation_id`` argument to ``apply_async`` can be
    used to set a related id for the ``ApplyResult`` object returned:
    >>> r = pool.apply_async(target, args, kwargs, correlation_id='foo')
    >>> r.correlation_id
    'foo'
  + Pool: New callback `on_process_exit` is called when a pool
    process exits, with signature ``(pid, exitcode)``.
  + Pool: Improved the too many restarts detection.
- Changes from 3.3.0.0
  + Dual code base now runs on Python 2.6+ and Python 3.
  + No longer compatible with Python 2.5
  + Includes many changes from multiprocessing in 3.4.
  + Now uses ``time.monotonic`` when available, also including
    fallback implementations for Linux and OS X.
  + No longer cleans up after receiving SIGILL, SIGSEGV or SIGFPE
  + ``Finalize`` and ``register_after_fork`` is now aliases to multiprocessing.
    It's better to import these from multiprocessing directly now
    so that there aren't multiple registries.
  + New `billiard.queues._SimpleQueue` that does not use semaphores.
  + Pool: Can now be extended to support using multiple IPC queues.
  + Pool: Can now use async I/O to write to pool IPC queues.
  + Pool: New ``Worker.on_loop_stop`` handler can be used to add actions
    at pool worker process shutdown.
    Note that, like all finalization handlers, there is no guarantee that
    this will be executed.

- Require python-setuptools instead of distribute (upstreams merged)

- Update to version 2.7.3.32
  + Fixed compatibility with Python 3.3
  + Process boostrap: Now ignores errors while flushing stdout (Issue #16)
- Changes from version 2.7.3.31
  + Recent changes broke support for running without C extension (Issue #57)
- Changes from version 2.7.3.30
  + Fixed ImportError in billiard._ext
- Changes from version 2.7.3.29
  + Compilation: Fixed improper handling of HAVE_SEM_OPEN (Issue #55)
  + Process now releases logging locks after fork.
  + Pool.terminate_job now ignores No such process errors.
  + billiard.Pool entrypoint did not support new arguments to billiard.pool.Pool
  + Connection inbound buffer size increased from 1kb to 128kb.
  + C extension cleaned up by properly adding a namespace to symbols.
  +_exit_function now works even if thread wakes up after gc collect.

- Update to version 2.7.3.28:
  + Pool: Fixed regression that disabled the deadlock fix in 2.7.3.24
  + Pool: RestartFreqExceeded could be raised prematurely.
  + Process: Include pid in startup and process INFO logs.
- Changes from version 2.7.3.27:
  + Manager now works again.
  + Python 3 fixes for billiard.connection.
  + Fixed invalid argument bug when running on Python 3.3
  + Ignore OSError when setting up signal handlers.
- Changes from version 2.7.3.26:
  + Pool: Child processes must ignore SIGINT.
- Changes from version 2.7.3.25:
  + Pool: 2.7.3.24 broke support for subprocesses (Issue #48).
- Changes from version 2.7.3.24:
  + Pool:  Make sure finally blocks are called when process exits due to a signal.
  + Pool:  Can now use GDB to debug pool child processes.
  + Fixes Python 3 compatibility problems.

- Update to 2.7.3.23:
  - Windows: Now catches SystemExit from setuptools while trying to
    build the C extension (Issue #41).
- Aditional changes from 2.7.3.22:
  - Pool: apply_async now supports a callbacks_propagate keyword
    argument that can be a tuple of exceptions to propagate in
    callbacks. (callback, errback, accept_callback, timeout_callback).
  - Errors are no longer logged for OK and recycle exit codes.
    This would cause normal maxtasksperchild recycled process
    to log an error.
  - Fixed Python 2.5 compatibility problem (Issue #33).
  - FreeBSD: Compilation now disables semaphores if Python was built
    without it (Issue #40).
    Contributed by William Grzybowski
- Aditional changes from 2.7.3.21:
  - Fixed typo EX_REUSE -> EX_RECYCLE
  - Code now conforms to new pep8.py rules.
- Aditional changes from 2.7.3.20:
  - Pool: Disable restart limit if maxR is not set.
  - Pool: Now uses os.kill instead of signal.signal.
    Contributed by Lukasz Langa
  - Fixed name error in process.py
  - Pool: ApplyResult.get now properly raises exceptions.
    Fix contributed by xentac.

- Update to 2.7.3.19:
  * Fixes problem at shutdown when gc has collected symbols.
  * Pool now always uses _kill for Py2.5 compatibility on Windows (Issue
    [#32]).
  * Fixes Python 3 compatibility issues

- Update to 2.7.3.18:
  * [Pool] Fix for check_timeouts if not set.
    Fix contributed by Dmitry Sukhov
  * Fixed pickle problem with Traceback.
    Code.frame.__loader__ is now ignored as it may be set to an unpickleable
    object.
  * The Django old-layout warning was always showing.
  2.7.3.17 - 2012-09-26
  * Fixes typo
  2.7.3.16 - 2012-09-26
  * Windows: Fixes for SemLock._rebuild (Issue #24).
  * Pool: Job terminated with terminate_job now raises
    billiard.exceptions.Terminated.
  2.7.3.15 - 2012-09-21
  * Windows: Fixes unpickling of SemLock when using fallback.
  * Windows: Fixes installation when no C compiler.
  2.7.3.14 - 2012-09-20
  * Installation now works again for Python 3.
  2.7.3.13 - 2012-09-14
  * Merged with Python trunk (many authors, many fixes: see Python changelog
    in trunk).
  * Using execv now also works with older Django projects using setup_environ
    (Issue #10).
  * Billiard now installs with a warning that the C extension could not be
    built if a compiler is not installed or the build fails in some other way.
    It really is recommended to have the C extension installed when running
    with force execv, but this change also makes it easier to install.
  * Pool: Hard timeouts now sends KILL shortly after TERM so that C extensions
    cannot block the signal.
    Python signal handlers are called in the interpreter, so they cannot be
    called while a C extension is blocking the interpreter from running.
  * Now uses a timeout value for Thread.join that doesn't exceed the maximum
    on some platforms.
  * Fixed bug in the SemLock fallback used when C extensions not installed.
    Fix contributed by Mher Movsisyan.
  * Pool: Now sets a Process.index attribute for every process in the pool.
    This number will always be between 0 and concurrency-1, and can be used
    to e.g. create a logfile for each process in the pool without creating a
    new logfile whenever a process is replaced.
  2.7.3.12 - 2012-08-05
  * Fixed Python 2.5 compatibility issue.
  * New Pool.terminate_job(pid) to terminate a job without raising
    WorkerLostError
  2.7.3.11 - 2012-08-01
  * Adds support for FreeBSD 7+
    Fix contributed by koobs.
  * Pool: New argument allow_restart is now required to enable the pool
    process sentinel that is required to restart the pool.
    It's disabled by default, which reduces the number of file descriptors/
    semaphores required to run the pool.
  * Pool: Now emits a warning if a worker process exited with error-code.
    But not if the error code is 155, which is now returned if the worker
    process was recycled (maxtasksperchild).
  * Python 3 compatibility fixes.
  * Python 2.5 compatibility fixes.
  2.7.3.10 - 2012-06-26
  * The TimeLimitExceeded exception string representation only included the
    seconds as a number, it now gives a more human friendly description.
  * Fixed typo in LaxBoundedSemaphore.shrink.
  * Pool: ResultHandler.handle_event no longer requires any arguments.
  * setup.py bdist now works
  2.7.3.9 - 2012-06-03
  * Environment variable MP_MAIN_FILE envvar is now set to the path of the
    __main__ module when execv is enabled.
  * Pool: Errors occurring in the TaskHandler are now reported.
  2.7.3.8 - 2012-06-01
  * Can now be installed on Py 3.2
  * Issue #12091: simplify ApplyResult and MapResult with threading.Event
    Patch by Charles-Francois Natali
  * Pool: Support running without TimeoutHandler thread.
  * The with_*_thread arguments has also been replaced with a single
    threads=True argument.
  * Two new pool callbacks:
  * on_timeout_set(job, soft, hard)
    Applied when a task is executed with a timeout.
  * on_timeout_cancel(job)
    Applied when a timeout is cancelled (the job completed)

- Update to 2.7.3.7
  * 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)
  * Pool: Process too frequent restart protection now only counts if the
    process had a non-successful exitcode.
  * Pool: New options max_restart + max_restart_freq
  * Pool: The ``WorkerLostError`` message now includes the exitcode of the
    process that disappeared.
- Build HTML docs

- Update to 2.7.3.5
  * 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.

- Update to 2.7.3.4
  * Added billiard.ensure_multiprocessing() - Raises NotImplementedError if
    the platform does not support multiprocessing (e.g. Jython).

- Generate new spec
- Update to 2.7.3.3
  * 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)

- Update to 0.3.1
  * Fixed broken bool evaluation in supervisor. Thanks to jonozzz
    The bug originated from a ``a if x else b`` vs. ``x and a or bz``
    confusion when porting code to Python 2.4.
  * ``ApplyResult._set`` can't delete the result if it's not been accepted.
    This also means ``ApplyResult._ack`` needs to delete the result if the job
    has been marked ready.
- 0.3.0
  * Added support for accept callbacks.
- 0.2.3
  * Python 2.4 support.

- Initial import