'(SrSSKJr SSKrSSKrSSKJr SrSrSr Sr "SS \ 5r "S S \ 5r S r"S S\ 5rg)aDecorators for applying timeout arguments to functions. These decorators are used to wrap API methods to apply either a Deadline-dependent (recommended), constant (DEPRECATED) or exponential (DEPRECATED) timeout argument. For example, imagine an API method that can take a while to return results, such as one that might block until a resource is ready: .. code-block:: python def is_thing_ready(timeout=None): response = requests.get('https://example.com/is_thing_ready') response.raise_for_status() return response.json() This module allows a function like this to be wrapped so that timeouts are automatically determined, for example: .. code-block:: python timeout_ = timeout.ExponentialTimeout() is_thing_ready_with_timeout = timeout_(is_thing_ready) for n in range(10): try: is_thing_ready_with_timeout({'example': 'data'}) except: pass In this example the first call to ``is_thing_ready`` will have a relatively small timeout (like 1 second). If the resource is available and the request completes quickly, the loop exits. But, if the resource isn't yet available and the request times out, it'll be retried - this time with a larger timeout. In the broader context these decorators are typically combined with :mod:`google.api_core.retry` to implement API methods with a signature that matches ``api_method(request, timeout=None, retry=None)``. )unicode_literalsN)datetime_helpersg@g>@g@cF\rSrSrSrS\R 4SjrSrSr Sr g)TimeToDeadlineTimeoutFaA decorator that decreases timeout set for an RPC based on how much time has left till its deadline. The deadline is calculated as ``now + initial_timeout`` when this decorator is first called for an rpc. In other words this decorator implements deadline semantics in terms of a sequence of decreasing timeouts t0 > t1 > t2 ... tn >= 0. Args: timeout (Optional[float]): the timeout (in seconds) to applied to the wrapped function. If `None`, the target function is expected to never timeout. NcXlX lgN)_timeout_clock)selftimeoutclocks *lib/third_party/google/api_core/timeout.py__init__TimeToDeadlineTimeout.__init__Ts   c^^^TR5R5m[R"T5UUU4Sj5nU$)Apply the timeout decorator. Args: func (Callable): The function to apply the timeout argument to. This function must accept a timeout keyword argument. Returns: Callable: The wrapped function. c>TRbSTR5R5nUT- S:aTnUT- nTRU- nUS:a TRnXAS'T"U0UD6$)#Wrapped function that adds timeout.gMbP?r )r r timestamp)argskwargs now_timestamptime_since_first_attemptremaining_timeoutfirst_attempt_timestampfuncr s rfunc_with_timeout9TimeToDeadlineTimeout.__call__..func_with_timeoutes}}( $ 7 7 9 !#::UB$;M+8;R+R($(MM4L$L!%q((, %$5y!(( (r)r r functoolswraps)r rr rs`` @r__call__TimeToDeadlineTimeout.__call__Xs=#'++-"9"9";   )  )<! rc8SRUR5$)Nz&formatr r s r__str__TimeToDeadlineTimeout.__str__s7>>t}}MMr)r r ) __name__ __module__ __qualname____firstlineno____doc__rutcnowrr$r*__static_attributes__rrrrFs&  $+;+B+B,!\Nrrc.\rSrSrSrSSjrSrSrSrg) ConstantTimeoutahA decorator that adds a constant timeout argument. DEPRECATED: use ``TimeToDeadlineTimeout`` instead. This is effectively equivalent to ``functools.partial(func, timeout=timeout)``. Args: timeout (Optional[float]): the timeout (in seconds) to applied to the wrapped function. If `None`, the target function is expected to never timeout. NcXlgr r )r r s rrConstantTimeout.__init__s rcJ^^[R"T5UU4Sj5nU$)rc2>TRUS'T"U0UD6$rr r8)rrrr s rr 3ConstantTimeout.__call__..func_with_timeouts#!% F9 (( (r)r"r#)r rr s`` rr$ConstantTimeout.__call__s(   )  ) ! rc8SRUR5$)Nz r'r)s rr*ConstantTimeout.__str__s188GGrr8r ) r,r-r.r/r0rr$r*r2r3rrr5r5s  !&Hrr5c## Ub+[R"5[R"US9-nO[RRnUn[R"5n[ UU[ XF- R55v XR-nM?7f)a6A generator that yields exponential timeout values. Args: initial (float): The initial timeout. maximum (float): The maximum timeout. multiplier (float): The multiplier applied to the timeout. deadline (float): The overall deadline across all invocations. Yields: float: A timeout value. )seconds)rr1datetime timedeltamaxminfloatrB)initialmaximum multiplierdeadlinedeadline_datetimer nows r_exponential_timeout_generatorrNs,3358J8J9  %--11G %%'   $*33 4   & sB B c<\rSrSrSr\\\\4Sjr Sr Sr Sr Sr g) ExponentialTimeoutaA decorator that adds an exponentially increasing timeout argument. DEPRECATED: the concept of incrementing timeout exponentially has been deprecated. Use ``TimeToDeadlineTimeout`` instead. This is useful if a function is called multiple times. Each time the function is called this decorator will calculate a new timeout parameter based on the the number of times the function has been called. For example .. code-block:: python Args: initial (float): The initial timeout to pass. maximum (float): The maximum timeout for any one call. multiplier (float): The multiplier applied to the timeout for each invocation. deadline (Optional[float]): The overall deadline across all invocations. This is used to prevent a very large calculated timeout from pushing the overall execution time over the deadline. This is especially useful in conjunction with :mod:`google.api_core.retry`. If ``None``, the timeouts will not be adjusted to accommodate an overall deadline. c4XlX lX0lX@lgr )_initial_maximum _multiplier _deadline)r rHrIrJrKs rrExponentialTimeout.__init__s  %!rcV[URURURUS9$)zReturn a copy of this timeout with the given deadline. Args: deadline (float): The overall deadline across all invocations. Returns: ExponentialTimeout: A new instance with the given deadline. )rHrIrJrK)rPrSrTrU)r rKs r with_deadline ExponentialTimeout.with_deadlines+"MMMM''   rc^^[URURURUR5m[ R "T5UU4Sj5nU$)rc0>[T5US'T"U0UD6$r<)next)rrrtimeoutss rr 6ExponentialTimeout.__call__..func_with_timeouts#!%XF9 (( (r)rNrSrTrUrVr"r#)r rr r^s ` @rr$ExponentialTimeout.__call__ sO2 MM4==$*:*:DNN    )  ) ! rczSRURURURUR5$)NzW)r(rSrTrUrVr)s rr*ExponentialTimeout.__str__ s1 228& t}}d.>.>3 r)rVrSrTrUN)r,r-r.r/r0_DEFAULT_INITIAL_TIMEOUT_DEFAULT_MAXIMUM_TIMEOUT_DEFAULT_TIMEOUT_MULTIPLIER_DEFAULT_DEADLINErrYr$r*r2r3rrrPrPs)8)(." " !, rrP)r0 __future__rrCr"google.api_corerrcrdrerfobjectrr5rNrPr3rrrjsg&P(,!ANFANH%Hf%HP'BS S r