3 Z_ð]^ã@sRddlmZddlmZddlmZdgZGdd„dƒZeƒZGdd„de ƒZ dS) é)Úprint_function)Úhubs)Ú greenletsÚEventc@seZdZdd„ZdS)ÚNOT_USEDcCsdS)Nr©)Úselfrrú2/tmp/pip-build-yz_zf6az/eventlet/eventlet/event.pyÚ__repr__ szNOT_USED.__repr__N)Ú__name__Ú __module__Ú __qualname__r rrrr r src@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ƒ|_|jƒdS)N)ÚsetÚ_waitersÚreset)rrrr Ú__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__0sz Event.__str__cCs"|jtk stdƒ‚t|_d|_dS)Nz#Trying to re-reset() a fresh event.)rrÚAssertionErrorr)rrrr r5sz 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.)rr)rrrr Úready=sz Event.readycCs |jdk S)N)r)rrrr Ú has_exceptionEszEvent.has_exceptioncCs|jtk o|jdkS)N)rrr)rrrr Ú has_resultHszEvent.has_resultcCs|jƒr|jƒS|S)N)rÚwait)rÚnotreadyrrr ÚpollKsz Event.pollcCs|jƒr|jƒS|S)N)rr)rrrrr Úpoll_exceptionUszEvent.poll_exceptioncCs|jƒr|jƒS|S)N)rr)rrrrr Ú poll_resultZszEvent.poll_resultc CsŽtjƒ}|jtkrrtjƒ}|jj|ƒd}|dk rF|j||j dd|ƒ}z|j ƒ}|dk r`|j ƒ|S|jj |ƒ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ÚswitchÚcancelÚdiscardrÚthrow)rÚtimeoutÚcurrentÚhubZtimerÚresultrrr r_s     z Event.waitcCsl|jtkstdƒ‚||_|dk r2t|tƒ r2|f}||_tjƒ}x&|jD]}|j d|j |j|j|ƒqHWdS)a]Makes 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') 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&)rr.Úexcr-Úwaiterrrr Úsend‡s z Event.sendcCs,||jkr(|dkr|j|ƒn |j|ŽdS)N)rr'r*)rr.r1r2rrr r&¬s  zEvent._do_sendcGs |jd|ƒ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)r3)rÚargsrrr Úsend_exception³s)zEvent.send_exception)N)N)N)N)NN)r r r Ú__doc__rrrrrrrrr r!r"rr3r&r5rrrr rs    ( %N) Ú __future__rZeventletrZeventlet.supportrr#Ú__all__rÚobjectrrrrr Ús