Decovent 1.1.1
Python event handling using decorators
License: MIT
Keywords: event raise handle decorator

*Decovent* is a small Python library that allows an easy 
and elegant event rising and handling, using decorators. 

  New in this version: 
    * Private methods have been made public to facilitate inheritance

Basic example:

  | ``from decovent import *         #required import`` 
  | 
  | ``class Mouse(object):           #no special inheritance required``
  |   ``def __init__(self):``
  |       ``self.on_click()          #register handler (no arguments)``
  | 
  |   ``@raise_event()               #raises event *click*``
  |   ``def click(self, x, y):``
  |       ``return (x, y)``
  | 
  |   ``@raise_event()               #raises event *move*``
  |   ``def move(self, x, y): pass   #the event can be an empty method``
  | 
  |   ``@set_handler('click')        #handles event *click*``
  |   ``def on_click(self, x, y):    #arguments will be sent by the event``
  |       ``return (x, y)``
  | 
  | ``>> mouse = Mouse()             #the handler is registered`` 
  | ``>> e, h = mouse.click(10, 20)  #*click* event is raised and results`` 
  | ``>>                             #are returned as tuple in e and h``
  | ``>> mouse.move(30, 40)          #*move* event is raised, but unhandled`` 

Features:
 * Decovent has been tested with Python's both productive versions, 
   Python 2.6.4 and Python 3.1.1
 * events and handlers are tied to the local-thread
 * event name is case sensitive, Unicode safe and not required if it 
   equals the decorated method name
 * for an event can be registered as many handlers as necessary
 * handlers are registered for (class, event) pair, to differentiate between 
   events with similar names, but raised by different classes
 * a handler can be registered many times, but will be executed only once 
   for (class, event) pair
 * handlers execution order is the same as the registration order
 * handlers are always executed in parallel threads, synchronous or 
   asynchronous
 * parameters received by the handlers are being sent by the event
 * no arguments are required for a handler at registration time
 * a handler can be flagged to run only once for an event and then unregister 
   itself
 * @classmethods can be raised as events or registered as handlers
 * events and handlers can be memoized at local or global level
 * events and handlers can be synchronized on the same lock
 * the time allocated for the execution of an event or handler is controllable
 * the number of methods that can be executed in parallel is controllable 

Restrictions:
 * events and handlers must be methods that belong to new-style classes
 * @staticmethods can't be raised as events or registered as handlers
 * one handler can be registered for only one event 
 
It's important to understand that events and handlers are not classes but 
decorated methods that may belong to any new style class. There are no 
restrictions on the class itself regarding inheritance or the interfaces 
that are implemented.

Please see the documentation for the full list of features:
http://packages.python.org/Decovent