ó
 ‹EYc@
sodd
lm
Z

ddlmZ
ddlmZ
dg
Zdd	d„ƒYZeƒZde	f
d„ƒYZ
dS(
iÿÿÿÿ(
tprint_function(
thubs(
t	greenletstEventtNOT_USEDc
B
seZ
d„ZRS(
c


C
sd
S(NR((
tself((sC/home/tvault/.virtenv/lib/python2.7/site-packages/eventlet/event.pyt__repr__
s
(t__name__t
__module__R(((sC/home/tvault/.virtenv/lib/python2.7/site-packages/eventlet/event.pyR	s
cB
sžeZ
dZdZdZd
„Zd„Zd„Zd„Z	d„Z
d„Zdd„
Zdd„
Z
dd	„
Zd
„Zddd„Zd„Zd
„ZRS(sè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() <eventlet.greenthread.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
    c

C
stƒ|_
|jƒ
dS(
N(tsett_waiterstreset(
R((sC/home/tvault/.virtenv/lib/python2.7/site-packages/eventlet/event.pyt__init__,s

c
C
s>|jj
tt|ƒ
ƒ
|j|jt|jƒ
f}
d
|
S(Ns)<%s at %s result=%r _exc=%r _waiters[%d]>(t	__class__Rthextidt_resultt_exctlenR
(Rtparams((sC/home/tvault/.virtenv/lib/python2.7/site-packages/eventlet/event.pyt__str__0s


c

C
s1|jt
k	std
ƒ
‚
t
|_d|_dS(Ns#Trying to re-reset() a fresh event.(RRtAssertionErrortNoneR(
R((sC/home/tvault/.virtenv/lib/python2.7/site-packages/eventlet/event.pyR5s
	
c

C
s
|jt
k	S(
s]
 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(
R((sC/home/tvault/.virtenv/lib/python2.7/site-packages/eventlet/event.pytready=sc

C
s
|jdk	S(
N(RR(
R((sC/home/tvault/.virtenv/lib/python2.7/site-packages/eventlet/event.pyt
has_exceptionEs
c

C
s|jt
k	o|jdkS(
N(RRRR(
R((sC/home/tvault/.virtenv/lib/python2.7/site-packages/eventlet/event.pyt
has_resultHs
c
C
s|jƒr|j
ƒS|
S(
N(Rtwait(Rtnotready((sC/home/tvault/.virtenv/lib/python2.7/site-packages/eventlet/event.pytpollKs



c
C
s|jƒr|j
ƒS|
S(
N(RR(RR((sC/home/tvault/.virtenv/lib/python2.7/site-packages/eventlet/event.pytpoll_exceptionUs



c
C
s|jƒr|j
ƒS|
S(
N(RR(RR((sC/home/tvault/.virtenv/lib/python2.7/site-packages/eventlet/event.pytpoll_resultZs



c
C
stj
ƒ}
|jtkrV|jj|
ƒ

ztjƒjƒSWd
|jj	|
ƒ

Xn|j
d
k	rx|
j|j
Œ
n|jS(sOWait until another coroutine calls :meth:`send`.
        Returns the value the other coroutine passed to
        :meth:`send`.

        >>> from eventlet import event
        >>> import eventlet
        >>> evt = event.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'
        N(
tgreenlett
getcurrentRRR
taddR
tget_hubtswitchtdiscardRRtthrow(Rtcurrent((sC/home/tvault/.virtenv/lib/python2.7/site-packages/eventlet/event.pyR_s






cC
s›|jt
kstd
ƒ
‚
|
|_|dk	rLt|tƒrL|f
}n||_tjƒ}x3|j	D](}|j
d|j|j|j|ƒ
qkWdS(s]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.
        s/Trying to re-send() an already-triggered event.iN(RRRRt
isinstancettupleRR
R"R
tschedule_call_globalt_do_send(Rtresulttexcthubtwaiter((sC/home/tvault/.virtenv/lib/python2.7/site-packages/eventlet/event.pytsend€s
	


	



cC
s?||jkr;|dkr+|j|
ƒ

q;|j|Œ
ndS(
N(R
RR#R%(RR+R,R.((sC/home/tvault/.virtenv/lib/python2.7/site-packages/eventlet/event.pyR*¥s


c
G
s|jd
|
ƒS(sÞ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 "<stdin>", line 1, in <module>
             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 "<stdin>", line 1, in <module>
             File "eventlet/event.py", line 120, in wait
               current.throw(*self._exc)
             File "<stdin>", line 2, in <module>
           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(R/R(Rtargs((sC/home/tvault/.virtenv/lib/python2.7/site-packages/eventlet/event.pytsend_exception¬s)N(RRt__doc__RRRRRRRRRRRRRR/R*R1(((sC/home/tvault/.virtenv/lib/python2.7/site-packages/eventlet/event.pyRs 

						
	!%	N((t
__future__RteventletR
teventlet.supportRRt__all__RtobjectR(((sC/home/tvault/.virtenv/lib/python2.7/site-packages/eventlet/event.pyt<module>
s