o 0׾g"d@sdZddlmZmZmZddlmZmZmZ ddl m Z m Z ddl mZddlmZddlmZddlmZmZdd lmZdd lmZdd lmZgd ZGd ddeZGdddeZGdddeZ GdddeZ!GdddeZ"dS)a2 Managing greenlets in a group. The :class:`Group` class in this module abstracts a group of running greenlets. When a greenlet dies, it's automatically removed from the group. All running greenlets in a group can be waited on with :meth:`Group.join`, or all running greenlets can be killed with :meth:`Group.kill`. The :class:`Pool` class, which is a subclass of :class:`Group`, provides a way to limit concurrency: its :meth:`spawn ` method blocks if the number of greenlets in the pool has already reached the limit, until there is a free slot. )print_functionabsolute_importdivision) GreenletExit getcurrentkill)joinallGreenlet)Full)Timeout)Event) SemaphoreDummySemaphore)izip)IMap) IMapUnordered)GroupPoolPoolFullc@seZdZdZddZddZddZdd Zdd d Zdd dZ d ddZ ddZ ddZ d!ddZ d!ddZddZddZddZd S)"GroupMappingMixincOt)a A function that runs *func* with *args* and *kwargs*, potentially asynchronously. Return a value with a ``get`` method that blocks until the results of func are available, and a ``rawlink`` method that calls a callback when the results are available. If this object has an upper bound on how many asyncronously executing tasks can exist, this method may block until a slot becomes available. NotImplementedError)selffuncargskwargsrrU/var/www/html/backend_erp/backend_erp_env/lib/python3.10/site-packages/gevent/pool.pyspawn-s zGroupMappingMixin.spawncCr)zc should the function passed to apply be called immediately, synchronously? rrrrr_apply_immediately9z$GroupMappingMixin._apply_immediatelycCr)z Should apply_async directly call Greenlet.spawn(), bypassing `spawn`? Return true when self.spawn would block. rr rrr_apply_async_use_greenlet@sz+GroupMappingMixin._apply_async_use_greenletcCr)zk Run the given callback function, possibly asynchronously, possibly synchronously. rrcallbackresultrrr_apply_async_cb_spawnIr"z'GroupMappingMixin._apply_async_cb_spawnNcCs&||||}|dur||||S)a :meth:`apply` the given *func(\*args, \*\*kwds)*, and, if a *callback* is given, run it with the results of *func* (unless an exception was raised.) The *callback* may be called synchronously or asynchronously. If called asynchronously, it will not be tracked by this group. (:class:`Group` and :class:`Pool` call it asynchronously in a new greenlet; :class:`~gevent.threadpool.ThreadPool` calls it synchronously in the current greenlet.) N)applyr')rrrkwdsr%r&rrrapply_cbPs  zGroupMappingMixin.apply_cbcCsf|durd}|dur i}|rt|j||||S|j|g|Ri|}|dur1|t||S)a A variant of the :meth:`apply` method which returns a :class:`~.Greenlet` object. When the returned greenlet gets to run, it *will* call :meth:`apply`, passing in *func*, *args* and *kwds*. If *callback* is specified, then it should be a callable which accepts a single argument. When the result becomes ready callback is applied to it (unless the call failed). This method will never block, even if this group is full (that is, even if :meth:`spawn` would block, this method will not). .. caution:: The returned greenlet may or may not be tracked as part of this group, so :meth:`joining ` this group is not a reliable way to wait for the results to be available or for the returned greenlet to run; instead, join the returned greenlet. .. tip:: Because :class:`~.ThreadPool` objects do not track greenlets, the returned greenlet will never be a part of it. To reduce overhead and improve performance, :class:`Group` and :class:`Pool` may choose to track the returned greenlet. These are implementation details that may change. Nr)r#r rr*link pass_value)rrrr)r%greenletrrr apply_async_s zGroupMappingMixin.apply_asynccCsJ|durd}|dur i}|r||i|S|j|g|Ri|S)a Rough quivalent of the :func:`apply()` builtin function blocking until the result is ready and returning it. The ``func`` will *usually*, but not *always*, be run in a way that allows the current greenlet to switch out (for example, in a new greenlet or thread, depending on implementation). But if the current greenlet or thread is already one that was spawned by this pool, the pool may choose to immediately run the `func` synchronously. Any exception ``func`` raises will be propagated to the caller of ``apply`` (that is, this method will raise the exception that ``func`` raised). Nr)r!rget)rrrr)rrrr(szGroupMappingMixin.applycsddfdd|DDS)NcSsg|]}|qSr)r/).0grrr sz+GroupMappingMixin.__map..csg|]}|qSr)r)r0irrrrr2sr)rriterablerr4r__mapszGroupMappingMixin.__mapcCst|j||}|S)z~Return a list made by applying the *func* to each element of the iterable. .. seealso:: :meth:`imap` )r r_GroupMappingMixin__mapr/)rrr5r1rrrmaps"zGroupMappingMixin.mapcCs |||}|dur|||SN)r8)rrr5r%r&rrrmap_cbs zGroupMappingMixin.map_cbcCst|j|||S)z A variant of the map() method which returns a Greenlet object that is executing the map function. If callback is specified then it should be a callable which accepts a single argument. )r rr:)rrr5r%rrr map_asyncszGroupMappingMixin.map_asynccOs2|dd}|r td|j|t||jd|dS)NmaxsizezUnsupported keyword argumentsT)r_zippedr<)pop TypeErrorrr)rclsr iterablesrr<rrr__imaps zGroupMappingMixin.__imapcO|jt|g|Ri|S)a imap(func, *iterables, maxsize=None) -> iterable An equivalent of :func:`itertools.imap`, operating in parallel. The *func* is applied to each element yielded from each iterable in *iterables* in turn, collecting the result. If this object has a bound on the number of active greenlets it can contain (such as :class:`Pool`), then at most that number of tasks will operate in parallel. :keyword int maxsize: If given and not-None, specifies the maximum number of finished results that will be allowed to accumulate awaiting the reader; more than that number of results will cause map function greenlets to begin to block. This is most useful if there is a great disparity in the speed of the mapping code and the consumer and the results consume a great deal of resources. .. note:: This is separate from any bound on the number of active parallel tasks, though they may have some interaction (for example, limiting the number of parallel tasks to the smallest bound). .. note:: Using a bound is slightly more computationally expensive than not using a bound. .. tip:: The :meth:`imap_unordered` method makes much better use of this parameter. Some additional, unspecified, number of objects may be required to be kept in memory to maintain order by this function. :return: An iterable object. .. versionchanged:: 1.1b3 Added the *maxsize* keyword parameter. .. versionchanged:: 1.1a1 Accept multiple *iterables* to iterate in parallel. )_GroupMappingMixin__imaprrrrArrrrimaps$zGroupMappingMixin.imapcOrC)a imap_unordered(func, *iterables, maxsize=None) -> iterable The same as :meth:`imap` except that the ordering of the results from the returned iterator should be considered in arbitrary order. This is lighter weight than :meth:`imap` and should be preferred if order doesn't matter. .. seealso:: :meth:`imap` for more details. )rDrrErrrimap_unordered s z GroupMappingMixin.imap_unordered)NNNNNr9)__name__ __module__ __qualname__ __slots__rr!r#r'r*r.r(r7r8r:r;rDrFrGrrrrr's     - %   &rc@seZdZdZeZddZddZddZdd Z d d Z d d Z ddZ ddZ ddZddZd)ddZeddfddZeddfddZdd Zd*d!d"Zd#d$Zd%d&Zd'd(ZdS)+ra Maintain a group of greenlets that are still running, without limiting their number. Links to each item and removes it upon notification. Groups can be iterated to discover what greenlets they are tracking, they can be tested to see if they contain a greenlet, and they know the number (len) of greenlets they are tracking. If they are not tracking any greenlets, they are False in a boolean context. .. attribute:: greenlet_class Either :class:`gevent.Greenlet` (the default) or a subclass. These are the type of object we will :meth:`spawn`. This can be changed on an instance or in a subclass. cGsZt|dks J|t||_|r|dD]}||jqt|_t|_|jdS)Nr)lenset greenletsrawlink_discarddyingr _empty_event)rrr-rrr__init__1s  zGroup.__init__cCsd|jjt||jfS)Nz<%s at 0x%x %s>) __class__rIidrPr rrr__repr__<szGroup.__repr__cC t|jS)z Answer how many greenlets we are tracking. Note that if we are empty, we are False in a boolean context. )rNrPr rrr__len__?s z Group.__len__cCs ||jvS)z? Answer if we are tracking the given greenlet. )rPritemrrr __contains__F zGroup.__contains__cCrY)z[ Iterate across all the greenlets we are tracking, in no particular order. )iterrPr rrr__iter__Lr^zGroup.__iter__cCsBz|j}Wn tyYnw||j|j||jdS)ar Begin tracking the *greenlet*. If this group is :meth:`full`, then this method may block until it is possible to track the greenlet. Typically the *greenlet* should **not** be started when it is added because if this object blocks in this method, then the *greenlet* may run to completion before it is tracked. N)rQAttributeErrorrRrPaddrTclear)rr-rQrrrrbRs    z Group.addcCs0|j||j||js|jdSdSr9)rPdiscardrSrTrOrr-rrrrRfs  zGroup._discardcCs8||z|j}Wn tyYdSw||jdS)z- Stop tracking the greenlet. N)rRunlinkra)rr-rfrrrrdls   z Group.discardcCs|||dS)z Add the **unstarted** *greenlet* to the collection of greenlets this group is monitoring, and then start it. Nrbstartrerrrrhxs  z Group.startcOs|j|i|}|||S)z Begin a new greenlet with the given arguments (which are passed to the greenlet constructor) and add it to the collection of greenlets this group is monitoring. :return: The newly started greenlet. )greenlet_classrh)rrrr-rrrrs z Group.spawnNFcCsP|rt|jnd}|jj|d}|D]}|jdur%t|dr"||jq|S)a; Wait for this group to become empty *at least once*. If there are no greenlets in the group, returns immediately. .. note:: By the time the waiting code (the caller of this method) regains control, a greenlet may have been added to this group, and so this object may no longer be empty. (That is, ``group.join(); assert len(group) == 0`` is not guaranteed to hold.) This method only guarantees that the group reached a ``len`` of 0 at some point. :keyword bool raise_error: If True (*not* the default), if any greenlet that finished while the join was in progress raised an exception, that exception will be raised to the caller of this method. If multiple greenlets raised exceptions, which one gets re-raised is not determined. Only greenlets currently in the group when this method is called are guaranteed to be checked for exceptions. :return bool: A value indicating whether this group became empty. If the timeout is specified and the group did not become empty during that timeout, then this will be a false value. Otherwise it will be a true value. .. versionchanged:: 1.2a1 Add the return value. rtimeoutN_raise_exception)listrPrTwait exceptionhasattrrl)rrk raise_errorrPr&r-rrrjoins  z Group.joinTc Cst|}zdz>|jrCt|jD](}||jvrqz|j}Wnty*t||Ynw||dd|j|q|s;nt |j|js Wnty[}z ||urQWYd}~n d}~wwW| dSW| dS| w)zA Kill all greenlets being tracked by this group. FblockN) r _start_new_or_dummyrPrmrSrra_killrbrcancel)rrortrktimerr-rexrrrrs8        z Group.killcCsL||jvr ||jvr"|j|dd|j||r$||dSdSdSdS)zf If the given *greenlet* is running and being tracked by this group, kill it. FrsN)rSrPrrbrr)rr-rortrkrrrkillones z Group.killonecCdS)z Return a value indicating whether this group can track more greenlets. In this implementation, because there are no limits on the number of tracked greenlets, this will always return a ``False`` value. Frr rrrfullsz Group.fullcCr{)z Block until it is possible to :meth:`spawn` a new greenlet. In this implementation, because there are no limits on the number of tracked greenlets, this will always return immediately. Nrrrkrrrwait_availableszGroup.wait_availablecCs t|vSr9)rr rrrr!r^zGroup._apply_immediatelycCst||dSr9)r rr$rrrr'szGroup._apply_async_cb_spawncCs|Sr9)r|r rrrr#szGroup._apply_async_use_greenlet)NFr9)rIrJrK__doc__r rirUrXrZr]r`rbrRrdrhrrrrrrzr|r~r!r'r#rrrrrs*   (   rc@seZdZdZdS)rzr Raised when a Pool is full and an attempt was made to add a new greenlet to it in non-blocking mode. N)rIrJrKrrrrrrsrc@sJeZdZdddZdddZddZdd Zd d Zdd dZddZ dS)rNcCs\|dur|dkrtd|ft|||_|dur||_|dur%t}nt}|||_dS)a Create a new pool. A pool is like a group, but the maximum number of members is governed by the *size* parameter. :keyword int size: If given, this non-negative integer is the maximum count of active greenlets that will be allowed in this pool. A few values have special significance: * `None` (the default) places no limit on the number of greenlets. This is useful when you want to track, but not limit, greenlets. In general, a :class:`Group` may be a more efficient way to achieve the same effect, but some things need the additional abilities of this class (one example being the *spawn* parameter of :class:`gevent.baseserver.BaseServer` and its subclass :class:`gevent.pywsgi.WSGIServer`). * ``0`` creates a pool that can never have any active greenlets. Attempting to spawn in this pool will block forever. This is only useful if an application uses :meth:`wait_available` with a timeout and checks :meth:`free_count` before attempting to spawn. Nrzsize must not be negative: %r) ValueErrorrrUsizerirr _semaphore)rrrifactoryrrrrU s z Pool.__init__cCs|jj|dS)a Wait until it's possible to spawn a greenlet in this pool. :param float timeout: If given, only wait the specified number of seconds. .. warning:: If the pool was initialized with a size of 0, this method will block forever unless a timeout is given. :return: A number indicating how many new greenlets can be put into the pool without blocking. .. versionchanged:: 1.1a3 Added the ``timeout`` parameter. rj)rrnr}rrrr~.szPool.wait_availablecCs |dkS)z Return a boolean indicating whether this pool is full, e.g. if :meth:`add` would block. :return: False if there is room for new members, True if there isn't. r) free_countr rrrr|@s z Pool.fullcCs"|jdurdStd|jt|S)zu Return a number indicating *approximately* how many more members can be added to this pool. NrMr)rmaxrNr rrrrIs zPool.free_countcOs$|j|g|Ri||dS)z start(greenlet, blocking=True, timeout=None) -> None Add the **unstarted** *greenlet* to the collection of greenlets this group is monitoring and then start it. Parameters are as for :meth:`add`. Nrg)rr-rrrrrrhRs z Pool.startTcCs<|jj||ds tz t||WdS|j)a Begin tracking the given **unstarted** greenlet, possibly blocking until space is available. Usually you should call :meth:`start` to track and start the greenlet instead of using this lower-level method, or :meth:`spawn` to also create the greenlet. :keyword bool blocking: If True (the default), this function will block until the pool has space or a timeout occurs. If False, this function will immediately raise a Timeout if the pool is currently full. :keyword float timeout: The maximum number of seconds this method will block, if ``blocking`` is True. (Ignored if ``blocking`` is False.) :raises PoolFull: if either ``blocking`` is False and the pool was full, or if ``blocking`` is True and ``timeout`` was exceeded. .. caution:: If the *greenlet* has already been started and *blocking* is true, then the greenlet may run to completion while the current greenlet blocks waiting to track it. This would enable higher concurrency than desired. .. seealso:: :meth:`Group.add` .. versionchanged:: 1.3.0 Added the ``blocking`` and ``timeout`` parameters. )blockingrkN)racquirerrrbrelease)rr-rrkrrrrb^s zPool.addcCst|||jdSr9)rrRrrrerrrrRs z Pool._discardrHr9)TN) rIrJrKrUr~r|rrhrbrRrrrrrs  $  *rc@sJeZdZdgZddZddZddZdd Zd d Zd d Z ddZ dS)r,r%cCs ||_dSr9)r%)rr%rrrrU zpass_value.__init__cCs|r ||jdSdSr9) successfulr%value)rsourcerrr__call__szpass_value.__call__cCrYr9)hashr%r rrr__hash__rzpass_value.__hash__cCs|jt|d|kSNr%)r%getattr)rotherrrr__eq__szpass_value.__eq__cCrYr9)strr%r rrr__str__rzpass_value.__str__cCrYr9)reprr%r rrrrXrzpass_value.__repr__cCs|dksJt|j|Sr)rr%r[rrr __getattr__s  zpass_value.__getattr__N) rIrJrKrLrUrrrrrXrrrrrr,s r,N)#r __future__rrr gevent.hubrrrrvgevent.greenletrr gevent.queuer QueueFullgevent.timeoutr gevent.eventr gevent.lockr rgevent._compatr gevent._imaprr__all__objectrrrrr,rrrrs(       ug