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

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.)
