a ݌xd@svddlmZddlmZddlmZmZmZmZm Z m Z m Z m Z m Z mZGdddeZe dedZGdd d Zd S) ) OrderedDict)Lock) AnyCallableDictListMappingOptionalSetTupleTypeVarUnionc@seZdZdZdS) PyeeExceptionzAn exception internal to pyee.N)__name__ __module__ __qualname____doc__rrA/var/www/html/Ranjet/env/lib/python3.9/site-packages/pyee/base.pyrsrHandler)nameboundc@seZdZdZddddZeeefdddZeeefddd d Z d.ee e e e e e ge ffd d d Zee e ge fdddZee e d ddZee e dddZe eedfeeefddddZeedddZeeddddZeeedfeeefedd d!Zeeeedd"d#Zd/ee e d d$d%Zee dd d&d'Zee dd d(d)Zd0e eddd*d+Zeee dd,d-Z dS)1 EventEmitteraThe 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:: @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. N)returncCst|_t|_dSN)dict_eventsr_lockselfrrr__init__5szEventEmitter.__init__cCs|j}|d=|S)Nr)__dict__copyrstaterrr __getstate__<s zEventEmitter.__getstate__)r$rcCs|j|t|_dSr)r!updaterrr#rrr __setstate__As zEventEmitter.__setstate__)eventfrcCs"|dur||S|||SdS)a`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:: @ee.on('data') def data_handler(data): print(data) Or directly:: 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``. N) listens_to add_listenerrr(r)rrronEs zEventEmitter.on)r(rcsttdfdd }|S)aMReturns a decorator which will register the decorated function to the event name ``event``:: @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)rcs|||Sr_add_event_handlerr)r(rrrr-osz#EventEmitter.listens_to..on)r)rr(r-rr2rr*cs zEventEmitter.listens_tocCs|||||S)a5Register 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/r,rrrr+us zEventEmitter.add_listener)r(kvcCs\|d|||j4||jvr,t|j|<||j||<Wdn1sN0YdS)NZ new_listener)emitrrr)rr(r3r4rrrr0s   zEventEmitter._add_event_handler.)r)argskwargsrcCs||i|dSrr)rr)r6r7rrr _emit_runszEventEmitter._emit_runcCst|jS)z6Get a set of events that this emitter is listening to.)setrkeysrrrr event_namesszEventEmitter.event_names)r(errorrcCs*|dkr&t|tr|ntd|dS)Nr<z%Uncaught, unspecified 'error' event: ) isinstance Exceptionr)rr(r<rrr_emit_handle_potential_errors z)EventEmitter._emit_handle_potential_error)r(r6r7rcCsbd}|j(t|j|t}Wdn1s80Y|D]}||||d}qF|S)NFT)rlistrgetrvaluesr8)rr(r6r7handledfuncsr)rrr_call_handlerss6zEventEmitter._call_handlerscOs.||||}|s*|||r$|dnd|S)a^Emit ``event``, passing ``*args`` and ``**kwargs`` to each attached function. Returns ``True`` if any functions are attached to ``event``; otherwise returns ``False``. Example:: ee.emit('data', '00101001') Assuming ``data`` is an attached function, this will call ``data('00101001')'``. rN)rEr?)rr(r6r7rCrrrr5szEventEmitter.emitcs.ttdfdd }|dur"|S||SdS)zmThe same as ``ee.on``, except that the listener is automatically removed after being called. r.cs,tttdfdd }|S)N)r6r7rcsjjFjvr.jvr.nWddSWdn1sR0Y|i|Sr)rr_remove_listener)r6r7)r(r)rrrgs .z.EventEmitter.once.._wrapper..g)rr0)r)rGr2r1r_wrappers z#EventEmitter.once.._wrapperN)r)rr(r)rHrr2ronces zEventEmitter.oncecCs*|j||t|j|s&|j|=dS)zNaked unprotected removal.N)rpoplenr,rrrrFszEventEmitter._remove_listenercCs6|j|||Wdn1s(0YdS)z*Removes the function ``f`` from ``event``.N)rrFr,rrrremove_listenerszEventEmitter.remove_listenercCsH|j.|durt|j|<nt|_Wdn1s:0YdS)zzRemove all listeners attached to ``event``. If ``event`` is ``None``, remove all listeners on all events. N)rrrrrr(rrrremove_all_listenerssz!EventEmitter.remove_all_listenerscCst|j|tS)zrrrrrrrs  0