+ jr^RIHtHtHtHtHt^RIHtHtH t H t H t H t H t ^RIHt]tR.t!RR]4tR#))AbstractEventLoop ensure_futureFuture iscoroutinewait)AnyCallablecastDictOptionalSetTuple) EventEmitterAsyncIOEventEmittercaa]tRt^ toRtRV3RlV3RllltV3RlV3RlltV3RlRltV3RlR ltV3R lR lt ] V3R lR l4t Rt Vt V;t#)raAn 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. c:<V^8dQhRS[RS[S[,RR/#)selfloopreturnN)Selfr r)format __classdict__s"J/opt/render/project/src/.venv/lib/python3.14/site-packages/pyee/asyncio.py __annotate__ AsyncIOEventEmitter.__annotate__)s(++t+8,=#>+$+cV<\\V` 4Wn\ 4VnR#N)superr__init___loopset_waiting)rr __class__s&&rr!AsyncIOEventEmitter.__init__)s !41326 %(U rc 8<V^8dQhRS[RS[RS[RS[RS[/#)rreventargskwargsr)rstrrbool)rrs"rrr.s;44444 4  4rc ,<\SV`!V.VO5/VB#)a'Emit `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. )r emit)rr(r)r*r%s&&*,rr.AsyncIOEventEmitter.emit.s0w|E3D3F33rc `<V^8dQhRS[RS[RS[S[R3,RS[S[S[3,RR/#)rrfr).r*rN)rr rrr r+)rrs"rrrHsK$#$#$# $#CHo$#S#X $#  $#rcaV!V/VBp\V4'dSSP'd'\\\V4SPR7pMC\\\V44pM)\ V\ 4'd\\V4pMR#RV3RllpVPV4SPPV4R# \dpSPRT4Rp?R#Rp?ii;i))rNc(V^8dQhR\RR/#)rr1rN)r)rs"rr3AsyncIOEventEmitter._emit_run..__annotate__as , ,F ,t ,rc<SPPV4VP4'dR#VP4pV'dSP RV4R#R#)Nerror)r$discard cancelled exceptionr.)r1excrs& rcallback/AsyncIOEventEmitter._emit_run..callbackasD %%a(;;==/0{{}IIgs+rr6) rr"rr r isinstanceradd_done_callbackr$add Exceptionr.)rr1r)r*corofutr;r:sf&&& r _emit_runAsyncIOEventEmitter._emit_runHs  #4*6*D4  ::: -T#t_4::NC'S$8CD&))3o , ,  ! !( + MM  c "9 $ IIgs # # $sC C6C11C6c$<V^8dQhRS[RR/#rrrNr)rrs"rrrns&&d&t&rc t"VP'd \VP4GRjxL R#R#L5i)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)r$rrs&rwait_for_complete%AsyncIOEventEmitter.wait_for_completens*( ===t}}% % %  %s +86 8c$<V^8dQhRS[RR/#rFrG)rrs"rrrsTdrc VPFCpVP4'dKVP4'dK3VP4KE VPP 4R#)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)r$doner8cancelclear)rrBs& rrOAsyncIOEventEmitter.cancelsB&==C88::cmmoo ! rc&<V^8dQhRS[RS[/#)rrr)rr,)rrs"rrrs!!t!!rc $VP'*#)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) ``` )r$rIs&rcompleteAsyncIOEventEmitter.completes,==  r)r"r$r)__name__ __module__ __qualname____firstlineno____doc__r!r.rCrJrOpropertyrT__static_attributes____classdictcell__ __classcell__)r%rs@@rrr sV6++ 444$#$#L&&.0!!!rN)asynciorrrrrtypingrr r r r r r pyee.baserr__all__rrrrds5POBBB"  !f!,f!r