o 0׾g@sLddlmZmZmZddlmZddlmZddl m Z ddl m Z ddl m Z ddlmZddlmZdd lmZdd lmZdd lmZdd lmZdd lmZddlmZddlmZ ddl!m"Z"ddl#m$Z%ddl&m'Z'gdZ(e)dj*e+d<dde+d<e'j,e+d<dde+d<dde+d<dde+d<d de+d!<d"de+d#<erdd$l-Z-e-j.Z/Gd%d&d&e0Z1Gd'd(d(e1Z2Gd)d*d*e1Z3Gd+d,d,e0Z4d-d.Z5e j6Z7Gd/d0d0e Z8Gd1d2d2e0Z9e9Z:e9Z;d3d4Zd:d;Z?dd$fd?d@ZBdAdBZCeCddCl!mDZDeDeEdDd$S)F)absolute_importprint_functiondivision) _getframe)exc_info)ref)greenlet) GreenletExit)reraise)PYPY)dump_traceback)load_traceback)InvalidSwitchError)iwait_on_objects)wait_on_objects)Timeout)config) readproperty)get_hub_noargs)_waiter)Greenletjoinallkillallr getcurrentcCdSNrrrY/var/www/html/backend_erp/backend_erp_env/lib/python3.10/site-packages/gevent/greenlet.py-sr greenlet_initWaitercC|jSrparentsrrrr5 get_my_hubcCr!rr"r$rrrr8r&get_generic_parentcCr!r)f_codeframerrrr;r&Gevent_PyFrame_GetCodecCr!r)f_linenor*rrrr<r&Gevent_PyFrame_GetLineNumbercCr!r)f_backr*rrrr=r&Gevent_PyFrame_GetBackNc@sNeZdZdZdgZddZddZddZd d Zd d Z d dZ ddZ dS) SpawnedLinkzj A wrapper around link that calls it in another greenlet. Can be called only from main loop. callbackcCs t|s td|f||_dS)NExpected callable: %r)callable TypeErrorr2selfr2rrr__init__Ms zSpawnedLink.__init__cCst|jt}||dSr)rr2get_hubswitch)r7sourcegrrr__call__RszSpawnedLink.__call__cC t|jSr)hashr2r7rrr__hash__V zSpawnedLink.__hash__cCs|jt|d|kSNr2)r2getattr)r7otherrrr__eq__YszSpawnedLink.__eq__cCr>r)strr2r@rrr__str__\rBzSpawnedLink.__str__cCr>r)reprr2r@rrr__repr___rBzSpawnedLink.__repr__cCs|dksJt|j|SrC)rDr2)r7itemrrr __getattr__bs  zSpawnedLink.__getattr__N) __name__ __module__ __qualname____doc__ __slots__r8r=rArFrHrJrLrrrrr1Es r1c@eZdZdZgZddZdS)SuccessSpawnedLinkz|A wrapper around link that calls it in another greenlet only if source succeed. Can be called only from main loop. cCs|r t||SdSr successfulr1r=r7r;rrrr=n zSuccessSpawnedLink.__call__NrMrNrOrPrQr=rrrrrSg rSc@rR)FailureSpawnedLinkz{A wrapper around link that calls it in another greenlet only if source failed. Can be called only from main loop. cCs|s t||SdSrrTrVrrrr=zrWzFailureSpawnedLink.__call__NrXrrrrrZsrYrZc@s$eZdZdZddZeddZdS)_Frame)r)r-r/cCsd|_d|_d|_dSNr)r)r/r-r@rrrr8s z_Frame.__init__cCrrrr@rrr f_globalssz_Frame.f_globalsN)rMrNrOrQr8propertyr]rrrrr[~s r[cCszt}Wn tyd}Ynwd}d}|rE|durE|d8}t}t||_t||_|dur3||_|}|dur;|}t|}|rE|dus|S)N) sys_getframe ValueErrorr[r,r)r.r-r/r0)limitr+ newest_Frame newer_Frame older_Framerrr_extract_stacks(       rfc@seZdZdZdZdfddZddZedd Ze d d Z d d Z eddZ ddZ ze ZWn ey8YnwerBeddZneddZddZddZddZddZddZdd Zd!d"Zed#d$Zd%d&Zd'd(Zd)d*Zd+d,Zed-d.Zed/d0Zd1d2Z d3d4Z!d5d6Z"e#d7d8Z$e#d9d:Z%e&d;d<Z'e&d=d>Z(d?d@Z)e*dAdfdBdCZ+dgdDdEZ,dfdFdGZ-dHdIZ.dJdKZ/dLdMZ0dNdOZ1dPdQZ2dRdSZ3dTdUZ4dVdWZ5dXdYZ6e7fdZd[Z8d\d]Z9d^d_Z:e;fd`daZdddeZ?dS)hrz@ A light-weight cooperatively-scheduled execution unit. NcOst|dt|dur||_t|jstd||_||_d|_d|_d|_ d|_ g|_ d|_ d|_ tjrbt}t||_z|j|_WntyYi|_t|durW|j|_Ynwt|j|_dSd|_d|_d|_dS)a :param args: The arguments passed to the ``run`` function. :param kwargs: The keyword arguments passed to the ``run`` function. :keyword callable run: The callable object to run. If not given, this object's `_run` method will be invoked (typically defined by subclasses). .. versionchanged:: 1.1b1 The ``run`` argument to the constructor is now verified to be a callable object. Previously, passing a non-callable object would fail after the greenlet was spawned. .. versionchanged:: 1.3b1 The ``GEVENT_TRACK_GREENLET_TREE`` configuration value may be set to a false value to disable ``spawn_tree_locals``, ``spawning_greenlet``, and ``spawning_stack``. The first two will be None in that case, and the latter will be empty. .. versionchanged:: 1.5 Greenlet objects are now more careful to verify that their ``parent`` is really a gevent hub, raising a ``TypeError`` earlier instead of an ``AttributeError`` later. .. versionchanged:: 20.12.1 Greenlet objects now function as context managers. Exiting the ``with`` suite ensures that the greenlet has completed by :meth:`joining ` the greenlet (blocking, with no timeout). If the body of the suite raises an exception, the greenlet is :meth:`killed ` with the default arguments and not joined in that case. Nz.The run argument or self._run must be callable)_greenlet__init__r9_runr4r5argskwargsvalue _start_event _notifier_formatted_info_links_ident _exc_info GEVENT_CONFIGtrack_greenlet_treerwrefspawning_greenletspawn_tree_localsAttributeErrorr(rfspawning_stack_limitspawning_stack)r7runrjrkspawnerrrrr8s:C        zGreenlet.__init__cCst|}|j}||Sr)r'ident_registry get_ident)r7hubregrrr_get_minimal_ident;s  zGreenlet._get_minimal_identcCs|jdur ||_|jS)a A small, unique non-negative integer that identifies this object. This is similar to :attr:`threading.Thread.ident` (and `id`) in that as long as this object is alive, no other greenlet *in this hub* will have the same id, but it makes a stronger guarantee that the assigned values will be small and sequential. Sometime after this object has died, the value will be available for reuse. To get ids that are unique across all hubs, combine this with the hub's (``self.parent``) ``minimal_ident``. Accessing this property from threads other than the thread running this greenlet is not defined. .. versionadded:: 1.3a2 N)rqrr@rrr minimal_identIs  zGreenlet.minimal_identcCs d|jfS)aL The greenlet name. By default, a unique name is constructed using the :attr:`minimal_ident`. You can assign a string to this value to change it. It is shown in the `repr` of this object if it has been assigned to or if the `minimal_ident` has already been generated. .. versionadded:: 1.3a2 .. versionchanged:: 1.4 Stop showing generated names in the `repr` when the ``minimal_ident`` hasn't been requested. This reduces overhead and may be less confusing, since ``minimal_ident`` can get reused. z Greenlet-%d)rr@rrrnameds z Greenlet.namecCst|jdSr)r rr@rrr_raise_exceptiontszGreenlet._raise_exceptioncCst|}|jSr)r'loopr7rrrrrwsz Greenlet.loopcCs|jduo |jduSr)rmrrr@rrr __nonzero__}szGreenlet.__nonzero__cCs0|jrdS|s |rdS|jot| S)zDBoolean indicating that the greenlet is dead and will not run again.FT)_greenlet__main"_Greenlet__start_cancelled_by_kill_Greenlet__started_but_aborted_greenlet__started _continulet is_pendingr@rrrdeads z Greenlet.deadcCs|p |p tj|S)a Boolean indicating that the greenlet is dead and will not run again. This is true if: 1. We were never started, but were :meth:`killed ` immediately after creation (not possible with :meth:`spawn`); OR 2. We were started, but were killed before running; OR 3. We have run and terminated (by raising an exception out of the started function or by reaching the end of the started function). )rrrr__get__r@rrrrs  cCs |jduSr)rmr@rrr__never_started_or_killedrBz"Greenlet.__never_started_or_killedcCs |jduo|jjpt|jddS)NactiveF)rmpendingrDr@rrr__start_pendings zGreenlet.__start_pendingcC |jtuSr)rm_cancelled_start_eventr@rrr__start_cancelled_by_killrBz"Greenlet.__start_cancelled_by_killcCrr)rm_start_completed_eventr@rrr__start_completedrBzGreenlet.__start_completedcCs(| o| o| o| Sr)"_Greenlet__never_started_or_killedr_Greenlet__start_completed_Greenlet__start_pendingr@rrr__started_but_aborteds zGreenlet.__started_but_abortedcCs(|jdurt|_|j|jdSr)rmrstopcloser@rrr__cancel_starts  zGreenlet.__cancel_startcCs|jdur^|jr`t|dkr+|d}t|tr#t|tr#||df}nt||df}n|s3ttdf}t|dtsNtd|ddl }| tt|df}t|dtsWJ| |dSdSdS)Nr_rz RANDOM CRAP) rrrlen isinstancetype issubclass BaseExceptionr print traceback print_stack_Greenlet__report_error)r7rjargrrrr__handle_death_before_starts   z$Greenlet.__handle_death_before_startcCst|Sr)boolr@rrrstartedszGreenlet.startedcCs|jp|jduS)a Return a true value if and only if the greenlet has finished execution. .. versionchanged:: 1.1 This function is only guaranteed to return true or false *values*, not necessarily the literal constants ``True`` or ``False``. N)rrrr@rrrreadys zGreenlet.readycCs|jduo |jdduS)a Return a true value if and only if the greenlet has finished execution successfully, that is, without raising an error. .. tip:: A greenlet that has been killed with the default :class:`GreenletExit` exception is considered successful. That is, ``GreenletExit`` is not considered an error. .. note:: This function is only guaranteed to return true or false *values*, not necessarily the literal constants ``True`` or ``False``. Nr_rrr@rrrrUs zGreenlet.successfulcCsd|jj}d|jvr|jdurd}nd|jf}d||tt|f}|}|r.|d|7}|dS)Nr z "%s" z <%s%sat %sz: >) __class__rM__dict__rqrhexid _formatinfo)r7 classnamerresult formattedrrrrJ s  zGreenlet.__repr__cCs|j}|dur |S|j}t|dd}||urd}n|dur"t|}n t|ddp+t|}|}g}|jr;dd|jD}|jrK|dd|jD|rX|dd |d 7}||_|S) N__self__rirMcSsg|] }t|ddqS)N2rI).0xrrr 0sz(Greenlet._formatinfo..cSs(g|]\}}d|t|ddfqS)z%s=%sNrr)rkeyrlrrrr2s((z, )) rorirDrIrjrkextenditemsjoin)r7infofuncim_selffuncnamerrjrrrrs(  zGreenlet._formatinfocCs|jdur |jdSdS)z Holds the exception instance raised by the function if the greenlet has finished with an error. Otherwise ``None``. Nr_rr@rrr exception9szGreenlet.exceptioncCsJ|j}|dur!|ddur#|d|d|drt|dfSdfSdSdS)z Holds the exc_info three-tuple raised by the function if the greenlet finished with an error. Otherwise a false value. .. note:: This is a provisional API and may change. .. versionadded:: 1.1 Nrr_)rrr )r7eirrrrAs zGreenlet.exc_infoc GsN|z|jstj|g|RW||dSW||dS||w)aImmediately switch into the greenlet and raise an exception in it. Should only be called from the HUB, otherwise the current greenlet is left unscheduled forever. To raise an exception in a safe manner from any greenlet, use :meth:`kill`. If a greenlet was started but never switched to yet, then also a) cancel the event that will start it b) fire the notifications as if an exception was raised in a greenlet N)_Greenlet__cancel_startrrthrow$_Greenlet__handle_death_before_start)r7rjrrrrTs zGreenlet.throwcCs2|jdurt|t|}|j|j|_dSdS)z3Schedule the greenlet to run in this loop iterationN)rm_call_spawn_callbacksr'r run_callbackr:rrrrstartjs zGreenlet.startcCs>|jdurt|t|}|j||_|j|jdSdS)z start_later(seconds) -> None Schedule the greenlet to run in the future loop iteration *seconds* later N)rmrr'rtimerrr:)r7secondsrrrr start_laterqs zGreenlet.start_latercCstdurtat|dS)ac add_spawn_callback(callback) -> None Set up a *callback* to be invoked when :class:`Greenlet` objects are started. The invocation order of spawn callbacks is unspecified. Adding the same callback more than one time will not cause it to be called more than once. .. versionadded:: 1.4.0 N)_spawn_callbackssetaddr2rrradd_spawn_callback~szGreenlet.add_spawn_callbackcCs&tdurt|tsdadSdSdS)a# remove_spawn_callback(callback) -> None Remove *callback* function added with :meth:`Greenlet.add_spawn_callback`. This function will not fail if *callback* has been already removed or if *callback* was never added. .. versionadded:: 1.4.0 N)rdiscardrrrrremove_spawn_callbacks  zGreenlet.remove_spawn_callbackcOs||i|}||S)a spawn(function, *args, **kwargs) -> Greenlet Create a new :class:`Greenlet` object and schedule it to run ``function(*args, **kwargs)``. This can be used as ``gevent.spawn`` or ``Greenlet.spawn``. The arguments are passed to :meth:`Greenlet.__init__`. .. versionchanged:: 1.1b1 If a *function* is given that is not callable, immediately raise a :exc:`TypeError` instead of spawning a greenlet that will raise an uncaught TypeError. )r)clsrjrkr<rrrspawnszGreenlet.spawncOs8|tur|sd|vrtd||i|}|||S)a spawn_later(seconds, function, *args, **kwargs) -> Greenlet Create and return a new `Greenlet` object scheduled to run ``function(*args, **kwargs)`` in a future loop iteration *seconds* later. This can be used as ``Greenlet.spawn_later`` or ``gevent.spawn_later``. The arguments are passed to :meth:`Greenlet.__init__`. .. versionchanged:: 1.1b1 If an argument that's meant to be a function (the first argument in *args*, or the ``run`` keyword ) is given to this classmethod (and not a classmethod of a subclass), it is verified to be callable. Previously, the spawned greenlet would have failed when it started running. r{r)rr5r)rrrjrkr<rrr spawn_laters  zGreenlet.spawn_latercCsJ|||j}|r#t|trt|dkr|}n|f}|||SN)r_Greenlet__freerrtuplerr)r7rrrjrrr_maybe_kill_before_starts z!Greenlet._maybe_kill_before_startTcCsd||s.|r dS|rtnd}t|}|jt||||dur0|||dSdSdS)a Raise the ``exception`` in the greenlet. If ``block`` is ``True`` (the default), wait until the greenlet dies or the optional timeout expires; this may require switching greenlets. If block is ``False``, the current greenlet is not unscheduled. This function always returns ``None`` and never raises an error. It may be called multpile times on the same greenlet object, and may be called on an unstarted or dead greenlet. .. note:: Depending on what this greenlet is executing and the state of the event loop, the exception may or may not be raised immediately when this greenlet resumes execution. It may be raised on a subsequent green call, or, if this greenlet exits before making such a call, it may not be raised at all. As of 1.1, an example where the exception is raised later is if this greenlet had called :func:`sleep(0) `; an example where the exception is raised immediately is if this greenlet had called :func:`sleep(0.1) `. .. caution:: Use care when killing greenlets. If the code executing is not exception safe (e.g., makes proper use of ``finally``) then an unexpected exception could result in corrupted state. Using a :meth:`link` or :meth:`rawlink` (cheaper) may be a safer way to clean up resources. See also :func:`gevent.kill` and :func:`gevent.killall`. :keyword type exception: The type of exception to raise in the greenlet. The default is :class:`GreenletExit`, which indicates a :meth:`successful` completion of the greenlet. .. versionchanged:: 0.13.0 *block* is now ``True`` by default. .. versionchanged:: 1.1a2 If this greenlet had never been switched to, killing it will prevent it from *ever* being switched to. Links (:meth:`rawlink`) will still be executed, though. .. versionchanged:: 20.12.1 If this greenlet is :meth:`ready`, immediately return instead of requiring a trip around the event loop. N) rrr r'rr_killgetr)r7rblocktimeoutwaiterrrrrkills 2z Greenlet.killcCs|r|r |jS||sttj}||z$t|}zt |}||ur5t d|fW| n| wWn | ||r\|rV|jS|dSdS)a get(block=True, timeout=None) -> object Return the result the greenlet has returned or re-raise the exception it has raised. If block is ``False``, raise :class:`gevent.Timeout` if the greenlet is still alive. If block is ``True``, unschedule the current greenlet until the result is available or the timeout expires. In the latter case, :class:`gevent.Timeout` is raised. z&Invalid switch into Greenlet.get(): %rN) rrUrlrrrr:rawlink_start_new_or_dummyr'rcancelunlink)r7rrr:trrrrrs0      z Greenlet.getc Cs|rdStj}||z$t|}zt|}||ur'td|fW|WdS|wtyP}z| |||urEWYd}~dSd}~w| |)z join(timeout=None) -> None Wait until the greenlet finishes or *timeout* expires. Return ``None`` regardless. Nz'Invalid switch into Greenlet.join(): %r) rrr:rrrr'rrr)r7rr:rrexrrrrAs*     z Greenlet.joincCs|Srrr@rrr __enter__]zGreenlet.__enter__cCs>|durz |W|dS|w||||fdSr)rr)r7rvtbrrr__exit__`s  zGreenlet.__exit__cCs<d|_||_|jr|jst|}|j|j|_dSdSdS)N)NNN)rrrlrprnr'rr _notify_links)r7rrrrr__report_resultis  zGreenlet.__report_resultcCst|dtr||ddSzt|d}Wnd}Y|d|d|f|_t|}|jr;|js;|j |j |_z |j |g|RW~dS~w)Nr_rr) rr _Greenlet__report_resultr rrr'rprnrrr handle_error)r7rrrrrr__report_errorps  zGreenlet.__report_errorcCspz2|t|_z |j|ji|j}Wn |tYn ||W| dSW| dS| wr) rrrmrirjrkr sys_exc_inforr)r7rrrrr{s  z Greenlet.runcCs0z|`Wn ty Ynwd|_|jdS)Nr)rirxrjrkclearr@rrr__frees zGreenlet.__freecCsdS)a8 Subclasses may override this method to take any number of arguments and keyword arguments. .. versionadded:: 1.1a3 Previously, if no callable object was passed to the constructor, the spawned greenlet would later fail with an AttributeError. Nrr@rrrris z Greenlet._runcCr>r)rrpr@rrr has_linksrBzGreenlet.has_linkscCs^t|s td|f|j||r)|jr+|js-t|}|j|j |_dSdSdSdS)a Register a callable to be executed when the greenlet finishes execution. The *callback* will be called with this instance as an argument. The *callback* will be called even if linked after the greenlet is already ready(). .. caution:: The *callback* will be called in the hub and **MUST NOT** raise an exception. r3N) r4r5rpappendrrnr'rrr)r7r2rrrrrs  zGreenlet.rawlinkcCs|||dS)au Link greenlet's completion to a callable. The *callback* will be called with this instance as an argument once this greenlet is dead. A callable is called in its own :class:`greenlet.greenlet` (*not* a :class:`Greenlet`). The *callback* will be called even if linked after the greenlet is already ready(). N)rr7r2r1rrrlinksz Greenlet.linkcCs(z |j|WdStyYdSw)z:Remove the callback set by :meth:`link` or :meth:`rawlink`N)rpremoverar6rrrrs  zGreenlet.unlinkcCs|jdd=dS)zL Remove all the callbacks. .. versionadded:: 1.3a2 N)rpr@rrr unlink_allszGreenlet.unlink_allcC|j||ddS)zy Like :meth:`link` but *callback* is only notified when the greenlet has completed successfully. r1Nrrrrr link_valuezGreenlet.link_valuecCr)z Like :meth:`link` but *callback* is only notified when the greenlet dies because of an unhandled exception. rNrrrrrlink_exceptionrzGreenlet.link_exceptioncCsR|jr'|jd}z||Wnt|j||fgtRY|jsdSdSr\)rppopr'rr)r7rrrrrs  zGreenlet._notify_linksr)TN)@rMrNrOrPryr8rr^rrrrrr__bool__ NameError_PYPYrrrrrrrrrrrUrJrrrrrr staticmethodrr classmethodrrrr rrrrrrrr{rrirrr1rrrrSrrZr rrrrrrs        #         = ,      rc@s0eZdZdZddZddZddZdd Zd S) _dummy_eventrrcCsd|_|_dS)NFrr@rrrr8 sz_dummy_event.__init__cCrrrr@rrrr rz_dummy_event.stopcCstd)NzCannot start the dummy event)AssertionError)r7cbrrrrsz_dummy_event.startcCrrrr@rrrrrz_dummy_event.closeN)rMrNrOrQr8rrrrrrrrs  rcCslzt|trt|dkr|j|n||Wnt|j|gtRY|dur4|ddSdSr)rrrrr'rrr:)gletrrrrrrs  rFcCsb|s t|||dSg}t|||dD]}t|dddur)t|dr&|n|j||q|S)a5 Wait for the ``greenlets`` to finish. :param greenlets: A sequence (supporting :func:`len`) of greenlets to wait for. :keyword float timeout: If given, the maximum number of seconds to wait. :return: A sequence of the greenlets that finished before the timeout (if any) expired. )rcountrNr)waitiwaitrDhasattrrrr) greenletsr raise_errorrdoneobjrrrr)s    rcCsbg}|D]%}|js)z||Wnt|j|gtRY|js)||q||dSr)rrr'rrrr:)rrrdiehardsr<rrr _killall3@s rcCsF|D]}|js z||Wqt|j|gtRYqqdSr)rrr'rr)rrr<rrr_killallMsrcCs"tdur tD]}||qdSdSr)r)grrrrrrVs  rTc Csg}|D]}z|j}Wnty||Yqw||s#||q|s(dS|j}|r]t}|t|||t|} z| } | rQt | ddW| dSW| dS| w|t ||dS)ax Forceably terminate all the *greenlets* by causing them to raise *exception*. .. caution:: Use care when killing greenlets. If they are not prepared for exceptions, this could result in corrupted state. :param greenlets: A **bounded** iterable of the non-None greenlets to terminate. *All* the items in this iterable must be greenlets that belong to the same hub, which should be the hub for this current thread. If this is a generator or iterator that switches greenlets, the results are undefined. :keyword exception: The type of exception to raise in the greenlets. By default this is :class:`GreenletExit`. :keyword bool block: If True (the default) then this function only returns when all the greenlets are dead; the current greenlet is unscheduled during that process. If greenlets ignore the initial exception raised in them, then they will be joined (with :func:`gevent.joinall`) and allowed to die naturally. If False, this function returns immediately and greenlets will raise the exception asynchronously. :keyword float timeout: A time in seconds to wait for greenlets to die. If given, it is only honored when ``block`` is True. :raise Timeout: If blocking and a timeout is given that elapses before all the greenlets are dead. .. versionchanged:: 1.1a2 *greenlets* can be any iterable of greenlets, like an iterator or a set. Previously it had to be a list or tuple. .. versionchanged:: 1.5a3 Any :class:`Greenlet` in the *greenlets* list that hadn't been switched to before calling this method will never be switched to. This makes this function behave like :meth:`Greenlet.kill`. This does not apply to raw greenlets. .. versionchanged:: 1.5a3 Now accepts raw greenlets created by :func:`gevent.spawn_raw`. NF)r) rrxrrr rrrrrrrr) rrrr need_killedrrrrraliverrrr_s2#     rcCs tdSr)rrrrr_initrBr#)import_c_accelzgevent._greenlet)NFN)F __future__rrrsysrr`rrweakrefrrurr gevent._compatr r r  gevent._tblibr r gevent.exceptionsrgevent._hub_primitivesrrrrgevent.timeoutrgevent._configrrs gevent._utilrgevent._hub_localrr9geventr__all__ __import__rlocalsr _continuation continuletrobjectr1rSrZr[rfr8rhrrrrrrrrrrrr#r$globalsrrrrsr                   "  #\   E