!niHXddlmZddlmZdgZGddZeZGddZy))hubs) greenletsEventceZdZdZy)NOT_USEDcy)Nrselfs N/home/homepc/tiktok-worker/venv/lib/python3.12/site-packages/eventlet/event.py__repr__zNOT_USED.__repr__sN)__name__ __module__ __qualname__r r rr rrsrrcpeZdZdZdZdZdZdZdZdZ dZ dZ dd Z dd Z dd Zdd Zdd ZdZdZy)raAn abstraction where an arbitrary number of coroutines can wait for one event from another. Events are similar to a Queue that can only hold one item, but differ in two important ways: 1. calling :meth:`send` never unschedules the current greenthread 2. :meth:`send` can only be called once; create a new event to send again. They are good for communicating results between coroutines, and are the basis for how :meth:`GreenThread.wait() ` is implemented. >>> from eventlet import event >>> import eventlet >>> evt = event.Event() >>> def baz(b): ... evt.send(b + 1) ... >>> _ = eventlet.spawn_n(baz, 3) >>> evt.wait() 4 NcBt|_|jyN)set_waitersresetr s r __init__zEvent.__init__+s  rc|jjtt||j|j t |jf}d|zS)Nz)<%s at %s result=%r _exc=%r _waiters[%d]>) __class__rhexid_result_exclenr)r paramss r __str__z Event.__str__/sC..))3r$x=,, 3t}}+=?:VCCrcZ|jtusJdt|_d|_y)Nz#Trying to re-reset() a fresh event.rrrr s r rz Event.reset4s*||8+R-RR+  rc&|jtuS)a] Return true if the :meth:`wait` call will return immediately. Used to avoid waiting for things that might take a while to time out. For example, you can put a bunch of events into a list, and then visit them all repeatedly, calling :meth:`ready` until one returns ``True``, and then you can :meth:`wait` on that one.)rrr s r readyz Event.ready<s ||8++rc|jduSr)rr s r has_exceptionzEvent.has_exceptionDsyy$$rcF|jtuxr|jduSrr#r s r has_resultzEvent.has_resultGs||8+A T0AArcF|jr|jS|Sr)r%waitr notreadys r pollz Event.pollJs ::<99; rcF|jr|jS|Sr)r'r+r,s r poll_exceptionzEvent.poll_exceptionTs    99; rcF|jr|jS|Sr)r)r+r,s r poll_resultzEvent.poll_resultYs ?? 99; rctj}|jturt j }|j j|d}||j||jdd|} |j}||j||j j|S|j|j|j|jS#|j j|wxYw)aWait until another coroutine calls :meth:`send`. Returns the value the other coroutine passed to :meth:`send`. >>> import eventlet >>> evt = eventlet.Event() >>> def wait_on(): ... retval = evt.wait() ... print("waited for {0}".format(retval)) >>> _ = eventlet.spawn(wait_on) >>> evt.send('result') >>> eventlet.sleep(0) waited for result Returns immediately if the event has already occurred. >>> evt.wait() 'result' When the timeout argument is present and not None, it should be a floating point number specifying a timeout for the operation in seconds (or fractions thereof). N)greenlet getcurrentrrrget_hubraddschedule_call_local_do_sendswitchcanceldiscardrthrow)r timeoutcurrenthubtimerresults r r+z Event.wait^s,%%' <<8 #,,.C MM  g &E"//dT[\ /$LLN %%g. 99 GMM499 %|| %%g.s :#C**Dc,|jtusJd||_|t|ts|f}||_t j }|jD]5}|jd|j|j|j|7y)auMakes arrangements for the waiters to be woken with the result and then returns immediately to the parent. >>> from eventlet import event >>> import eventlet >>> evt = event.Event() >>> def waiter(): ... print('about to wait') ... result = evt.wait() ... print('waited for {0}'.format(result)) >>> _ = eventlet.spawn(waiter) >>> eventlet.sleep(0) about to wait >>> evt.send('a') >>> eventlet.sleep(0) waited for a It is an error to call :meth:`send` multiple times on the same event. >>> evt.send('whoops') # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): AssertionError: Trying to re-send() an already-triggered event. Use :meth:`reset` between :meth:`send` s to reuse an event object. z/Trying to re-send() an already-triggered event.Nr) rr isinstancetuplerrr6rschedule_call_globalr9)r rBexcr@waiters r sendz Event.sends4||x'Z)ZZ' ?:c5#9'C llnmm CF  $ $4==$,, 6 C Crch||jvr$||j|y|j|yyr)rr:r=)r rBrGrHs r r9zEvent._do_sends2 T]] "{ f% c" #rc&|jd|S)aSame as :meth:`send`, but sends an exception to waiters. The arguments to send_exception are the same as the arguments to ``raise``. If a single exception object is passed in, it will be re-raised when :meth:`wait` is called, generating a new stacktrace. >>> from eventlet import event >>> evt = event.Event() >>> evt.send_exception(RuntimeError()) >>> evt.wait() Traceback (most recent call last): File "", line 1, in File "eventlet/event.py", line 120, in wait current.throw(*self._exc) RuntimeError If it's important to preserve the entire original stack trace, you must pass in the entire :func:`sys.exc_info` tuple. >>> import sys >>> evt = event.Event() >>> try: ... raise RuntimeError() ... except RuntimeError: ... evt.send_exception(*sys.exc_info()) ... >>> evt.wait() Traceback (most recent call last): File "", line 1, in File "eventlet/event.py", line 120, in wait current.throw(*self._exc) File "", line 2, in RuntimeError Note that doing so stores a traceback object directly on the Event object, which may cause reference cycles. See the :func:`sys.exc_info` documentation. N)rI)r argss r send_exceptionzEvent.send_exceptionsRyyt$$rr)NN)rrr__doc__rrrr!rr%r'r)r.r0r2r+rIr9rMr rr rrsY0G DD ,%B  &P"CH#)%rN)eventletreventlet.supportrr4__all__rrr rr rRs12 ) :K%K%r