
    㾙h:!                         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mZ eZ G d de      Z G d de      Z ede	      Z G d
 d      Zy)    )OrderedDict)Lock)AnyCallableDictListMappingOptionaloverloadSetTupleTypeVarUnionc                       e Zd ZdZy)PyeeExceptionz@An exception internal to pyee. Deprecated in favor of PyeeError.N__name__
__module____qualname____doc__     E/var/www/Befach/backend/env/lib/python3.12/site-packages/pyee/base.pyr   r      s    Jr   r   c                       e Zd ZdZy)	PyeeErrorzAn error internal to pyee.Nr   r   r   r   r   r      s    $r   r   Handler)boundc                   ^   e Zd ZdZdeddfdZdedeeef   fdZ	dedeeef   ddfdZ
eded	edeegef   fd
       Zeded	ededefd       Z	 d!ded	edee   deeeegef   f   fdZded	edeegef   fdZded	ededefdZded	ededefdZdededeedf   deeef   ddf
dZdedee   fdZded	ededdfdZde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def
dZ	 d!ded	edee   defdZded	ededdfdZded	ededdfdZd!ded	ee   ddfdZ de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.
    selfreturnNc                 @    t               | _        t               | _        y N)dict_eventsr   _lockr    s    r   __init__zEventEmitter.__init__>   s     F 	  6
r   c                 @    | j                   j                         }|d= |S )Nr&   )__dict__copyr    states     r   __getstate__zEventEmitter.__getstate__E   s     ""$'Nr   r-   c                 X    | j                   j                  |       t               | _        y r#   )r*   updater   r&   r,   s     r   __setstate__zEventEmitter.__setstate__J   s    U#V
r   eventc                      y r#   r   r    r2   s     r   onzEventEmitter.onN   s    DGr   fc                      y r#   r   r    r2   r6   s      r   r5   zEventEmitter.onP   s    ;>r   c                 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_listenerr8   s      r   r5   zEventEmitter.onS   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`.
        r6   r!   c                 .    j                  | |        | S r#   _add_event_handler)r6   r2   r    s    r   r5   z#EventEmitter.listens_to.<locals>.on   s    ##E1a0Hr   )r   )r    r2   r5   s   `` r   r:   zEventEmitter.listens_tou   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`.
        r>   r8   s      r   r;   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    r2   rA   rB   s       r   r?   zEventEmitter._add_event_handler   s_    		.%+ ZZ 	'DLL(&1mU#%&DLL"	' 	' 	's   8A!!A*args.kwargsc                      ||i | y r#   r   )r    r6   rF   rG   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 )NrN   z%Uncaught, unspecified 'error' event: )
isinstance	Exceptionr   )r    r2   rN   s      r   _emit_handle_potential_errorz)EventEmitter._emit_handle_potential_error   s1    G%+"Gw OPP	 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   valuesrI   )r    r2   rF   rG   handledfuncsr6   s          r   _call_handlerszEventEmitter._call_handlers   su     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)rY   rR   )r    r2   rF   rG   rW   s        r   rE   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.
        r6   r!   c                 d     dt         dt         dt         f fd}j                   |        S )NrF   rG   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)rF   rG   r2   r6   r    s     r   gz.EventEmitter.once.<locals>._wrapper.<locals>.g   ss     ZZ $ ,dll56I1I--eQ7#$ $ 8	$ $)&))$ $s   4AA%)r   r?   )r6   r_   r2   r    s   ` r   _wrapperz#EventEmitter.once.<locals>._wrapper   s;    *** * ##E1a0Hr   )r   )r    r2   r6   r`   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lenr8   s      r   r^   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&   r^   r8   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$   r4   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`.)rT   r%   rU   r   rL   r4   s     r   	listenerszEventEmitter.listeners  s)    DLL$$UKM:??ABBr   r#   )#r   r   r   r   Selfr(   r	   strr   r.   r1   r   r   r   r5   r
   r   r:   r;   r?   r   r   rI   r   rM   rR   boolrY   rE   ra   r^   rf   rh   r   rj   r   r   r   r   r   !   s    8"t " "4 GCH$5 
4 S(9 d  GGcGhy'/A&BG G>>c>g>'> > 8< / / /#+G#4 /	w'G!344	5 /D c hy'7I.J (4   G  ' 'c 'h '8 ' CHo S#X	
 
($ (3s8 (Q4 Q QC QD Q CHo S#X	
 
   	
 
: !% H 
	B$t $C $H $ $,d ,3 ,8 , ,
&4 & & &C CS CT(^ Cr   r   N)collectionsr   	threadingr   typingr   r   r   r   r	   r
   r   r   r   r   r   rk   rQ   r   r   r   r   r   r   r   <module>rq      s^    $     KI K% % )8
,zC zCr   