iHlddlmZddlmZdgZGddZeZGddZdS))hubs) greenletsEventceZdZdZdS)NOT_USEDcdS)Nrselfs 9/usr/local/lib/python3.11/dist-packages/eventlet/event.py__repr__zNOT_USED.__repr__szN)__name__ __module__ __qualname__r r rr rrs#rrcreZdZdZdZdZdZdZdZdZ dZ dZ dd Z dd Z dd Zdd Zdd ZdZdZdS)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 NcTt|_|dSN)set_waitersresetr s r __init__zEvent.__init__+s  rc|jjtt||j|jt |jf}d|zS)Nz)<%s at %s result=%r _exc=%r _waiters[%d]>) __class__rhexid_result_exclenr)r paramss r __str__z Event.__str__/s?.)3r$xx==, 3t}+=+=?:VCCrc\|jtus Jdt|_d|_dS)Nz#Trying to re-reset() a fresh event.rrrr s r rz Event.reset4s2|8+++-R+++  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_exceptionDsy$$rc0|jtuo|jduSrr#r s r has_resultzEvent.has_resultGs|8+A T0AArcV|r|S|Sr)r%waitr notreadys r pollz Event.pollJs% ::<< 99;; rcV|r|S|Sr)r'r+r,s r poll_exceptionzEvent.poll_exceptionTs)      99;; rcV|r|S|Sr)r)r+r,s r poll_resultzEvent.poll_resultYs' ??   99;; rctj}|jturt j}|j|d}||||j dd|} | }|| ||j |S#|j |wxYw|j |j|j |jS)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 M  g & & &E"//dT[\\ /$LLNNN %%g.... %%g.... 9 GM49 % %|s 2+B88Cc|jtus Jd||_|t|ts|f}||_t j}|jD]*}|d|j |j|j|+dS)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''' ?:c5#9#9?'C lnnm C CF  $ $4=$, 6 C C C C C Crcb||jvr%|||dS|j|dSdSr)rr:r=)r rBrGrHs r r9zEvent._do_sendsI T] " "{ f%%%%% c"""" # "rc.|d|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 rrs0G DDDD ,,,%%%BBB  &&&&P"C"C"C"CH###)%)%)%)%)%rN)eventletreventlet.supportrr4__all__rrr rr rRs222222 ) 8::K%K%K%K%K%K%K%K%K%K%r