!ni:4VddlmZddlZddlmZddlmZddlmZddlmZddlm Z ddl m Z dd l m ZddlZgd Zej Zdd Zd Zd ZdZdZdZdZeZdZddde j4fdde j6ffD\ZZdZGddejZdZdZ y))dequeN) GreenletExit)event)hubs)support)timeout)timer) greenlets) getcurrentsleepspawnspawn_nkill spawn_afterspawn_after_local GreenThreadc&tj}t}|j|ur|dkryt d|j ||j } |j |jy#|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 T/home/homepc/tiktok-worker/venv/lib/python3.12/site-packages/eventlet/greenthread.pyr r su ,,.ClG ||w a< MNN  $ $Wgnn =E    s A==Bctj}t|j}|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 2s< ,,.CCLL!AQ$f= Hc$td|||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 ||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 rrrOs<" ,,.CCLL!AWahhdFC Hr$ctj}t|j}|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 rrrfs<" ,,.CCLL!AGQXXtT6B Hr$c\tjdtdt||||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}s2 MM > q * GT4 0 33r$ctjdtdtj}t j ||j }|j ||jg|i|}|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_localr9sc MM Cq* ,,.C(3<<8ACDCFCA Hr$ctjdtd|tj|dSt j }|j|tjg|S)NzJInstead of exc_after, which is deprecated, use Timeout(seconds, exception)r-r.cyNr=r$rzexc_after..sr$) r0r1r2r Timerrrr+r throw)r throw_argsrs r exc_afterrBs] MM0$4{{7L11 ,,.C "3 " "7JL,>,> L LLr$c#\K|]$\}}}tj|||&ywr<)rwrap_deprecated).0oldnewfuns r rIs0/.got_future_results&!$)) +4!r$cjry |j}j|y#t$rj Yyt $r}j |Yd}~yd}~wwxYwr<)donewait set_resultrr BaseException set_exception)gthreadresulter[s rgot_gthread_resultz1GreenThread.__await__..got_gthread_results_{{} ( !!&)    ($$Q'' (s!6A4A4A//A4) eventlet.hubs.asynciorWrr isinstancerloop create_futureadd_done_callbacklink __await__)rUrWrr\rfr[s` @rrmzGreenThread.__await__s} .lln#s#Q  '')    !23 ( $%!!r$c6|jjS)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|_|jj|||f|jj r|j yy)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.linksX"    #$wD  |^ DE    ! ! #    ! $r$cz|jsy |jj|||fy#t$rYywxYw)zn remove linked function set by :meth:`link` Remove successfully return True, otherwise False FT)rTremove ValueErrorrss runlinkzGreenThread.unlinksE      # #T<$H I  s . ::c ||i|}|jj||jy#|jjt j |jxYwr<)rRsendrrsend_exceptionsysexc_info)rUr7r!r"rds rrPzGreenThread.mainsj "t.v.F    ! !& )    !   +D   + +S\\^ <    ! s 6>A4c|jry|jsyd|_ |jr7|jj\}}}||g|i||jr7d|_y#d|_wxYw)NTF)rSrTpopleft)rUfcackws rrrzGreenThread._resolve_linkssz    $ *""!--557 2s$##s#""%*D !ED !s AA.. A7ct|g|S)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|S)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$rrrs5  '"R'".  " *' )r$rc"|s t|g|yy)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 rrr5s  Q r$c`|jrytj}|s0fd}||_t |t r |j |dit}||jur,|j|jd|j|jy#YXxYw)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. Nc^rdjdtj)Nr&r-)with_tracebackrr)akwrAs r just_raisezkill..just_raiseOs. m22:a=AA++--r$r=r) rZrrrunrhrrPr rensure_greenletrrr@)r#rArrrs ` rrr=s vv ,,.C  .  a % z2r*lGcll"    GNN3 AGGZ s B))B-)r)! collectionsrr}rreventletrrrr eventlet.hubsr eventlet.supportr r0__all__r r r rrrr3r9 call_afterrBrJrK TimeoutErrorr'rrrr=r$rrs !2 > :  . . .4  M #Y@ #^W5I5IJA lE)(##E)P$r$