
    tf                         d dl mZ d dlmZ d dlmZmZmZmZm	Z	m
Z
mZmZmZmZ  G d de      Z ede      Z G d d	      Zy
)    )OrderedDict)Lock)
AnyCallableDictListMappingOptionalSetTupleTypeVarUnionc                       e Zd ZdZy)PyeeExceptionzAn exception internal to pyee.N)__name__
__module____qualname____doc__     S/var/www/html/software/conda/envs/higlass/lib/python3.12/site-packages/pyee/base.pyr   r      s    (r   r   Handler)boundc                      e Zd ZdZddZdeeef   fdZdeeef   ddfdZ		 dded	e
e   deeeegef   f   fd
Zdedeegef   fdZded	edefdZdededefdZd	edeedf   deeef   ddfdZdee   fdZdededdfdZdedeedf   deeef   defdZdedededefdZ	 dded	e
e   defdZded	eddfdZded	eddfdZdde
e   ddfdZdedee   fdZ y) EventEmittera  The base event emitter class. All other event emitters inherit from
    this class.

    Most events are registered with an emitter via the `on` and `once`
    methods, and fired with the `emit` method. However, pyee event emitters
    have two *special* events:

    - `new_listener`: Fires whenever a new listener is created. Listeners for
      this event do not fire upon their own creation.

    - `error`: When emitted raises an Exception by default, behavior can be
      overridden by attaching callback to the event.

      For example:

    ```py
    @ee.on('error')
    def on_error(message):
        logging.err(message)

    ee.emit('error', Exception('something blew up'))
    ```

    All callbacks are handled in a synchronous, blocking manner. As in node.js,
    raised exceptions are not automatically handled for you---you must catch
    your own exceptions, and treat them accordingly.
    returnNc                 @    t               | _        t               | _        y N)dict_eventsr   _lockselfs    r   __init__zEventEmitter.__init__7   s     F 	  6
r   c                 @    | j                   j                         }|d= |S )Nr!   )__dict__copyr#   states     r   __getstate__zEventEmitter.__getstate__>   s     ""$'Nr   r)   c                 X    | j                   j                  |       t               | _        y r   )r&   updater   r!   r(   s     r   __setstate__zEventEmitter.__setstate__C   s    U#V
r   eventfc                 L    || j                  |      S | j                  ||      S )au  Registers the function `f` to the event name `event`, if provided.

        If `f` isn't provided, this method calls `EventEmitter#listens_to`, and
        otherwise calls `EventEmitter#add_listener`. In other words, you may either
        use it as a decorator:

        ```py
        @ee.on('data')
        def data_handler(data):
            print(data)
        ```

        Or directly:

        ```py
        ee.on('data', data_handler)
        ```

        In both the decorated and undecorated forms, the event handler is
        returned. The upshot of this is that you can call decorated handlers
        directly, as well as use them in remove_listener calls.

        Note that this method's return type is a union type. If you are using
        mypy or pyright, you will probably want to use either
        `EventEmitter#listens_to` or `EventEmitter#add_listener`.
        )
listens_toadd_listenerr#   r.   r/   s      r   onzEventEmitter.onG   s+    : 9??5))$$UA..r   c                 0     dt         dt         f fd}|S )aV  Returns a decorator which will register the decorated function to
        the event name `event`:

        ```py
        @ee.listens_to("event")
        def data_handler(data):
            print(data)
        ```

        By only supporting the decorator use case, this method has improved
        type safety over `EventEmitter#on`.
        r/   r   c                 .    j                  | |        | S r   _add_event_handler)r/   r.   r#   s    r   r4   z#EventEmitter.listens_to.<locals>.onw   s    ##E1a0Hr   )r   )r#   r.   r4   s   `` r   r1   zEventEmitter.listens_toi   s    	' 	g 	 	r   c                 ,    | j                  |||       |S )a:  Register the function `f` to the event name `event`:

        ```
        def data_handler(data):
            print(data)

        h = ee.add_listener("event", data_handler)
        ```

        By not supporting the decorator use case, this method has improved
        type safety over `EventEmitter#on`.
        r7   r3   s      r   r2   zEventEmitter.add_listener}   s     	q!,r   kvc                     | j                  d||       | j                  5  || j                  vrt               | j                  |<   || j                  |   |<   d d d        y # 1 sw Y   y xY w)Nnew_listener)emitr!   r    r   )r#   r.   r:   r;   s       r   r8   zEventEmitter._add_event_handler   s_    		.%+ ZZ 	'DLL(&1mU#%&DLL"	' 	' 	's   8A!!A*args.kwargsc                      ||i | y r   r   )r#   r/   r?   r@   s       r   	_emit_runzEventEmitter._emit_run   s     	
