ó
 ‹EYc@
sm
dZd
dl
mZ
d
dlZd
dlZd
dlZd
dlZd
dlmZ
d
dl	m
Z

d
dlmZ
d
dl
mZ
d
dlmZ
d
d	lmZ
d
ddd
ddgZeƒZejjjZejjjZdef
d„ƒYZd
ef
d„ƒYZdef
d„ƒYZd
ef
d„ƒYZdef
d„ƒYZdef
d„ƒYZdS(sÌSynchronized queues.

The :mod:`eventlet.queue` module implements multi-producer, multi-consumer
queues that work across greenlets, with the API similar to the classes found in
the standard :mod:`Queue` and :class:`multiprocessing <multiprocessing.Queue>`
modules.

A major difference is that queues in this module operate as channels when
initialized with *maxsize* of zero. In such case, both :meth:`Queue.empty`
and :meth:`Queue.full` return ``True`` and :meth:`Queue.put` always blocks until
a call to :meth:`Queue.get` retrieves the item.

An interesting difference, made possible because of greenthreads, is
that :meth:`Queue.qsize`, :meth:`Queue.empty`, and :meth:`Queue.full` *can* be
used as indicators of whether the subsequent :meth:`Queue.get`
or :meth:`Queue.put` will not block.  The new methods :meth:`Queue.getting`
and :meth:`Queue.putting` report on the number of greenthreads blocking
in :meth:`put <Queue.put>` or :meth:`get <Queue.get>` respectively.
iÿÿÿÿ(
tprint_functionN(
tEvent(
t
getcurrent(
tget_hub(
tsix(
tqueue(
tTimeouttQueuet
PriorityQueuet	LifoQueuet
LightQueuetFulltEmptytWaitercB
sneZ
dZd
g
Zd„Zd„Zd„Zd„ZeZe	d„ƒ
Z
d
d„
Zd„Z
d	„ZRS(s6A low level synchronization class.

    Wrapper around greenlet's ``switch()`` and ``throw()`` calls that makes them safe:

    * switching will occur only if the waiting greenlet is executing :meth:`wait`
      method currently. Otherwise, :meth:`switch` and :meth:`throw` are no-ops.
    * any error raised in the greenlet is handled inside :meth:`switch` and :meth:`throw`

    The :meth:`switch` and :meth:`throw` methods must only be called from the :class:`Hub` greenlet.
    The :meth:`wait` method must be called from a greenlet other than :class:`Hub`.
    tgreenletc

C
s
d|_
dS(
N(tNoneR(
tself((sC/home/tvault/.virtenv/lib/python2.7/site-packages/eventlet/queue.pyt__init__Ns
c
C
sD|jrd
}
nd}
dt
|ƒ
jtt|ƒ
ƒ
|
|jfS(Ns waitingts<%s at %s%s greenlet=%r>(twaitingttypet__name__thextidR(RR((sC/home/tvault/.virtenv/lib/python2.7/site-packages/eventlet/queue.pyt__repr__Qs

	
	

c
C
s5|jrd
}
nd}
dt
|ƒ
j|
|jfS(sD
        >>> print(Waiter())
        <Waiter greenlet=None>
        s waitingRs<%s%s greenlet=%s>(RRRR(RR((sC/home/tvault/.virtenv/lib/python2.7/site-packages/eventlet/queue.pyt__str__Zs	
	
c

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

C
s
|jdk	S(
N(RR(
R((sC/home/tvault/.virtenv/lib/python2.7/site-packages/eventlet/queue.pyRjscC
s_tƒt
ƒjks!td
ƒ
‚
|jdk	r[y|jj|
ƒ

Wq[


tjƒ
q[XndS(sWake up the greenlet that is calling wait() currently (if there is one).
        Can only be called from Hub's greenlet.
        s3Can only use Waiter.switch method from the mainloopN(RRRtAssertionErrorRtswitcht	tracebackt	print_exc(Rtvalue((sC/home/tvault/.virtenv/lib/python2.7/site-packages/eventlet/queue.pyRns
	




c
G
s_tƒt
ƒjks!td
ƒ
‚
|jdk	r[y|jj|
Œ
Wq[


tjƒ
q[XndS(suMake greenlet calling wait() wake up (if there is a wait()).
        Can only be called from Hub's greenlet.
        s3Can only use Waiter.switch method from the mainloopN(RRRRRtthrowRR(Rt
throw_args((sC/home/tvault/.virtenv/lib/python2.7/site-packages/eventlet/queue.pyR zs
	




c

C
sS|jdks%td
|jf
ƒ
‚
tƒ|_ztƒjƒSWdd|_XdS(s2Wait until switch() or throw() is called.
        s!This Waiter is already used by %rN(RRRRRR(
R((sC/home/tvault/.virtenv/lib/python2.7/site-packages/eventlet/queue.pytwait‡s
%


N(Rt
__module__t__doc__t	__slots__RRRRt__bool__tpropertyRRRR R"(((sC/home/tvault/.virtenv/lib/python2.7/site-packages/eventlet/queue.pyR
@s
							
cB
sÈeZ
dZdd
„
Zd„Zd„Zd„Zd„Zd„Z	d„Z
d„Zd	„Zd
„Z
d„Zd„Zd
„Zedd„Zd„Zedd„Zd„Zd„Zd„ZRS(s 

    This is a variant of Queue that behaves mostly like the standard
    :class:`Stdlib_Queue`.  It differs by not supporting the
    :meth:`task_done <Stdlib_Queue.task_done>` or
    :meth:`join <Stdlib_Queue.join>` methods, and is a little faster for
    not having that overhead.
    cC
s_|
dks|
d
kr$d|_
n	|
|_
tƒ|_tƒ|_d|_|j|
ƒ

dS(Ni(Rtmaxsizetsettgetterstputterst
_event_unlockt_init(RR(((sC/home/tvault/.virtenv/lib/python2.7/site-packages/eventlet/queue.pyR›s

	


	
cC
stj
ƒ|_dS(
N(tcollectionstdequeR(RR(((sC/home/tvault/.virtenv/lib/python2.7/site-packages/eventlet/queue.pyR-§s
c


C
s
|jj
ƒS(
N(Rtpopleft(
R((sC/home/tvault/.virtenv/lib/python2.7/site-packages/eventlet/queue.pyt_getªs
cC
s|jj
|
ƒ

dS(
N(Rtappend(Rtitem((sC/home/tvault/.virtenv/lib/python2.7/site-packages/eventlet/queue.pyt_put­s
c

C
s,d
t|ƒ
j
tt|ƒ
ƒ
|jƒfS(Ns
<%s at %s %s>(RRRRt_format(
R((sC/home/tvault/.virtenv/lib/python2.7/site-packages/eventlet/queue.pyR°s
c

C
sd
t|ƒ
j
|jƒfS(Ns<%s %s>(RRR5(
R((sC/home/tvault/.virtenv/lib/python2.7/site-packages/eventlet/queue.pyR³s
c
C
sœd
|jf
}
t
|ddƒr6|
d|j7}
n|jrY|
dt|jƒ
7}
n|jr||
dt|jƒ
7}
n|jdk	r˜|
d7}
n|
S(Ns
maxsize=%rRs	 queue=%rs getters[%s]s putters[%s]s
 unlocking(R(tgetattrRRR*tlenR+R,(Rtresult((sC/home/tvault/.virtenv/lib/python2.7/site-packages/eventlet/queue.pyR5¶s



	

	




c

C
s
t|j
ƒ
S(
sReturn the size of the queue.(R7R(
R((sC/home/tvault/.virtenv/lib/python2.7/site-packages/eventlet/queue.pytqsizeÂscC
sD|jd
k	r7|
d
ks*|
|jkr7|jƒ
n|
|_d
S(syResizes the queue's maximum size.

        If the size is increased, and there are putters waiting, they may be woken up.N(R(Rt_schedule_unlock(Rtsize((sC/home/tvault/.virtenv/lib/python2.7/site-packages/eventlet/queue.pytresizeÆs*

c

C
s
t|j
ƒ
S(
s`Returns the number of greenthreads that are blocked waiting to put
        items into the queue.(R7R+(
R((sC/home/tvault/.virtenv/lib/python2.7/site-packages/eventlet/queue.pytputtingÐsc

C
s
t|j
ƒ
S(
sVReturns the number of greenthreads that are blocked waiting on an
        empty queue.(R7R*(
R((sC/home/tvault/.virtenv/lib/python2.7/site-packages/eventlet/queue.pytgettingÕsc


C
s|jƒS(
s;Return ``True`` if the queue is empty, ``False`` otherwise.(
R9(
R((sC/home/tvault/.virtenv/lib/python2.7/site-packages/eventlet/queue.pytemptyÚsc

C
s"|jd
k	o!|jƒ|jkS(skReturn ``True`` if the queue is full, ``False`` otherwise.

        ``Queue(None)`` is never full.
        N(R(RR9(
R((sC/home/tvault/.virtenv/lib/python2.7/site-packages/eventlet/queue.pytfullÞscC
s~
|jd
ks$|jƒ|jkrJ|j|
ƒ

|jrz
|jƒ
qz
n0
|r¾tƒjtƒkr¾xL|jr´|jj	ƒ}|ri|j|
ƒ

|j
ƒ}
|j|
ƒ

d
SqiWt‚
n¼|rt
t
|
ƒ
}|jj|ƒ

t|tƒ}zd|jr
|jƒ
n|jƒ}||ks3
td|f
ƒ
‚
|jtk	rR
|j|
ƒ

nWd
|jƒ
|jj|ƒ

Xnt‚
d
S(s#Put an item into the queue.

        If optional arg *block* is true and *timeout* is ``None`` (the default),
        block if necessary until a free slot is available. If *timeout* is
        a positive number, it blocks at most *timeout* seconds and raises
        the :class:`Full` exception if no free slot was available within that time.
        Otherwise (*block* is false), put an item on the queue if a free slot
        is immediately available, else raise the :class:`Full` exception (*timeout*
        is ignored in that case).
        Ns!Invalid switch into Queue.put: %r(R(RR9R4R*R:RRRtpopR1RRt
ItemWaiterR+taddRR"RR3t_NONEtcanceltdiscard(RR3tblockttimeouttgettertwaiterR8((sC/home/tvault/.virtenv/lib/python2.7/site-packages/eventlet/queue.pytputæs6$

	










	





	







cC
s|j|
t
ƒ
d
S(s²Put an item into the queue without blocking.

        Only enqueue the item if a free slot is immediately available.
        Otherwise raise the :class:`Full` exception.
        N(RKtFalse(RR3((sC/home/tvault/.virtenv/lib/python2.7/site-packages/eventlet/queue.pyt
put_nowait
scC
s
|jƒr,|j
r"|jƒ
n|jƒS|
rœtƒjtƒkrœxH|j
r’|j
jƒ}|rK|j|ƒ

|jƒr|jƒSqKqKWt	‚
ny|
r
t
ƒ}t|t	ƒ}z4|jj
|ƒ

|j
rã|jƒ
n|jƒSWd
|jj|ƒ

|jƒ
Xnt	‚
d
S(sRemove and return an item from the queue.

        If optional args *block* is true and *timeout* is ``None`` (the default),
        block if necessary until an item is available. If *timeout* is a positive number,
        it blocks at most *timeout* seconds and raises the :class:`Empty` exception
        if no item was available within that time. Otherwise (*block* is false), return
        an item if one is immediately available, else raise the :class:`Empty` exception
        (*timeout* is ignored in that case).
        N(R9R+R:R1RRRRARRR
RR*RCR"RFRE(RRGRHtputterRJ((sC/home/tvault/.virtenv/lib/python2.7/site-packages/eventlet/queue.pytget
s.

	











	

	



	



c

C
s
|jt
ƒ
S(
s´Remove and return an item from the queue without blocking.

        Only get an item if one is immediately available. Otherwise
        raise the :class:`Empty` exception.
        (RORL(
R((sC/home/tvault/.virtenv/lib/python2.7/site-packages/eventlet/queue.pyt
get_nowait@
sc
C
s|
zk
xd
tri
|j
ƒrv|jrv|jjƒ}
|
rf
y|jƒ}Wn


|
jtjƒŒ
qsX|
j|ƒ

qf
q|j	r
|jr
|j	jƒ}|rf
|jjƒ}
|
rú|j
}t|_
|j|ƒ

|jƒ}|
j|ƒ

|j|ƒ

q

|j	j
|ƒ

qf
q|j	re
|jsF
|jdksF
|j
ƒ|jkre
|j	jƒ}|j|ƒ

qPqWWdd|_XdS(
N(tTrueR9R*RAR1R tsystexc_infoRR+R3RDR4RCR(RR,(RRIR3RN((sC/home/tvault/.virtenv/lib/python2.7/site-packages/eventlet/queue.pyt_unlockH
s:

	












		










	c

C
s1|jdkr-tƒjd
|jƒ|_ndS(Ni(R,RRtschedule_call_globalRT(
R((sC/home/tvault/.virtenv/lib/python2.7/site-packages/eventlet/queue.pyR:o
s

N(RR#R$RRR-R1R4RRR5R9R<R=R>R?R@RQRKRMRORPRTR:(((sC/home/tvault/.virtenv/lib/python2.7/site-packages/eventlet/queue.pyR
’s(								
				,	&		'RBc
B
seZ
dg
Zd
„ZRS(R3cC
stj
|ƒ

|
|_dS(
N(R
RR3(RR3((sC/home/tvault/.virtenv/lib/python2.7/site-packages/eventlet/queue.pyRw
s


(RR#R%R(((sC/home/tvault/.virtenv/lib/python2.7/site-packages/eventlet/queue.pyRBt
s
	cB
sGeZ
dZdd
„
Zd„Zd„Zd„Zd„Zd„Z	RS(s¯
Create a queue object with a given maximum size.

    If *maxsize* is less than zero or ``None``, the queue size is infinite.

    ``Queue(0)`` is a channel, that is, its :meth:`put` method always blocks
    until the item is delivered. (This is unlike the standard
    :class:`Stdlib_Queue`, where 0 means infinite size).

    In all other respects, this Queue class resembles the standard library,
    :class:`Stdlib_Queue`.
    cC
s)tj
||
ƒ
d
|_tƒ|_dS(Ni(R
Rtunfinished_tasksR
t_cond(RR(((sC/home/tvault/.virtenv/lib/python2.7/site-packages/eventlet/queue.pyR‰
s

	
c
C
s9tj
|ƒ
}
|jr5|
d
|j|jf7}
n|
S(Ns tasks=%s _cond=%s(R
R5RVRW(RR8((sC/home/tvault/.virtenv/lib/python2.7/site-packages/eventlet/queue.pyR5Ž
s

	

cC
stj
||
ƒ
|jƒ
dS(
N(R
R4t_put_bookkeeping(RR3((sC/home/tvault/.virtenv/lib/python2.7/site-packages/eventlet/queue.pyR4”
s

c

C
s2|jd
7_|j
jƒr.|j
jƒ
ndS(Ni
(RVRWtreadytreset(
R((sC/home/tvault/.virtenv/lib/python2.7/site-packages/eventlet/queue.pyRX˜
s


c

C
sS|jd
k
rt
dƒ
‚
n|jd8_|jd
krO|jjdƒ

ndS(sYIndicate that a formerly enqueued task is complete. Used by queue consumer threads.
        For each :meth:`get <Queue.get>` used to fetch a task, a subsequent call to
        :meth:`task_done` tells the queue that the processing on the task is complete.

        If a :meth:`join` is currently blocking, it will resume when all items have been processed
        (meaning that a :meth:`task_done` call was received for every item that had been
        :meth:`put <Queue.put>` into the queue).

        Raises a :exc:`ValueError` if called more times than there were items placed in the queue.
        is!task_done() called too many timesi
N(RVt
ValueErrorRWtsendR(
R((sC/home/tvault/.virtenv/lib/python2.7/site-packages/eventlet/queue.pyt	task_done
s




c

C
s#|jd
kr|j
jƒ
ndS(s’
Block until all items in the queue have been gotten and processed.

        The count of unfinished tasks goes up whenever an item is added to the queue.
        The count goes down whenever a consumer thread calls :meth:`task_done` to indicate
        that the item was retrieved and all work on it is complete. When the count of
        unfinished tasks drops to zero, :meth:`join` unblocks.
        iN(RVRWR"(
R((sC/home/tvault/.virtenv/lib/python2.7/site-packages/eventlet/queue.pytjoin¯
s
N(
RR#R$RRR5R4RXR]R^(((sC/home/tvault/.virtenv/lib/python2.7/site-packages/eventlet/queue.pyR|
s				cB
s5eZ
dZd
„Zejd„
Zejd„
ZRS(s¦A subclass of :class:`Queue` that retrieves entries in priority order (lowest first).

    Entries are typically tuples of the form: ``(priority number, data)``.
    cC
s
g|_dS(
N(
R(RR(((sC/home/tvault/.virtenv/lib/python2.7/site-packages/eventlet/queue.pyR-Á
s
cC
s||j|
ƒ
|j
ƒ
dS(
N(RRX(RR3theappush((sC/home/tvault/.virtenv/lib/python2.7/site-packages/eventlet/queue.pyR4Ä
s

cC
s
|
|jƒ
S(
N(
R(Rtheappop((sC/home/tvault/.virtenv/lib/python2.7/site-packages/eventlet/queue.pyR1È
s
(	RR#R$R-theapqR_R4R`R1(((sC/home/tvault/.virtenv/lib/python2.7/site-packages/eventlet/queue.pyR»
s	c
B
s)eZ
dZd
„Zd„Zd„ZRS(sNA subclass of :class:`Queue` that retrieves most recently added entries first.cC
s
g|_dS(
N(
R(RR(((sC/home/tvault/.virtenv/lib/python2.7/site-packages/eventlet/queue.pyR-Ï
s
cC
s|jj
|
ƒ

|jƒ
dS(
N(RR2RX(RR3((sC/home/tvault/.virtenv/lib/python2.7/site-packages/eventlet/queue.pyR4Ò
s

c


C
s
|jj
ƒS(
N(RRA(
R((sC/home/tvault/.virtenv/lib/python2.7/site-packages/eventlet/queue.pyR1Ö
s
(RR#R$R-R4R1(((sC/home/tvault/.virtenv/lib/python2.7/site-packages/eventlet/queue.pyR	Ì
s
		( R$t
__future__RRRRaR.Rteventlet.eventR
teventlet.greenthreadRt
eventlet.hubsRteventlet.supportRteventlet.support.six.movesRtStdlib_Queueteventlet.timeoutRt__all__tobjectRDtmovesRRR
R
RBRRR	(((sC/home/tvault/.virtenv/lib/python2.7/site-packages/eventlet/queue.pyt<module>)s*








	

Râ?