o 0׾gQ[@sdZddlmZddlZddlmZddlmZddlm Z ddl Z ej ddkr.ddl ZnddlZejZZejZZddlmZdd lmZdd lmZgZgd Zd d gZddgZeedrie dej!Z"eeee7ZddZ#ddl$Z%e%j&j'e(d<e)dj*e(d<dde(d<Gddde'Z+Gddde,Z Gddde Z-Gdd d e Z.Gd!d"d"e Z/Gd#d d e Z0Gd$d d e,Z1d%d&Z2e2dd'l3m4Z4e4e5d(dS))al Synchronized queues. The :mod:`gevent.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 ` modules. The classes in this module implement the iterator protocol. Iterating over a queue means repeatedly calling :meth:`get ` until :meth:`get ` returns ``StopIteration`` (specifically that class, not an instance or subclass). >>> import gevent.queue >>> queue = gevent.queue.Queue() >>> queue.put(1) >>> queue.put(2) >>> queue.put(StopIteration) >>> for item in queue: ... print(item) 1 2 .. versionchanged:: 1.0 ``Queue(0)`` now means queue of infinite size, not a channel. A :exc:`DeprecationWarning` will be issued with this argument. )absolute_importN)heappush)heappop)heapify)Timeout)get_hub_noargs)InvalidSwitchError)Queue PriorityQueue LifoQueue JoinableQueueChannelEmptyFull SimpleQueuecCs&z||WdStyYdSwN)remove ValueError)deqitemrV/var/www/html/backend_erp/backend_erp_env/lib/python3.10/site-packages/gevent/queue.py _safe_removeCs  rWaitergreenlet getcurrentcCsdSrrrrrrNsr greenlet_initc@s eZdZdZddZddZdS) ItemWaiter)rqueuecCst|||_||_dSr)r__init__rr )selfrr rrrr!Ws  zItemWaiter.__init__cCs$|j|jd|_d|_||Sr)r _putrswitchr"rrrput_and_switch\s zItemWaiter.put_and_switchN)__name__ __module__ __qualname__ __slots__r!r&rrrrrPs rc@s eZdZdZdZd>ddZedd Zejd d Zd d Z d?d dZ ddZ ddZ ddZ ddZddZddZddZddZdd Zd!d"Zd#d$Zd%d&Zd@d(d)Zd*d+Zd,d-Zd@d.d/Zd0d1Zd@d2d3Zd4d5Zd6d7Zd8d9Zd:d;Z d)r"nvrrrr:s  cCst||j|jSr)typer:r r%rrrcopysz Queue.copycCs t|Sr)r6r7r"r;rrrr9 zQueue._create_queuecC |jSr)r popleftr%rrr_getrDz Queue._getcC |jdSr=r r%rrr_peekrDz Queue._peekcC|j|dSrr appendr"rrrrr#z Queue._putcC dt|jtt||fS)Nz <%s at %s%s>rAr'hexid_formatr%rrr__repr__ zQueue.__repr__cCdt|j|fS)Nz<%s%s>rAr'rTr%rrr__str__z Queue.__str__cCsg}|jdur|d|jft|ddr|d|jf|jr,|dt|j|jr9|dt|j|rBdd|SdS)Nz maxsize=%rr zqueue=%rz getters[%s]z putters[%s] )r:rMgetattrr r,lenr-joinr"resultrrrrTs  z Queue._formatcC t|jS)zReturn the size of the queue.)r^r r%rrrqsize z Queue.qsizecCs|S)z Return the size of the queue. This is the same as :meth:`qsize`. .. versionadded: 1.1b3 Previously, getting len() of a queue would raise a TypeError. rcr%rrr__len__s z Queue.__len__cCdS)z A queue object is always True. .. versionadded: 1.1b3 Now that queues support len(), they need to implement ``__bool__`` to return True for backwards compatibility. Trr%rrr__bool__s zQueue.__bool__cCrgNTrr%rrr __nonzero__szQueue.__nonzero__cCs | S)z;Return ``True`` if the queue is empty, ``False`` otherwise.rer%rrremptyrdz Queue.emptycCs|jdko ||jkS)zkReturn ``True`` if the queue is full, ``False`` otherwise. ``Queue(None)`` is never full. r)r+rcr%rrrfullsz Queue.fullTc Cs8|jdks ||jkr|||jr|dSdS|jturX|jrH|rH||jkrH|j}|||jrH|rH||jks0||jkrV||dSt |rt ||}|j |t |t }z#|jrs||}||urtd|fW|t|j |dS|t|j |wt )a#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). r2Nz!Invalid switch into Queue.put: %r)r+rcr#r,_schedule_unlockr.rrFr$rrr-rMr_start_new_or_dummygetr cancelrr"rblocktimeoutgetterwaiterrarrrputs<         z Queue.putcCs||ddS)zPut an item into the queue without blocking. Only enqueue the item if a free slot is immediately available. Otherwise raise the :class:`Full` exception. FNrvrNrrr put_nowait"szQueue.put_nowaitc Cs|jtur|jr|j|r|S|js t|s tt}t |t}z*|j ||jr7| | }||urFtd|f|W|t|j |S|t|j |w)Nz!Invalid switch into Queue.get: %r)r.rr-rFr&rcrrrrnr,rMrmror rpr)r"methodrrrsrurarrr __get_or_peek+s.   zQueue.__get_or_peekcCs.|r|jr ||S||j||S)aRemove 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). )rcr-rmrG_Queue__get_or_peekr"rrrsrrrroOs  z Queue.getcC |dS)zRemove and return an item from the queue without blocking. Only get an item if one is immediately available. Otherwise raise the :class:`Empty` exception. Fror%rrr get_nowait` zQueue.get_nowaitcCs |r|S||j||S)aReturn an item from the queue without removing it. 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). )rcrJr{r|rrrpeekhs z Queue.peekcCr})zReturn an item from the queue without blocking. Only return an item if one is immediately available. Otherwise raise the :class:`Empty` exception. F)rr%rrr peek_nowaityrzQueue.peek_nowaitcCs d}|jr3|jdks||jkr3d}z |j}||jWn |jtYn| ||j rF|rFd}|j }| ||sJdSq)NTFr2) r-r+rcrFr#rthrowsysexc_infor$r,)r"repeatputterrtrrr_unlocks"    z Queue._unlockcC |js|jj|j|_dSdSrr/r.loop run_callbackrr%rrrrmzQueue._schedule_unlockcC|Srrr%rrr__iter__zQueue.__iter__cC|}|tur ||Srro StopIterationr`rrr__next__zQueue.__next__)NrrrTN)#r'r(r)__doc__r*r!propertyr:setterrBr9rGrJr#rUrYrTrcrfrhrjrkrlrvrxr{rorrrrrmrrnextrrrrr bsD       * $ r c@s$eZdZdZdddZd ddZdS) UnboundQueuerNcCs(|durtdt|||d|_dS)NzUnboundQueue has no maxsize)rr r!r-)r"r:r;rrrr!s zUnboundQueue.__init__TcCs |||jr|dSdSr)r#r,rm)r"rrrrsrrrrvs  zUnboundQueue.put)Nrr)r'r(r)r*r!rvrrrrrs rc@s.eZdZdZdZd ddZddZddZd S) r aA subclass of :class:`Queue` that retrieves entries in priority order (lowest first). Entries are typically tuples of the form: ``(priority number, data)``. .. versionchanged:: 1.2a1 Any *items* given to the constructor will now be passed through :func:`heapq.heapify` to ensure the invariants of this class hold. Previously it was just assumed that they were already a heap. rcCst|}t||Sr)list_heapify)r"r;qrrrr9szPriorityQueue._create_queuecCst|j|dSr) _heappushr rNrrrr#rOzPriorityQueue._putcCrbr)_heappopr r%rrrrGrDzPriorityQueue._getNr)r'r(r)rr*r9r#rGrrrrr s   r c@s6eZdZdZdZd ddZddZddZd d Zd S) r zNA subclass of :class:`Queue` that retrieves most recently added entries first.rcCst|Sr)rrCrrrr9szLifoQueue._create_queuecCrKrrLrNrrrr#rOzLifoQueue._putcCrEr)r popr%rrrrGrDzLifoQueue._getcCrH)Nr2rIr%rrrrJrDzLifoQueue._peekNr) r'r(r)rr*r9r#rGrJrrrrr s  r c@sHeZdZdZdZdddZddZd d Zd d Zd dZ dddZ dS)r zl A subclass of :class:`Queue` that additionally has :meth:`task_done` and :meth:`join` methods. )_condunfinished_tasksNrcCsjtj|||ddddlm}||_|j|r||_n |r&t||_nd|_|jr3|jdSdS)z .. versionchanged:: 1.1a1 If *unfinished_tasks* is not given, then all the given *items* (if any) will be considered unfinished. )r<r)EventN) r r! gevent.eventrrsetrr^clear)r"r:r;rrrrrr!s   zJoinableQueue.__init__cCst||j|j|jSr)rAr:r rr%rrrrBrZzJoinableQueue.copycCs(t|}|jr|d|j|jf7}|S)Nz tasks=%s _cond=%s)r rTrrr`rrrrTs zJoinableQueue._formatcCs(t|||jd7_|jdS)N)r r#rrrrNrrrr# s zJoinableQueue._putcCs<|jdkr td|jd8_|jdkr|jdSdS)aYIndicate that a formerly enqueued task is complete. Used by queue consumer threads. For each :meth:`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 ` into the queue). Raises a :exc:`ValueError` if called more times than there were items placed in the queue. rz!task_done() called too many timesrN)rrrrr%rrr task_dones  zJoinableQueue.task_donecCs|jj|dS)a 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. :param float timeout: If not ``None``, then wait no more than this time in seconds for all tasks to finish. :return: ``True`` if all tasks have finished; if ``timeout`` was given and expired before all tasks finished, ``False``. .. versionchanged:: 1.1a1 Add the *timeout* parameter. )rs)rwait)r"rsrrrr_#szJoinableQueue.join)NrNr) r'r(r)rr*r!rBrTr#rr_rrrrr s c@seZdZdZd%ddZddZddZd d Zed d Z d dZ ddZ ddZ d&ddZ ddZd&ddZddZddZdd Zd!d"Zd#d$ZeZdS)'r)r,r-r.r/r0rcCs6|dkrtdt|_t|_t|_d|_dS)NrzChannels have a maxsize of 1)rr6r7r,r-r8r.r/)r"r:rrrr!As    zChannel.__init__cCrP)Nz <%s at %s %s>rQr%rrrrUJrVzChannel.__repr__cCrW)Nz<%s %s>rXr%rrrrYMrZzChannel.__str__cCs8d}|jr|dt|j7}|jr|dt|j7}|S)Nr\z getters[%s]z putters[%s])r,r^r-r`rrrrTPs zChannel._formatcCst|jt|jSr)r^r-r,r%rrrbalanceXr?zChannel.balancecCrgr=rr%rrrrc\rz Channel.qsizecCrgrirr%rrrrk_rz Channel.emptycCrgrirr%rrrrlbrz Channel.fullTNcCs|jtur|jr|j}||dSt|sd}t}||f}|j|t |t}z*z|jr7| | }||urFt d|fWn t|j|W|dS|w)Nrz#Invalid switch into Channel.put: %r)r.rr,rFr$rrr-rMrrnrmror rrprqrrrrves0      z Channel.putcCs||ddSNFrwrNrrrrxrOzChannel.put_nowaitcCs|jtur|jr|j\}}|jj|j||S|sd}t}t |t }z"z|j ||jr7| |WW|S|j ||wr=)r.rr-rFrrr$rrrnrr,rMrmrocloser)r"rrrsrrrurrrros&       z Channel.getcCr}rr~r%rrrrrDzChannel.get_nowaitcCsT|jr$|jr(|j}|j\}}|||||jr&|jsdSdSdSdSr)r-r,rFr$)r"rtrrrrrrs    zChannel._unlockcCrrrr%rrrrmrzChannel._schedule_unlockcCrrrr%rrrrrzChannel.__iter__cCrrrr`rrrrrzChannel.__next__)rr)r'r(r)r*r!rUrYrTrrrcrkrlrvrxrorrrmrrrrrrrr7s(     cCs tdSr)rrrrr_initrDr)import_c_accelz gevent._queue)6r __future__rrheapqrrrrrrr6 version_infor __queue__r r_Fullr_Emptygevent.timeoutrgevent._hub_localrr8gevent.exceptionsr __all____implements____extensions__ __imports__hasattrrM_PySimpleQueuerrgevent._waitergevent_waiterrlocals __import__rrobjectrr r r rr gevent._utilrglobalsrrrrsR            DV|