j i'(dZddlmZddlZddlZddlmZdZdZdZ dZ Gdd e Z Gd d e Z d ZGd de ZdS)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@c4eZdZdZdejfdZdZdZdS)TimeToDeadlineTimeouta&A 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. Nc"||_||_dSN)_timeout_clock)selftimeoutclocks O/srv/django_bis/venv311/lib/python3.11/site-packages/google/api_core/timeout.py__init__zTimeToDeadlineTimeout.__init__Ts  ctjfd}|S)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. cjR}|z dkr}|z }j|z }|dkrj}||d<|i|S)#Wrapped function that adds timeout.NgMbP?r )r r timestamp)argskwargs now_timestamptime_since_first_attemptremaining_timeoutfirst_attempt_timestampfuncr s rfunc_with_timeoutz9TimeToDeadlineTimeout.__call__..func_with_timeoutes}( $ 7 7 9 9 !#::UBB$;M+8;R+R($(M4L$L!%q(((, %$5y!4((( (r)r r functoolswraps)r rrrs`` @r__call__zTimeToDeadlineTimeout.__call__Xsa#'++--"9"9";";    ) ) ) ) ) )   )<! rc6d|jS)Nz&formatr r s r__str__zTimeToDeadlineTimeout.__str__s7>>t}MMMr) __name__ __module__ __qualname____doc__rutcnowrr!r&rrrrFsa   $+;+B,!,!,!\NNNNNrrc&eZdZdZddZdZdZdS)ConstantTimeoutaA 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. Nc||_dSrr )r r s rrzConstantTimeout.__init__s  rcJtjfd}|S)rc(j|d<|i|Srr r0)rrrr s rrz3ConstantTimeout.__call__..func_with_timeouts&!% F9 4((( (r)rr )r rrs`` rr!zConstantTimeout.__call__sA    ) ) ) ) )   ) ! rc6d|jS)Nz r#r%s rr&zConstantTimeout.__str__s188GGGrr)r'r(r)r*rr!r&r,rrr.r.sU      !!!&HHHHHrr.c#K|*tjtj|z}ntjj}|} tj}t ||t ||z jV||z}A)aVA 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. N)seconds)rr+datetime timedeltamaxminfloatr6)initialmaximum multiplierdeadlinedeadline_datetimer nows r_exponential_timeout_generatorrBs,3558J9 9 9  %-1G '%''   $s*3 4 4      J& 'rc4eZdZdZeeeefdZdZ dZ dZ dS)ExponentialTimeoutaTA 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. c>||_||_||_||_dSr)_initial_maximum _multiplier _deadline)r r<r=r>r?s rrzExponentialTimeout.__init__s%   %!rcFt|j|j|j|S)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. )r<r=r>r?)rDrFrGrH)r r?s r with_deadlinez ExponentialTimeout.with_deadlines."MM'     rct|j|j|j|jt jfd}|S)rc8t|d<|i|Sr3)next)rrrtimeoutss rrz6ExponentialTimeout.__call__..func_with_timeouts*!%XF9 4((( (r)rBrFrGrHrIrr )r rrrOs ` @rr!zExponentialTimeout.__call__ sd2 M4=$*:DN      ) ) ) ) )   ) ! rcZd|j|j|j|jS)NzW)r$rFrGrHrIr%s rr&zExponentialTimeout.__str__ s- 228& t}d.>33 rN) r'r(r)r*_DEFAULT_INITIAL_TIMEOUT_DEFAULT_MAXIMUM_TIMEOUT_DEFAULT_TIMEOUT_MULTIPLIER_DEFAULT_DEADLINErrKr!r&r,rrrDrDsm8)(." " " " "   !!!,     rrD)r* __future__rr7rgoogle.api_corerrQrRrSrTobjectrr.rBrDr,rrrXs!&&P(''''',,,,,,!ANANANANANFANANANH%H%H%H%H%Hf%H%H%HP'''BS S S S S S S S S S r