3 Z_]L-@s ddlmZddlZddlmZddlmZddlmZddlmZddlm Z ddl m Z ddl Z ddlZd d d d d dddgZe jZd(dd Zdd Zdd ZddZddZddZddZeZddZddddejfd d!ejffD\ZZd"d#ZGd$dde j Zd%d&Zd'd Z dS)))dequeN)event)hubs)support)timeout)timer) greenlets getcurrentsleepspawnspawn_nkill spawn_afterspawn_after_local GreenThreadc CsJtj}t}|j|k s td|j||j}z |jWd|jXdS)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 greenletAssertionErrorschedule_call_globalswitchcancel)secondshubcurrentrr8/tmp/pip-build-yz_zf6az/eventlet/eventlet/greenthread.pyr s  cOs*tj}t|j}|jd|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. r)rrrrrr)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)rrrrrrr 9s cOs*tj}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`. )rrrrrr)rrrrrrrrrrFs cOs*tj}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_localr)rrrrrrrrrr]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!)rrrrrrrcall_after_globalts r(cOsBtjdtddtj}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)rfunctionrrrrtrrrcall_after_local}s r,cGsFtjdtdd|dkr(tj|ddStj}|j|tj f|S)NzJInstead of exc_after, which is deprecated, use Timeout(seconds, exception)r#)r$cSsdS)Nrrrrrszexc_after..) r%r&r'rTimerrrr"r throw)r throw_argsrrrr exc_afters  r1ccs$|]\}}}tj|||VqdS)N)rZwrap_deprecated).0oldnewZfunrrr sr5zgreenthread.TimeoutErrorTimeoutzgreenthread.with_timeout with_timeoutcCs6tj}tj||jd}|j||jf||}||fS)N)r))rrrrr)rrrrrrr+rrrr!sr!c@sPeZdZdZddZddZddZdd Zd d Zd d Z 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,tjj||j|tj|_d|_d|_dS)NF)r__init__mainrEvent _exit_event_resolving_links _exit_funcs)selfr)rrrr8s zGreenThread.__init__cCs |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).)r;wait)r>rrrr?szGreenThread.waitcOs:|jdkrt|_|jj|||f|jjr6|jdS)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)r=rappendr;ready_resolve_links)r>r curried_argscurried_kwargsrrrlinks   zGreenThread.linkc Os:|js dSy|jj|||fdStk r4dSXdS)zn remove linked function set by :meth:`link` Remove successfully return True, otherwise False FTN)r=remove ValueError)r>rrCrDrrrunlinkszGreenThread.unlinkc CsNy|||}Wn&|jjtj|jYnX|jj||jdS)N)r;Zsend_exceptionsysexc_inforBsend)r>r*rrresultrrrr9s zGreenThread.mainc CsX|jr dS|jsdSd|_z0x*|jrF|jj\}}}||f||qWWdd|_XdS)NTF)r<r=popleft)r>fcaZckwrrrrBszGreenThread._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`).)r )r>r0rrrr 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`).)r)r>r0rrrrszGreenThread.cancelN) __name__ __module__ __qualname____doc__r8r?rErHr9rBr rrrrrrs  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.N)r )rr0rrrrsrc s|jr dStj}|sRfdd}||_t|trRy|j|fiWn YnXt}||jk rx|j |j 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,r tjdddntjdS)Nrr r#)sixreraiserZ GreenletExit)akw)r0rr just_raiseszkill..just_raiser) Zdeadrrrun isinstancerr9r rZensure_greenletrrr/)rr0rrXrr)r0rr s    )r)! collectionsrrIZeventletrrrrZ eventlet.hubsrZeventlet.supportrrrTr%__all__r r r r rrr(r,Z call_afterr1r6r7 TimeoutErrorr!rrr rrrrs:              _