def __init__(self, sender=None, asynch=False, exc_info=False,<EOL>threads=<NUM_LIT:3>, traceback=False):
if asynch and threads == <NUM_LIT:0>:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>self.asynch = bool(asynch)<EOL>self.exc_info = bool(exc_info)<EOL>self.sender = sender<EOL>self.threads = int(threads)<EOL>self.traceback = bool(traceback)<EOL>self.handlers = {}<EOL>self.memoize = {}<EOL>self._hlock = RLock()<EOL>self._mlock = RLock()<EOL>
Creates an event 

        asynch
            if True, handlers are executed asynchronously (the main thread is not 
            waiting for handlers execution to complete). In this case, no data
            regarding the success and result of the execution is returned.
        exc_info
            if True, result will contain sys.exc_info()[:2] on error
        sender
            event's sender. The sender is passed as the first argument to the 
            handler, only if is not None. For this case the handler must have
            a placeholder in the arguments to receive the sender
        threads
            maximum number of threads that will be started for handlers execution             
            threads = 0: 
                - synchronized execution in the main thread
                - asynch must be False 
            threads = 1: 
                - synchronized execution in separate thread
                - asynch can be True or False 
            threads > 1: 
                - desynchronized execution in separate threads
                - asynch can be True or False              
            visual representation:
                threads = 0:
                    [Main Thread]: event (handler1, handler2, handler3, handler4)
                    [Main Thread]: ..handler1, handler2, handler3, handler4
                threads = 1:
                    [Main Thread]: event (handler1, handler2, handler3, handler4)
                       [Thread-1]: ..handler1, handler2, handler3, handler4
                threads > 1 (let's say 2): (thread switch is not accurate)
                    [Main Thread]: event (handler1, handler2, handler3, handler4)
                       [Thread-1]: ..handler1 <= assume short running
                       [Thread-2]: ..handler2 <= assume long running 
                       [Thread-1]: ..handler3 <= assume short running
                       [Thread-1]: ..handler4 <= assume short running
        traceback
            if True, the execution result will contain sys.exc_info() 
            on error. exc_info must be also True to get the traceback      

        hash = hash(handler)

        Handlers are stored in a dictionary that has as keys the handler's hash        
            handlers = { 
                hash : (handler, memoize, timeout),
                hash : (handler, memoize, timeout), ... 
            }
        The execution result is cached using the following structure    
            memoize = { 
                hash : ((args, kw, result), (args, kw, result), ...), 
                hash : ((args, kw, result), ...), ...                      
            } 
        The execution result is returned as a tuple having this structure
            exec_result = (
                (True, result, handler),        # on success
                (False, error_info, handler),   # on error 
                (None, None, handler), ...      # asynchronous execution
            )