B H/\1@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) _FakeTimercCsdS)NFr )selfr r -lib/python3.7/site-packages/gevent/timeout.pypending(sz_FakeTimer.pendingcCsdS)zAlways returns NoneNr )r r r rseconds.sz_FakeTimer.secondscOs tddS)Nz$non-expiring timer cannot be started)AssertionError)r argskwargsr r rstart4sz_FakeTimer.startcCsdS)Nr )r r r rstop8sz_FakeTimer.stopcCs|S)Nr )r r r r __enter__?sz_FakeTimer.__enter__cCsdS)Nr )r Z_tZ_vZ_tbr r r__exit__Bsz_FakeTimer.__exit__N)__name__ __module__ __qualname__ __slots__propertyractivertimer exceptionrrcancelcloserrr r r rr s  r c@szeZdZdZdddZdd Zedd d Zedd d Z e ddZ ddZ ddZ ddZddZddZddZdS)r aS 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() .. note:: If the code that the timeout was protecting finishes executing before the timeout elapses, be sure to ``close`` the timeout so it is not unexpectedly raised in the future. Even if it is raised, it is a best practice to close it. This ``try/finally`` construct or a ``with`` statement is a recommended pattern. (If the timeout object will be started again, use ``cancel`` instead of ``close``; this is rare.) 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. NTFcCsJt|||_||_||_|dkr,t|_ntjj|p:d||d|_dS)Ng)refpriority) BaseException__init__rr _one_shotr rget_hubZloop)r rrr#r$r'r r rr&s zTimeout.__init__cCsf|jrtd||jdkr dS|jdks@|jdks@t|jtrF|}n|j}|jjtj |dddS)zSchedule the timeout.z5%r is already started; to restart it, cancel it firstNFT)update) rrrr isinstancerrrrthrow)r Zthrowsr r rrs   z Timeout.startcCs8t|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')r*r rr)clstimeoutrr#r'r r r start_news zTimeout.start_newcCs|dkr tStj|||ddS)NT)r')r r r.)r-rr#r r r_start_new_or_dummys zTimeout._start_new_or_dummycCs|jjp|jjS)z.True if the timeout is scheduled to be raised.)rrr)r r r rrszTimeout.pendingcCs|j|jr|dS)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)rrr'r!)r r 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)rrr!r )r r r rr!&s  z Timeout.closecCsPt|j}|jrd}nd}|jdkr*d}n d|j}d|tt||j||fS)Nz pendingz exception=%rz<%s at %s seconds=%s%s%s>)typerrrhexidr)r Z classnamerrr r r__repr__/s   zTimeout.__repr__cCsb|jdkrdS|jdkrdnd}|jdkr8d|j|fS|jdkrPd|j|fSd|j||jfS) z >>> raise Timeout #doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ... Timeout Nr0sz %s second%sFz%s second%s (silent)z%s second%s: %s)rr)r suffixr r r__str__;s   zTimeout.__str__cCs|js||S)z^ Start and return the timer. If the timer is already started, just return it. )rr)r r r rrMszTimeout.__enter__cCs"|||kr|jdkrdSdS)z Stop the timer. .. versionchanged:: 1.3a1 The underlying native timer is also stopped. This object cannot be used again. FTN)r!r)r typvaluetbr r rrUszTimeout.__exit__)NNTr"F)NNTF)NT)rrr__doc__r&r classmethodr. staticmethodr/rrr r!r4r8rrr r r rr Hsz       c Osr|dt}tj|dd}zHy |||Stk r^}z||krL|tk rL|SWdd}~XYnXWd|XdS)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_valueT)r'N)poprr r.r )rZfunctionrkwdsr?r-exr r rr bs  N)r<Z __future__rrrZgevent._compatrZ gevent._utilrZgreenletrZgevent._hub_localrr(__all__objectr r%r r r r r rs    '