
    g                          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 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. Deprecated in favor of PyeeError.N__name__
__module____qualname____doc__     >/var/www/openai/venv/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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__;   s     F 	  6
r   c                 @    | j                   j                         }|d= |S )Nr$   )__dict__copyr&   states     r   __getstate__zEventEmitter.__getstate__B   s     ""$'Nr   r,   c                 X    | j                   j                  |       t               | _        y r!   )r)   updater   r$   r+   s     r   __setstate__zEventEmitter.__setstate__G   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&   r1   r2   s      r   onzEventEmitter.onK   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`.
        r2   r   c                 .    j                  | |        | S r!   _add_event_handler)r2   r1   r&   s    r   r7   z#EventEmitter.listens_to.<locals>.on{   s    ##E1a0Hr   )r   )r&   r1   r7   s   `` r   r4   zEventEmitter.listens_tom   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:   r6   s      r   r5   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&   r1   r=   r>   s       r   r;   zEventEmitter._add_event_handler   sT    		.%+ ZZDLL(&1mU#%&DLL" ZZs   8A!!A*args.kwargsc                      ||i | y r!   r   )r&   r2   rB   rC   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 )NrJ   z%Uncaught, unspecified 'error' event: )
isinstance	Exceptionr   )r&   r1   rJ   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   valuesrE   )r&   r1   rB   rC   handledfuncsr2   s          r   _call_handlerszEventEmitter._call_handlers   si     ZZ))%?FFHIE ANN1dF+G   Zs   <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)rU   rN   )r&   r1   rB   rC   rS   s        r   rA   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.
        r2   r   c                 d     dt         dt         dt         f fd}j                   |        S )NrB   rC   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)rB   rC   r1   r2   r&   s     r   gz.EventEmitter.once.<locals>._wrapper.<locals>.g   sh     ZZ ,dll56I1I--eQ7#  Z 8	   $)&))  Zs   4AA%)r   r;   )r2   r[   r1   r&   s   ` r   _wrapperz#EventEmitter.once.<locals>._wrapper   s;    *** * ##E1a0Hr   )r   )r&   r1   r2   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lenr6   s      r   rZ   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$   rZ   r6   s      r   remove_listenerzEventEmitter.remove_listener  s#    ZZ!!%+ ZZs   )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&   r1   s     r   remove_all_listenersz!EventEmitter.remove_all_listeners  s4     ZZ &1mU##v	 ZZs   *A  A	c                 x    t        | j                  j                  |t                     j	                               S )z:Returns a list of all listeners registered to the `event`.)rP   r#   rQ   r   rH   rd   s     r   	listenerszEventEmitter.listeners  s)    DLL$$UKM:??ABBr   )r   Nr!   )!r   r   r   r   r'   r	   strr   r-   r0   r
   r   r   r   r7   r4   r5   r;   r   r   rE   r   rI   rN   boolrU   rA   r]   rZ   rb   re   r   rg   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 (Q# Qc Qd Q 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   rM   r   r   r   r   r   r   r   <module>rm      sR    $   KI K% % )8
,uC uCr   