========================================
 Changelog for the `processing` package
========================================

Changes in 0.34
---------------

* Although version 0.33 the C extension would compile on Mac OSX
  trying to import it failed with "undefined symbol: _sem_timedwait".
  Unfortunately the `ImportError `exception was silently swallowed.
  
  This is now fixed by using the `NO_SEM_TIMED` macro.  Unfortunately
  this means that some methods like `Condition.wait()` and
  `Queue.get()` will not work with timeouts on Mac OS X.  If you
  really need to be able to use timeouts then you can always use the
  equivalent objects created with a manager.  Thanks to Doug Hellmann
  for report and testing.
  
* Added a `terminate()` method to process objects which is more
  forceful than `stop()`.

* Fixed bug in the cleanup function registered with `atexit` which on
  Windows could cause a process which is shutting down to deadlock
  waiting for a manager to exit.  Thanks to Dominique Wahli for report
  and testing.
  
* Added `test/test_workers.py` which gives an example of how to create
  a collection of worker processes which execute tasks from one queue
  and return results on another.

* Added `processing.Pool()` which returns a process pool object.  This
  allows one to execute functions asynchronously.  It also has a
  parallel implementation of the `map()` builtin.  This is still
  *experimental* and undocumented --- see `test/test_pool.py` for
  example usage.


Changes in 0.33
---------------

* Added a `recvbytes_into()` method for receiving byte data into
  objects with the writable buffer interface.  Also renamed the
  `_recv_string()` and `_send_string()` methods of connection objects
  to `recvbytes()` and `sendbytes()`.

* Some optimizations for the transferring of large blocks of data
  using connection objects.

* On Unix `os.sysconf()` is now used by default to determine whether
  to compile in support for posix semaphores or posix message queues.
  
  By using the `NO_SEM_TIMED` and `NO_MQ_TIMED` macros (see
  `INSTALL.txt`) it should now also be possible to compile in
  (partial) semaphore or queue support on Unix systems which lack the
  timeout functions `sem_timedwait()` or `mq_timedreceive()` and
  `mq_timesend()`.

* `gettimeofday()` is now used instead of `clock_gettime()` making
  compilation of the C extension (hopefully) possible on Mac OSX.  No
  modificaton of `setup.py` should be necessary.  Thanks to Michele
  Bertoldi for report and proposed patch.

* `cpuCount()` function added which returns the number of CPUs
  in the system.

* Bugfixes to `PosixQueue` class.


Changes in 0.32
---------------

* Refactored and simplified `_nonforking` module -- info about
  `sys.modules` of parent process is no longer passed on to child
  process.  Also `pkgutil` is no longer used.

* Allocated space from an mmap used by `LocalManager` will now be
  recycled.

* Better tests for `LocalManager`.

* Fixed bug in `managers.py` concerning refcounting of shared objects.
  Bug affects the case where the callable used to create a shared
  object does not return a unique object each time it is called.
  Thanks to Alexey Akimov for the report.

* Added a `freezeSupport()` function. Calling this at the appropriate
  point in the main module is necessary when freezing a multiprocess
  program to produce a Windows executable.  (Has been tested with
  `py2exe`, `PyInstaller` and `cx_Freeze`.)


Changes in 0.31
---------------

* Fixed one line bug in `localmanager.py` which caused shared memory maps
  not to be resized properly.

* Added tests for shared values/structs/arrays to `test/test_processing`.


Changes in 0.30
----------------

* Process objects now support the complete API of thread objects.

  In particular `isAlive()`, `isDaemon()`, `setDaemon()` have been
  added and `join()` now supports the `timeout` paramater.

  There are also new methods `stop()`, `getPid()` and `getExitCode()`.
  
* Implemented synchronization primitives based on the Windows mutexes
  and semaphores and posix named semaphores.  

* Added support for sharing simple objects between processes by using
  a shared memory map and the `struct` or `array` modules.

* An `activeChildren()` function has been added to `processing` which
  returns a list of the child processes which are still alive.

* A `Pipe()` function has been added which returns a pair of
  connection objects representing the ends of a duplex connection over
  which picklable objects can be sent.

* socket objects etc are now picklable and can be transferred between
  processes.  (Requires compilation of the `_processing` extension.)

* Subclasses of `managers.BaseManager` no longer automatically spawn a
  child process when an instance is created: the `start()` method must be
  called explicitly.

* On Windows child processes are now spawned using `subprocess`.

* On Windows the Python 2.5 version of `pkgutil` is now used for
  loading modules by the `_nonforking` module.  On Python 2.4 this
  version of `pkgutil` (which uses the standard Python licence) is
  included in `processing.compat`.

* The arguments to the functions in `processing.connection` have
  changed slightly.

* Connection objects now have a `poll()` method which tests whether
  there is any data available for reading.

* The `test/py2exedemo` folder shows how to get `py2exe` to create a
  Windows executable from a program using the `processing` package.

* More tests.

* Bugfixes.

* Rearrangement of various stuff.


Changes in 0.21
---------------

* By default a proxy is now only able to access those methods of its
  referent which have been explicitly exposed.

* The `connection` sub-package now supports digest authentication.

* Process objects are now given randomly generated 'inheritable'
  authentication keys.

* A manager process will now only accept connections from processes
  using the same authentication key.

* Previously `get_module()` from `_nonforking.py` was seriously messed
  up (though it generally worked).  It is a lot saner now.

* Python 2.4 or higher is now required.


Changes in 0.20
---------------

* The `doc` folder contains HTML documentation.

* `test` is now a subpackage.  Running `processing.test.main()` 
  will run test scripts using both processes and threads.

* `nonforking.py` has been renamed `_nonforking.py`.
  `manager.py` has been renamed `manager.py`.
  `connection.py` has become a sub-package `connection`

* `Listener` and `Client` have been removed from
  `processing`, but still exist in `processing.connection`.

* The package is now *probably* compatible with versions of Python
  earlier than 2.4.

* `set` is no longer a type supported by the default manager type.

* Many more changes.


Changes in 0.12
---------------

* Fixed bug where the arguments to `processing.Manager()` were passed on
  to `processing.manager.DefaultManager()` in the wrong order.

* `processing.dummy` is now a subpackage of `processing`
  instead of a module.

* Rearranged package so that the `test` folder, `README.txt` and
  `CHANGES.txt` are copied when the package is installed.


Changes in 0.11
---------------

* Fixed bug on windows when the full path of `nonforking.py` contains a
  space.

* On unix there is no longer a need to make the arguments to the
  constructor of `Process` be picklable or for and instance of a
  subclass of `Process` to be picklable when you call the start method.

* On unix proxies which a child process inherits from its parent can
  be used by the child without any problem, so there is no longer a
  need to pass them as arguments to `Process`.  (This will never be
  possible on windows.)
