U @f2@s$ddlmZddlZddlmZddlmZddlmZddlmZddlm Z ddl m Z dd l m ZddlZd d d d ddddgZejZd)dd Zdd Zdd ZddZddZddZddZeZddZdddd e jfd!d"e jffD\ZZd#d$ZGd%ddejZd&d'Zd(dZ dS)*)dequeN) GreenletExit)event)hubs)support)timeout)timer) greenlets getcurrentsleepspawnspawn_nkill spawn_afterspawn_after_local GreenThreadcCsJt}t}|j|kr td|||j}z |W5|XdS)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. z0do not call blocking functions from the mainloopN)rget_hubr greenlet RuntimeErrorschedule_call_globalswitchcancel)secondshubcurrentrrN/var/www/html/chatgpt/venv/lib/python3.8/site-packages/eventlet/greenthread.pyr s   cOs*t}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)funcargskwargsrgrrrr +s  cOstd|||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)rrr rrrr ;s cOs*t}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`. rrrrr rr!rrrrHs cOs*t}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$rrrr_s cOs"tjdtddt||||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#)rrrr rrrcall_after_globalvs r,cOsBtjdtddt}tj||jd}|j||jf||}|S)Nzocall_after_local is renamed to spawn_after_local, whichhas the same signature and semantics (plus a bit extra).r&r'parent)r)r*r+rrrr%r)rfunctionrr rr!trrrcall_after_localsr1cGsFtjdtdd|dkr(t|ddSt}|j|tj f|S)NzJInstead of exc_after, which is deprecated, use Timeout(seconds, exception)r&r'cSsdSNrrrrrzexc_after..) r)r*r+rTimerrrr%r throw)r throw_argsrrrr exc_aftersr8ccs$|]\}}}t|||VqdSr2)rZwrap_deprecated).0oldnewZfunrrr sr<zgreenthread.TimeoutErrorTimeoutzgreenthread.with_timeout with_timeoutcCs6t}tj||jd}|j||jf||}||fS)Nr-)rrrrr)rrrr rr!r0rrrr#sr#c@sXeZdZdZddZddZddZdd Zd d Zd d Z ddZ ddZ ddZ dS)rzThe GreenThread class is a type of Greenlet which has the additional property of being able to retrieve the return value of the main function. Do not construct GreenThread objects directly; call :func:`spawn` to get one. cCs,tj||j|t|_d|_d|_dS)NF)r__init__mainrEvent _exit_event_resolving_links _exit_funcs)selfr.rrrr?s zGreenThread.__init__csdddlm}t}t||s&td|jfdd}|fdd} | S)zS Enable ``GreenThread``s to be ``await``ed in ``async`` functions. r)HubzmThis API only works with eventlet's asyncio hub. To use it, set an EVENTLET_HUB=asyncio environment variable.cs|rjsdSr2) cancelleddeadrfuturerErrgot_future_resultsz0GreenThread.__await__..got_future_resultc snr dSz|}|WnFtk r>Yn,tk rh}z|W5d}~XYnXdSr2)donewait set_resultrr BaseException set_exception)ZgthreadresulterIrrgot_gthread_results z1GreenThread.__await__..got_gthread_result) Zeventlet.hubs.asynciorFrr isinstancerloop create_futureadd_done_callbacklink __await__)rErFrrLrTr)rJrErrZs       zGreenThread.__await__cCs |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).)rBrNrKrrrrNszGreenThread.waitcOs:|jdkrt|_|j|||f|jr6|dS)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)rDrappendrBready_resolve_linksrErZ curried_argsZcurried_kwargsrrrrYs   zGreenThread.linkcOs>|js dSz|j|||fWdStk r8YdSXdS)zn remove linked function set by :meth:`link` Remove successfully return True, otherwise False FTN)rDremove ValueErrorr^rrrunlinkszGreenThread.unlinkcCsNz|||}Wn&|jjt|YnX|j||dSr2)rBZsend_exceptionsysexc_infor]send)rEr/rr rRrrrr@s zGreenThread.maincCsT|jr dS|jsdSd|_z,|jrD|j\}}}||f||qW5d|_XdS)NTF)rCrDpopleft)rEfcaZckwrrrr]szGreenThread._resolve_linkscGst|f|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`).rrEr7rrrr szGreenThread.killcGst|f|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`).)rrirrrr&szGreenThread.cancelN) __name__ __module__ __qualname____doc__r?rZrNrYrar@r]rrrrrrrs)  cGs|st|f|dS)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.Nrh)r!r7rrrr.srcs|jr dSt}|sRfdd}||_t|trRz||diWn YnXt}||jk rx| | 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. Ncs$rddntdS)Nr"r&)with_tracebackrr)akwr7rr just_raiseHszkill..just_raiserr) rHrrrunrUrr@r rZensure_greenletrrr6)r!r7rrrrrrqrr6s    )r)! collectionsrrbrrZeventletrrrrZ eventlet.hubsrZeventlet.supportr r)__all__r r r r rrr,r1Z call_afterr8r=r> TimeoutErrorr#rrrrrrrsF