o 0׾g2@sdZddlmZmZmZddlmZddlmZddl m Z ddl m Z ddgZGd d d eZeZGd ddeZd dZd S)a Timeouts. Many functions in :mod:`gevent` have a *timeout* argument that allows limiting the time the function will block. When that is not available, the :class:`Timeout` class and :func:`with_timeout` function in this module add timeouts to arbitrary code. .. warning:: Timeouts can only work when the greenlet switches to the hub. If a blocking function is called or an intense calculation is ongoing during which no switches occur, :class:`Timeout` is powerless. )absolute_importprint_functiondivision) string_types)_NONE) getcurrent)get_hub_noargsTimeout with_timeoutc@s`eZdZdZeddZeZeddZeZZ ddZ dd Z e Z e Z Z d d Zd d ZdS) _FakeTimercCdS)NFr selfr r X/var/www/html/backend_erp/backend_erp_env/lib/python3.10/site-packages/gevent/timeout.pypending(sz_FakeTimer.pendingcCr )zAlways returns NoneNr rr r rseconds.sz_FakeTimer.secondscOstd)Nz$non-expiring timer cannot be started)AssertionError)rargskwargsr r rstart4sz_FakeTimer.startcCdSNr rr r rstop8z_FakeTimer.stopcCs|Srr rr r r __enter__?rz_FakeTimer.__enter__cCrrr )r_t_v_tbr r r__exit__Brz_FakeTimer.__exit__N)__name__ __module__ __qualname__ __slots__propertyractivertimer exceptionrrcancelcloserrr r r rr s   r c@seZdZdZ  dddZdd Zd d Zedd d Ze d ddZ e ddZ ddZ ddZddZddZddZddZdS)!r a Timeout(seconds=None, exception=None, ref=True, priority=-1) Raise *exception* in the current greenlet after *seconds* have elapsed:: timeout = Timeout(seconds, exception) timeout.start() try: ... # exception will be raised here, after *seconds* passed since start() call finally: timeout.close() .. warning:: You must **always** call `close` on a ``Timeout`` object you have created, whether or not the code that the timeout was protecting finishes executing before the timeout elapses (whether or not the ``Timeout`` exception is raised) This ``try/finally`` construct or a ``with`` statement is a good pattern. (If the timeout object will be started again, use `cancel` instead of `close`; this is rare. You must still `close` it when you are done.) When *exception* is omitted or ``None``, the ``Timeout`` instance itself is raised:: >>> import gevent >>> gevent.Timeout(0.1).start() >>> gevent.sleep(0.2) #doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ... Timeout: 0.1 seconds If the *seconds* argument is not given or is ``None`` (e.g., ``Timeout()``), then the timeout will never expire and never raise *exception*. This is convenient for creating functions which take an optional timeout parameter of their own. (Note that this is **not** the same thing as a *seconds* value of ``0``.) :: def function(args, timeout=None): "A function with an optional timeout." timer = Timeout(timeout) with timer: ... .. caution:: A *seconds* value less than ``0.0`` (e.g., ``-1``) is poorly defined. In the future, support for negative values is likely to do the same thing as a value of ``None`` or ``0`` A *seconds* value of ``0`` requests that the event loop spin and poll for I/O; it will immediately expire as soon as control returns to the event loop. .. rubric:: Use As A Context Manager To simplify starting and canceling timeouts, the ``with`` statement can be used:: with gevent.Timeout(seconds, exception) as timeout: pass # ... code block ... This is equivalent to the try/finally block above with one additional feature: if *exception* is the literal ``False``, the timeout is still raised, but the context manager suppresses it, so the code outside the with-block won't see it. This is handy for adding a timeout to the functions that don't support a *timeout* parameter themselves:: data = None with gevent.Timeout(5, False): data = mysock.makefile().readline() if data is None: ... # 5 seconds passed without reading a line else: ... # a line was read within 5 seconds .. caution:: If ``readline()`` above catches and doesn't re-raise :exc:`BaseException` (for example, with a bare ``except:``), then your timeout will fail to function and control won't be returned to you when you expect. .. rubric:: Catching Timeouts When catching timeouts, keep in mind that the one you catch may not be the one you have set (a calling function may have set its own timeout); if you going to silence a timeout, always check that it's the instance you need:: timeout = Timeout(1) timeout.start() try: ... except Timeout as t: if t is not timeout: raise # not my timeout finally: timeout.close() .. versionchanged:: 1.1b2 If *seconds* is not given or is ``None``, no longer allocate a native timer object that will never be started. .. versionchanged:: 1.1 Add warning about negative *seconds* values. .. versionchanged:: 1.3a1 Timeout objects now have a :meth:`close` method that *must* be called when the timeout will no longer be used to properly clean up native resources. The ``with`` statement does this automatically. NTFcCsLt|||_||_||_|durt|_dStjj|pd||d|_dS)Ng)refpriority) BaseException__init__rr' _one_shotr r&get_hubloop)rrr'r+r,r/r r rr.s  zTimeout.__init__cCsh|jr td||jdurdS|jdus |jdus t|jtr#|}n|j}|jj|jt |dddS)zSchedule the timeout.z5%r is already started; to restart it, cancel it firstNFT)update) rrrr' isinstancerr&r_on_expirationr)rthrowsr r rrs   z Timeout.startcCs||dSr)throw)r prev_greenletexr r rr4szTimeout._on_expirationcCs8t|tr|js ||S|||||d}||S)aCreate a started :class:`Timeout`. This is a shortcut, the exact action depends on *timeout*'s type: * If *timeout* is a :class:`Timeout`, then call its :meth:`start` method if it's not already begun. * Otherwise, create a new :class:`Timeout` instance, passing (*timeout*, *exception*) as arguments, then call its :meth:`start` method. Returns the :class:`Timeout` instance. )r+r/)r3r rr)clstimeoutr'r+r/r r r start_news zTimeout.start_newcCs|durtStj|||ddS)NTr/)r r r;)r:r'r+r r r_start_new_or_dummy szTimeout._start_new_or_dummycCs|jjp|jjS)z.True if the timeout is scheduled to be raised.)r&rr%rr r rrszTimeout.pendingcCs |j|jr|dSdS)z If the timeout is pending, cancel it. Otherwise, do nothing. The timeout object can be :meth:`started ` again. If you will not start the timeout again, you should use :meth:`close` instead. N)r&rr/r)rr r rr(#s  zTimeout.cancelcCs|j|jt|_dS)z Close the timeout and free resources. The timer cannot be started again after this method has been used. N)r&rr)r rr r rr)/s   z Timeout.closecCsPt|j}|jr d}nd}|jdurd}nd|j}d|tt||j||fS)Nz pendingz exception=%rz<%s at %s seconds=%s%s%s>)typer rr'hexidr)r classnamerr'r r r__repr__8s   zTimeout.__repr__cCsb|jdurdS|jdkrdnd}|jdurd|j|fS|jdur(d|j|fSd|j||jfS) z >>> raise Timeout #doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ... Timeout Nr>sz %s second%sFz%s second%s (silent)z%s second%s: %s)rr')rsuffixr r r__str__Ds   zTimeout.__str__cCs|js||S)z^ Start and return the timer. If the timer is already started, just return it. )rrrr r rrVszTimeout.__enter__cCs&|||ur|jdurdSdSdS)z Stop the timer. .. versionchanged:: 1.3a1 The underlying native timer is also stopped. This object cannot be used again. FTN)r)r')rtypvaluetbr r rr^szTimeout.__exit__)NNTr*F)NNTF)NT)r r!r"__doc__r.rr4 classmethodr; staticmethodr=r$rr(r)rCrGrrr r r rr Hs&        c Os|dt}tj|dd}z0z ||i|WW|Sty=}z||ur8|tur8|WYd}~W|Sd}~ww|w)aZWrap a call to *function* with a timeout; if the called function fails to return before the timeout, cancel it and return a flag value, provided by *timeout_value* keyword argument. If timeout expires but *timeout_value* is not provided, raise :class:`Timeout`. Keyword argument *timeout_value* is not passed to *function*. timeout_valueTr<N)poprr r;r()rfunctionrkwdsrNr:r8r r rr ks    N)rK __future__rrrgevent._compatr gevent._utilrgreenletrgevent._hub_localrr0__all__objectr r-r r r r r rs    ' %