46r   c                 H    t        | j                  j                               S )z6Get a set of events that this emitter is listening to.)setr    keysr"   s    r   event_nameszEventEmitter.event_names   s    4<<$$&''r   errorc                 N    |dk(  r t        |t              r|t        d|       y )NrG   z%Uncaught, unspecified 'error' event: )
isinstance	Exceptionr   )r#   r.   rG   s      r   _emit_handle_potential_errorz)EventEmitter._emit_handle_potential_error   s1    G%+#&KE7$STT	 r   c                     d}| j                   5  t        | j                  j                  |t	                     j                               }d d d        D ]  }| j                  |||       d} |S # 1 sw Y   'xY w)NFT)r!   listr    getr   valuesrB   )r#   r.   r?   r@   handledfuncsr/   s          r   _call_handlerszEventEmitter._call_handlers   sz     ZZ 	J))%?FFHIE	J 	ANN1dF+G	 	J 	Js   <A11A:c                 b    | j                  |||      }|s| j                  ||r|d   nd       |S )ac  Emit `event`, passing `*args` and `**kwargs` to each attached
        function. Returns `True` if any functions are attached to `event`;
        otherwise returns `False`.

        Example:

        ```py
        ee.emit('data', '00101001')
        ```

        Assuming `data` is an attached function, this will call
        `data('00101001')'`.
        r   N)rR   rK   )r#   r.   r?   r@   rP   s        r   r>   zEventEmitter.emit   s8    & %%eT6:--eT!W$Or   c                 D     dt         dt         f fd}||S  ||      S )zkThe same as `ee.on`, except that the listener is automatically
        removed after being called.
        r/   r   c                 d     dt         dt         dt         f fd}j                   |        S )Nr?   r@   r   c                      j                   5  j                  v r$j                     v rj                         n
	 d d d        y 	 d d d         | i |S # 1 sw Y   xY wr   )r!   r    _remove_listener)r?   r@   r.   r/   r#   s     r   gz.EventEmitter.once.<locals>._wrapper.<locals>.g   ss     ZZ $ ,dll56I1I--eQ7#$ $ 8	$ $)&))$ $s   4AA%)r   r8   )r/   rX   r.   r#   s   ` r   _wrapperz#EventEmitter.once.<locals>._wrapper   s;    *** * ##E1a0Hr   )r   )r#   r.   r/   rY   s   ``  r   oncezEventEmitter.once   s,    	 	X 	& 9OA;r   c                     | j                   |   j                  |       t        | j                   |         s| j                   |= yy)zNaked unprotected removal.N)r    poplenr3   s      r   rW   zEventEmitter._remove_listener   s;    U"4<<&'U# (r   c                 j    | j                   5  | j                  ||       ddd       y# 1 sw Y   yxY w)z&Removes the function `f` from `event`.N)r!   rW   r3   s      r   remove_listenerzEventEmitter.remove_listener   s.    ZZ 	,!!%+	, 	, 	,s   )2c                     | j                   5  |t               | j                  |<   nt               | _        ddd       y# 1 sw Y   yxY w)ztRemove all listeners attached to `event`.
        If `event` is `None`, remove all listeners on all events.
        N)r!   r   r    r   r#   r.   s     r   remove_all_listenersz!EventEmitter.remove_all_listeners  s?     ZZ 	& &1mU##v		& 	& 	&s   *A  A	c                 x    t        | j                  j                  |t                     j	                               S )z:Returns a list of all listeners registered to the `event`.)rM   r    rN   r   rE   ra   s     r   	listenerszEventEmitter.listeners  s)    DLL$$UKM:??ABBr   )r   Nr   )!r   r   r   r   r$   r	   strr   r*   r-   r
   r   r   r   r4   r1   r2   r8   r   r   rB   r   rF   rK   boolrR   r>   rZ   rW   r_   rb   r   rd   r   r   r   r   r      s.   8"gc3h/ 
'#s("3  
 26 / /%g. /	w'G!344	5 /D 'G1C(D (# ' g  ' ' 'X ' CHo S#X	
 
(SX (U# Uc Ud U CHo S#X	
 
   	
 
: !% H 
	B$c $h $4 $,S ,X ,$ ,
&(3- &4 &Cs CtH~ Cr   r   N)collectionsr   	threadingr   typingr   r   r   r   r	   r
   r   r   r   r   rJ   r   r   r   r   r   r   <module>rj      sD    $   )I ) )8
,uC uCr   