i:4<ddlmZddlZddlmZddlmZddlmZddlmZddlm Z ddl m Z dd l m ZddlZgd ZejZdd Zd Zd ZdZdZdZdZeZdZddde jfdde jffD\ZZdZGddejZdZdZ dS))dequeN) GreenletExit)event)hubs)support)timeout)timer) greenlets) getcurrentsleepspawnspawn_nkill spawn_afterspawn_after_local GreenThreadc.tj}t}|j|ur|dkrdSt d|||j} ||jdS#|jwxYw)a Yield control to another eligible coroutine until at least *seconds* have elapsed. *seconds* may be specified as an integer, or a float if fractional seconds are desired. Calling :func:`~greenthread.sleep` with *seconds* of 0 is the canonical way of expressing a cooperative yield. For example, if one is looping over a large list performing an expensive calculation without calling any socket methods, it's a good idea to call ``sleep(0)`` occasionally; otherwise nothing else will run. rNz0do not call blocking functions from the mainloop)rget_hubr greenlet RuntimeErrorschedule_call_globalswitchcancel)secondshubcurrentr s ?/usr/local/lib/python3.11/dist-packages/eventlet/greenthread.pyr r s ,..CllG |w a<< FMNNN  $ $Wgn = =E    s BBctj}t|j}|d|j||||S)aCreate a greenthread to run ``func(*args, **kwargs)``. Returns a :class:`GreenThread` object which you can use to get the results of the call. Execution control returns immediately to the caller; the created greenthread is merely scheduled to be run at the next available opportunity. Use :func:`spawn_after` to arrange for greenthreads to be spawned after a finite delay. rrrrrrr)funcargskwargsrgs rr r 2sA ,..CCL!!AQ$f=== Hc2td|||dS)aSame as :func:`spawn`, but returns a ``greenlet`` object from which it is not possible to retrieve either a return value or whether it raised any exceptions. This is faster than :func:`spawn`; it is fastest if there are no keyword arguments. If an exception is raised in the function, spawn_n prints a stack trace; the print can be disabled by calling :func:`eventlet.debug.hub_exceptions` with False. r)_spawn_n)r r!r"s rrrBs AtT6 * *1 --r$ctj}t|j}|||j||||S)ahSpawns *func* after *seconds* have elapsed. It runs as scheduled even if the current greenthread has completed. *seconds* may be specified as an integer, or a float if fractional seconds are desired. The *func* will be called with the given *args* and keyword arguments *kwargs*, and will be executed within its own greenthread. The return value of :func:`spawn_after` is a :class:`GreenThread` object, which can be used to retrieve the results of the call. To cancel the spawn and prevent *func* from being called, call :meth:`GreenThread.cancel` on the return value of :func:`spawn_after`. This will not abort the function if it's already started running, which is generally the desired behavior. If terminating *func* regardless of whether it's started or not is the desired behavior, call :meth:`GreenThread.kill`. rrr r!r"rr#s rrrOsA" ,..CCL!!AWahdFCCC Hr$ctj}t|j}|||j||||S)a+Spawns *func* after *seconds* have elapsed. The function will NOT be called if the current greenthread has exited. *seconds* may be specified as an integer, or a float if fractional seconds are desired. The *func* will be called with the given *args* and keyword arguments *kwargs*, and will be executed within its own greenthread. The return value of :func:`spawn_after` is a :class:`GreenThread` object, which can be used to retrieve the results of the call. To cancel the spawn and prevent *func* from being called, call :meth:`GreenThread.cancel` on the return value. This will not abort the function if it's already started running. If terminating *func* regardless of whether it's started or not is the desired behavior, call :meth:`GreenThread.kill`. )rrrrschedule_call_localrr)s rrrfsA" ,..CCL!!AGQXtT6BBB Hr$cjtjdtdt||||dS)Nzcall_after_global is renamed to spawn_after, whichhas the same signature and semantics (plus a bit extra). Please do a quick search-and-replace on your codebase, thanks! stacklevelr)warningswarnDeprecationWarningr')rr r!r"s rcall_after_globalr3}sB M > q **** GT4 0 0 33r$ctjdtdtj}t j||j}|j||jg|Ri|}|S)Nzocall_after_local is renamed to spawn_after_local, whichhas the same signature and semantics (plus a bit extra).r-r.parent)r0r1r2rrrr+r)rfunctionr!r"rr#ts rcall_after_localr9su M Cq**** ,..C(3<888ACDCCCFCCA Hr$ctjdtd|tj|dSt j}|j|tj g|RS)NzJInstead of exc_after, which is deprecated, use Timeout(seconds, exception)r-r.cdSNr=r$rzexc_after..sDr$) r0r1r2r Timerrrr+r throw)r throw_argsrs r exc_afterrBso M0$4444{7LL111 ,..C "3 "7JLL,> L L L LLr$c#ZK|]&\}}}tj|||V'dSr<)rwrap_deprecated).0oldnewfuns r rIsQ/.got_future_resultsE!! $)      r$c"rdS |}|dS#t$rYdSt $r }|Yd}~dSd}~wwxYwr<)donewait set_resultrr BaseException set_exception)gthreadresulter[s rgot_gthread_resultz1GreenThread.__await__..got_gthread_results{{}}  ( !!&)))))      ( ( ($$Q''''''''' (s)AB% B.B  B) eventlet.hubs.asynciorWrr isinstancerloop create_futureadd_done_callbacklink __await__)rUrWrr\rfr[s` @rrmzGreenThread.__await__s .-----lnn#s## Q  ''))        !2333 ( ( ( ( ( $%%%!!!r$c4|jS)aH Returns the result of the main function of this GreenThread. If the result is a normal return value, :meth:`wait` returns it. If it raised an exception, :meth:`wait` will raise the same exception (though the stack trace will unavoidably contain some frames from within the greenthread module).)rRr_)rUs rr_zGreenThread.waits $$&&&r$c|jt|_|j|||f|jr|dSdS)a Set up a function to be called with the results of the GreenThread. The function must have the following signature:: def func(gt, [curried args/kwargs]): When the GreenThread finishes its run, it calls *func* with itself and with the `curried arguments `_ supplied at link-time. If the function wants to retrieve the result of the GreenThread, it should call wait() on its first argument. Note that *func* is called within execution context of the GreenThread, so it is possible to interfere with other linked functions by doing things like switching explicitly to another greenthread. N)rTrappendrRready_resolve_linksrUr curried_argscurried_kwargss rrlzGreenThread.linksp"   #$wwD  |^ DEEE   ! ! # # "    ! ! ! ! ! " "r$cv|jsdS |j|||fdS#t$rYdSwxYw)zn remove linked function set by :meth:`link` Remove successfully return True, otherwise False FT)rTremove ValueErrorrss runlinkzGreenThread.unlinks^  5    # #T<$H I I I4   55 s * 88c ||i|}|j||dS#|jjt j|xYwr<)rRsendrrsend_exceptionsysexc_info)rUr7r!r"rds rrPzGreenThread.mains "Xt.v..F   ! !& ) ) )    ! ! ! ! !   +D  +S\^^ < <    ! ! ! s :7A1c|jrdS|jsdSd|_ |jr0|j\}}}||g|Ri||j0d|_dS#d|_wxYw)NTF)rSrTpopleft)rUfcackws rrrzGreenThread._resolve_linkss    F  F $ *" $!-5577 2s$####s###" $%*D ! ! !ED ! ) ) ) )s 7A A$ct|g|RS)zKills the greenthread using :func:`kill`. After being killed all calls to :meth:`wait` will raise *throw_args* (which default to :class:`greenlet.GreenletExit`).rrUrAs rrzGreenThread.kill'sD&:&&&&r$ct|g|RS)zKills the greenthread using :func:`kill`, but only if it hasn't already started running. After being canceled, all calls to :meth:`wait` will raise *throw_args* (which default to :class:`greenlet.GreenletExit`).)rrs rrzGreenThread.cancel-s d(Z((((r$N) __name__ __module__ __qualname____doc__rOrmr_rlryrPrrrrr=r$rrrs    '"'"'"R'''""".    " " " * * *''' )))))r$rc(|st|g|RdSdS)zLike :func:`kill`, but only terminates the greenthread if it hasn't already started execution. If the grenthread has already started execution, :func:`cancel` has no effect.Nr)r#rAs rrr5s2  Qr$cf|jrdStj}|sAfd}||_t |t r ||din#YnxYwt}||jur/| | d|j |j dS)aTerminates the target greenthread by raising an exception into it. Whatever that greenthread might be doing; be it waiting for I/O or another primitive, it sees an exception right away. By default, this exception is GreenletExit, but a specific exception may be specified. *throw_args* should be the same as the arguments to raise; either an exception instance or an exc_info tuple. Calling :func:`kill` causes the calling greenthread to cooperatively yield. Ncpr!ddtj)Nr&r-)with_tracebackrr)akwrAs r just_raisezkill..just_raiseOs6 . m22:a=AAA+---r$r=r) rZrrrunrhrrPr rensure_greenletrrr@)r#rArrrs ` rrr=s v ,..C  . . . . .  a % %  z2r**** llGcl""    GN333 AGZs AA)r)! collectionsrr}rreventletrrrr eventlet.hubsr eventlet.supportr r0__all__r r r rrrr3r9 call_afterrBrJrK TimeoutErrorr'rrrr=r$rrs !!!!!!222222 > > > :    . . .   .   .444    MMM #Y@ #^W5IJA lE)E)E)E)E)(#E)E)E)P$$$$$r$