a ҏi @sddlmZmZmZmZmZddlmZmZddl m Z ddl m Z m Z zddlmZWneyndZYn0dgZGddde ZdS) )AnyCallableDictOptionalTuple)DeferredensureDeferred)Failure) EventEmitter PyeeException) iscoroutineNTwistedEventEmittercsZeZdZdZfddZeeedfee efddddZ e edd fd d Z Z S) r aAn event emitter class which can run twisted coroutines and handle returned Deferreds, in addition to synchronous blocking functions. For example: ```py @ee.on('event') @inlineCallbacks def async_handler(*args, **kwargs): yield returns_a_deferred() ``` or: ```py @ee.on('event') async def async_handler(*args, **kwargs): await returns_a_deferred() ``` When async handlers fail, Failures are first emitted on the `failure` event. If there are no `failure` handlers, the Failure's associated exception is then emitted on the `error` event. If there are no `error` handlers, the exception is raised. For consistency, when handlers raise errors synchronously, they're captured, wrapped in a Failure and treated as an async failure. This is unlike the behavior of EventEmitter, which have no special error handling. For twisted 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. Similar behavior occurs for "sync" functions which return Deferreds. cstt|dS)N)superr __init__self __class__.errback) Exceptionrr r r isinstancerZ addErrback)rrrrdresultrrrr _emit_run:s    zTwistedEventEmitter._emit_run)eventerrorrc s|dkrt|trRz |WqtyN}z|d|WYd}~qd}~00qt|trj|d|q|dtd|ntt|||dS)Nrr#zUnexpected failure object: ) rr ZraiseExceptionrrr rr _emit_handle_potential_error)rr"r#excrrrr$Ss  $  z0TwistedEventEmitter._emit_handle_potential_error) __name__ __module__ __qualname____doc__rrrrrstrr!r$ __classcell__rrrrr s#    )typingrrrrrZtwisted.internet.deferrrZtwisted.python.failurer Z pyee.baser r Zasyncior ImportError__all__r rrrrs