o ˷e1@sdZddlmZddlZddlZddlZddlZddlZddlZ ddl m Z ddl m Z ddl m ZeeZdZdZdZd Zd d Zee je je je j je j jejZ efd d ZdddZGddde Z!dS)axHelpers for retrying functions with exponential back-off. The :class:`Retry` decorator can be used to retry functions that raise exceptions using exponential backoff. Because a exponential sleep algorithm is used, the retry is limited by a `deadline`. The deadline is the maxmimum amount of time a method can block. This is used instead of total number of retries because it is difficult to ascertain the amount of time a function can block when using total number of retries and exponential backoff. By default, this decorator will retry transient API errors (see :func:`if_transient_error`). For example: .. code-block:: python @retry.Retry() def call_flaky_rpc(): return client.flaky_rpc() # Will retry flaky_rpc() if it raises transient API errors. result = call_flaky_rpc() You can pass a custom predicate to retry on different exceptions, such as waiting for an eventually consistent item to be available: .. code-block:: python @retry.Retry(predicate=if_exception_type(exceptions.NotFound)) def check_if_exists(): return client.does_thing_exist() is_available = check_if_exists() Some client library methods apply retry automatically. These methods can accept a ``retry`` parameter that allows you to configure the behavior: .. code-block:: python my_retry = retry.Retry(deadline=60) result = client.some_method(retry=my_retry) )unicode_literalsN)datetime_helpers) exceptionsg?gN@@g^@csfdd}|S)a9Creates a predicate to check if the exception is of a given type. Args: exception_types (Sequence[:func:`type`]): The exception types to check for. Returns: Callable[Exception]: A predicate that returns True if the provided exception is of the given type(s). cs t|S)z/Bound predicate for checking an exception type.) isinstance) exceptionexception_typesL/var/www/ideatree/venv/lib/python3.10/site-packages/google/api_core/retry.pyif_exception_type_predicateZs z6if_exception_type..if_exception_type_predicater )r r r rr if_exception_typeNs r ccs*|} ttd|d|V||}q)a%Generates sleep intervals based on the exponential back-off algorithm. This implements the `Truncated Exponential Back-off`_ algorithm. .. _Truncated Exponential Back-off: https://cloud.google.com/storage/docs/exponential-backoff Args: initial (float): The minimum amount of time to delay. This must be greater than 0. maximum (float): The maximum amount of time to delay. multiplier (float): The multiplier applied to the delay. Yields: float: successive sleep intervals. Tgr)minrandomuniform)initialmaximum multiplierdelayr r r exponential_sleep_generator}s rc Cs|durttj|d}nd}d}|D]Y}z|WSty>}z||s*|}|dur4||WYd}~nd}~wwt} |dur`|| krUtd||||| } t | |}t d||t |qtd)aFCall a function and retry if it fails. This is the lowest-level retry helper. Generally, you'll use the higher-level retry helper :class:`Retry`. Args: target(Callable): The function to call and retry. This must be a nullary function - apply arguments with `functools.partial`. predicate (Callable[Exception]): A callable used to determine if an exception raised by the target should be considered retryable. It should return True to retry or False otherwise. sleep_generator (Iterable[float]): An infinite iterator that determines how long to sleep between retries. deadline (float): How long to keep retrying the target. The last sleep period is shortened as necessary, so that the last retry runs at ``deadline`` (and not considerably beyond it). on_error (Callable[Exception]): A function to call while processing a retryable exception. Any error raised by this function will *not* be caught. Returns: Any: the return value of the target function. Raises: google.api_core.RetryError: If the deadline is exceeded while retrying. ValueError: If the sleep generator stops yielding values. Exception: If the target raises a method that isn't retryable. N)secondsz:Deadline of {:.1f}s exceeded while calling target functionz(Retrying due to {}, sleeping {:.1f}s ...z.Sleep generator stopped yielding sleep values.)rutcnowdatetime timedelta Exceptionr RetryErrorformat total_secondsr_LOGGERdebugtimesleep ValueError) target predicatesleep_generatordeadlineon_errordeadline_datetimelast_excr!excnowtime_to_deadliner r r retry_targetsF       r-c@s^eZdZdZeeeeedfddZ dddZ e ddZ d d Z d d Zdd dZddZdS)RetryamExponential retry decorator. This class is a decorator used to add exponential back-off retry behavior to an RPC call. Although the default behavior is to retry transient API errors, a different predicate can be provided to retry other exceptions. Args: predicate (Callable[Exception]): A callable that should return ``True`` if the given exception is retryable. initial (float): The minimum amount of time to delay in seconds. This must be greater than 0. maximum (float): The maximum amount of time to delay in seconds. multiplier (float): The multiplier applied to the delay. deadline (float): How long to keep retrying in seconds. The last sleep period is shortened as necessary, so that the last retry runs at ``deadline`` (and not considerably beyond it). NcCs(||_||_||_||_||_||_dSN) _predicate_initial _multiplier_maximum _deadline _on_error)selfr$rrrr&r'r r r __init__s   zRetry.__init__cs.jdurjtfdd}|S)aWrap a callable with retry behavior. Args: func (Callable): The callable to add retry behavior to. on_error (Callable[Exception]): A function to call while processing a retryable exception. Any error raised by this function will *not* be caught. Returns: Callable: A callable that will invoke ``func`` with retry behavior. NcsBtjg|Ri|}tjjjd}t|j|jdS)z0A wrapper that calls target function with retry.)r)r') functoolspartialrr1r3r2r-r0r4)argskwargsr#r%funcr'r6r r retry_wrapped_funcs z*Retry.__call__..retry_wrapped_func)r5r8wraps)r6r=r'r>r r<r __call__s zRetry.__call__cCs|jSr/)r4r6r r r r&%szRetry.deadlinecCst|j|j|j|j||jdS)zReturn a copy of this retry with the given deadline. Args: deadline (float): How long to keep retrying. Returns: Retry: A new retry instance with the given deadline. r$rrrr&r')r.r0r1r3r2r5)r6r&r r r with_deadline)s zRetry.with_deadlinecCst||j|j|j|j|jdS)a*Return a copy of this retry with the given predicate. Args: predicate (Callable[Exception]): A callable that should return ``True`` if the given exception is retryable. Returns: Retry: A new retry instance with the given predicate. rB)r.r1r3r2r4r5)r6r$r r r with_predicate;s zRetry.with_predicatecCsDt|j|dur |n|j|dur|n|j|dur|n|j|j|jdS)aReturn a copy of this retry with the given delay options. Args: initial (float): The minimum amount of time to delay. This must be greater than 0. maximum (float): The maximum amount of time to delay. multiplier (float): The multiplier applied to the delay. Returns: Retry: A new retry instance with the given predicate. NrB)r.r0r1r3r2r4r5)r6rrrr r r with_delayNs zRetry.with_delaycCs d|j|j|j|j|j|jS)Nze)rr0r1r3r2r4r5rAr r r __str__csz Retry.__str__r/)NNN)__name__ __module__ __qualname____doc__if_transient_error_DEFAULT_INITIAL_DELAY_DEFAULT_MAXIMUM_DELAY_DEFAULT_DELAY_MULTIPLIER_DEFAULT_DEADLINEr7r@propertyr&rCrDrErFr r r r r.s  !   r.r/)"rJ __future__rrr8loggingrr requests.exceptionsrequestsgoogle.api_corerr google.authauth_exceptions getLoggerrGrrLrMrNrOr InternalServerErrorTooManyRequestsServiceUnavailableConnectionErrorChunkedEncodingErrorTransportErrorrKrr-objectr.r r r r s: *      I