U Ã@ÛfHã@sDddlmZddlmZdgZGdd„dƒZeƒZGdd„dƒZdS)é)Úhubs)Ú greenletsÚEventc@seZdZdd„ZdS)ÚNOT_USEDcCsdS)Nr©©ÚselfrrúH/var/www/html/chatgpt/venv/lib/python3.8/site-packages/eventlet/event.pyÚ__repr__szNOT_USED.__repr__N)Ú__name__Ú __module__Ú __qualname__r rrrr rsrc@sŠeZdZdZdZdZdd„Zdd„Zdd„Zd d „Z d d „Z d d„Z ddd„Z ddd„Z ddd„Zd dd„Zd!dd„Zdd„Zdd„ZdS)"raèAn 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 NcCstƒ|_| ¡dS©N)ÚsetÚ_waitersÚresetrrrr Ú__init__+szEvent.__init__cCs,|jjtt|ƒƒ|j|jt|jƒf}d|S)Nz)<%s at %s result=%r _exc=%r _waiters[%d]>)Ú __class__r ÚhexÚidÚ_resultÚ_excÚlenr)rÚparamsrrr Ú__str__/s ÿz Event.__str__cCs"|jtk stdƒ‚t|_d|_dS)Nz#Trying to re-reset() a fresh event.)rrÚAssertionErrorrrrrr r4sz Event.resetcCs |jtk S)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.)rrrrrr Úready<sz Event.readycCs |jdk Sr)rrrrr Ú has_exceptionDszEvent.has_exceptioncCs|jtk o|jdkSr)rrrrrrr Ú has_resultGszEvent.has_resultcCs| ¡r| ¡S|Sr)rÚwait©rZnotreadyrrr ÚpollJsz Event.pollcCs| ¡r| ¡S|Sr)rrr rrr Úpoll_exceptionTszEvent.poll_exceptioncCs| ¡r| ¡S|Sr)rrr rrr Ú poll_resultYszEvent.poll_resultc Cs’t ¡}|jtkrvt ¡}|j |¡d}|dk rF| ||j dd|¡}z |  ¡}|dk r`|  ¡|W¢S|j  |¡X|j dk rŒ|j|j Ž|jS)aÎWait 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)ÚgreenletZ getcurrentrrrÚget_hubrÚaddZschedule_call_localÚ_do_sendÚdiscardÚswitchÚcancelrÚthrow)rÚtimeoutÚcurrentÚhubÚtimerÚresultrrr r^s     z Event.waitcCsf|jtkstdƒ‚||_|dk r0t|tƒs0|f}||_t ¡}|jD]}|  d|j |j|j|¡qDdS)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) rrrÚ isinstanceÚtuplerrr%rZschedule_call_globalr')rr0Úexcr.Úwaiterrrr Úsend†s ÿz Event.sendcCs,||jkr(|dkr| |¡n |j|ŽdSr)rr)r+)rr0r3r4rrr r'ªs  zEvent._do_sendcGs | d|¡S)aÞSame 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)r5)rÚargsrrr Úsend_exception±s)zEvent.send_exception)N)N)N)N)NN)r r r Ú__doc__rrrrrrrrr!r"r#rr5r'r7rrrr rs    ( $N)ZeventletrZeventlet.supportrr$Ú__all__rrrrrr Ús