o fAh@sjddlmZmZmZmZmZddlmZmZm Z m Z m Z m Z m Z ddlmZeZdgZGdddeZdS))AbstractEventLoop ensure_futureFuture iscoroutinewait)AnyCallablecastDictOptionalSetTuple) EventEmitterAsyncIOEventEmitterc seZdZdZddedeeddffdd Zdeded e d e de f fd d Z ded e d e e dfd eee fddf ddZdeddfddZdeddfddZedede fddZZS)ra(An event emitter class which can run asyncio coroutines in addition to synchronous blocking functions. For example: ```py @ee.on('event') async def async_handler(*args, **kwargs): await returns_a_future() ``` On emit, the event emitter will automatically schedule the coroutine using `asyncio.ensure_future` and the configured event loop (defaults to `asyncio.get_event_loop()`). Unlike the case with the EventEmitter, all exceptions raised by event handlers are automatically emitted on the `error` event. This is important for asyncio coroutines specifically but is also handled for synchronous functions for consistency. When `loop` is specified, the supplied event loop will be used when scheduling work with `ensure_future`. Otherwise, the default asyncio event loop is used. For asyncio coroutine event handlers, calling emit is non-blocking. In other words, you do not have to await any results from emit, and the coroutine is scheduled in a fire-and-forget fashion. Nselfloopreturncs tt|||_t|_dSN)superr__init___loopset_waiting)rr __class__U/var/www/html/brandlife/copilot/chat-env/lib/python3.10/site-packages/pyee/asyncio.pyr)s zAsyncIOEventEmitter.__init__eventargskwargscstj|g|Ri|S)aEmit `event`, passing `*args` and `**kwargs` to each attached function or coroutine. 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')'`. When executing coroutine handlers, their respective futures will be stored in a "waiting" state. These futures may be waited on or canceled with `wait_for_complete` and `cancel`, respectively; and their status may be checked via the `complete` property. N)remit)rrrrrrrr .szAsyncIOEventEmitter.emitf.c sz ||i|}Wnty"}z d|WYd}~dSd}~wwt|r=jr5ttt|jd}nttt|}n t|trHtt|}ndSdtddffdd }| |j |dS)Nerror)rr!rcs8j||r dS|}|rd|dSdS)Nr")rdiscard cancelled exceptionr )r!excrrrcallbackas z/AsyncIOEventEmitter._emit_run..callback) Exceptionr rrrr r isinstanceradd_done_callbackradd)rr!rrcoror&futr(rr'r _emit_runHs    zAsyncIOEventEmitter._emit_runcs |jrt|jIdHdSdS)aWaits for all pending tasks to complete. For example: ```py @ee.on('event') async def async_handler(*args, **kwargs): await returns_a_future() # Triggers execution of async_handler ee.emit('data', '00101001') await ee.wait_for_complete() # async_handler has completed execution ``` This is useful if you're attempting a graceful shutdown of your application and want to ensure all coroutines have completed execution beforehand. N)rrr'rrrwait_for_completensz%AsyncIOEventEmitter.wait_for_completecCs2|jD]}|s|s|q|jdS)aCancel all pending tasks. For example: ```py @ee.on('event') async def async_handler(*args, **kwargs): await returns_a_future() # Triggers execution of async_handler ee.emit('data', '00101001') ee.cancel() # async_handler execution has been canceled ``` This is useful if you're attempting to shut down your application and attempts at a graceful shutdown via `wait_for_complete` have failed. N)rdoner$cancelclear)rr.rrrr2s zAsyncIOEventEmitter.cancelcCs|j S)aWhen true, there are no pending tasks, and execution is complete. For example: ```py @ee.on('event') async def async_handler(*args, **kwargs): await returns_a_future() # Triggers execution of async_handler ee.emit('data', '00101001') # async_handler is still running, so this prints False print(ee.complete) await ee.wait_for_complete() # async_handler has completed execution, so this prints True print(ee.complete) ``` N)rr'rrrcompleteszAsyncIOEventEmitter.completer)__name__ __module__ __qualname____doc__Selfr rrstrrboolr rr r r/r0r2propertyr4 __classcell__rrrrr s:    &N)asynciorrrrrtypingrrr r r r r pyee.baserr9__all__rrrrrs $