python-backoff 2.2.2rc2__py3-none-any.whl → 2.3.1__py3-none-any.whl

backoff/__init__.py

@@ -1,4 +1,3 @@
-# coding:utf-8
 """
 Function decoration for backoff and retry
 
@@ -12,20 +11,21 @@ polling resources for externally generated content.
 For examples and full documentation see the README at
 https://github.com/python-backoff/backoff
 """
+
 from backoff._decorator import on_exception, on_predicate
 from backoff._jitter import full_jitter, random_jitter
 from backoff._wait_gen import constant, expo, fibo, runtime, decay
 
 __all__ = [
-    'on_predicate',
-    'on_exception',
-    'constant',
-    'expo',
-    'decay',
-    'fibo',
-    'runtime',
-    'full_jitter',
-    'random_jitter',
+    "on_predicate",
+    "on_exception",
+    "constant",
+    "expo",
+    "decay",
+    "fibo",
+    "runtime",
+    "full_jitter",
+    "random_jitter",
 ]
 
-__version__ = "2.2.1"
+__version__ = "2.3.1"

backoff/_async.py

@@ -1,20 +1,20 @@
-# coding:utf-8
-import datetime
-import functools
 import asyncio
+import functools
 import inspect
-from datetime import timedelta
+import time
 
-from backoff._common import (_init_wait_gen, _maybe_call, _next_wait)
+from backoff._common import _init_wait_gen, _maybe_call, _next_wait
 
 
 def _ensure_coroutine(coro_or_func):
     if inspect.iscoroutinefunction(coro_or_func):
         return coro_or_func
     else:
+
         @functools.wraps(coro_or_func)
         async def f(*args, **kwargs):
             return coro_or_func(*args, **kwargs)
+
         return f
 
 
@@ -22,27 +22,32 @@ def _ensure_coroutines(coros_or_funcs):
     return [_ensure_coroutine(f) for f in coros_or_funcs]
 
 
-async def _call_handlers(handlers,
-                         *,
-                         target, args, kwargs, tries, elapsed,
-                         **extra):
+async def _call_handlers(handlers, *, target, args, kwargs, tries, elapsed, **extra):
     details = {
-        'target': target,
-        'args': args,
-        'kwargs': kwargs,
-        'tries': tries,
-        'elapsed': elapsed,
+        "target": target,
+        "args": args,
+        "kwargs": kwargs,
+        "tries": tries,
+        "elapsed": elapsed,
     }
     details.update(extra)
     for handler in handlers:
         await handler(details)
 
 
-def retry_predicate(target, wait_gen, predicate,
-                    *,
-                    max_tries, max_time, jitter,
-                    on_success, on_backoff, on_giveup,
-                    wait_gen_kwargs):
+def retry_predicate(
+    target,
+    wait_gen,
+    predicate,
+    *,
+    max_tries,
+    max_time,
+    jitter,
+    on_success,
+    on_backoff,
+    on_giveup,
+    wait_gen_kwargs,
+):
     on_success = _ensure_coroutines(on_success)
     on_backoff = _ensure_coroutines(on_backoff)
     on_giveup = _ensure_coroutines(on_giveup)
@@ -55,17 +60,16 @@ def retry_predicate(target, wait_gen, predicate,
 
     @functools.wraps(target)
     async def retry(*args, **kwargs):
-
         # update variables from outer function args
         max_tries_value = _maybe_call(max_tries)
         max_time_value = _maybe_call(max_time)
 
         tries = 0
-        start = datetime.datetime.now()
+        start = time.monotonic()
         wait = _init_wait_gen(wait_gen, wait_gen_kwargs)
         while True:
             tries += 1
-            elapsed = timedelta.total_seconds(datetime.datetime.now() - start)
+            elapsed = time.monotonic() - start
             details = {
                 "target": target,
                 "args": args,
@@ -76,23 +80,22 @@ def retry_predicate(target, wait_gen, predicate,
 
             ret = await target(*args, **kwargs)
             if predicate(ret):
-                max_tries_exceeded = (tries == max_tries_value)
-                max_time_exceeded = (max_time_value is not None and
-                                     elapsed >= max_time_value)
+                max_tries_exceeded = tries == max_tries_value
+                max_time_exceeded = (
+                    max_time_value is not None and elapsed >= max_time_value
+                )
 
                 if max_tries_exceeded or max_time_exceeded:
                     await _call_handlers(on_giveup, **details, value=ret)
                     break
 
                 try:
-                    seconds = _next_wait(wait, ret, jitter, elapsed,
-                                         max_time_value)
+                    seconds = _next_wait(wait, ret, jitter, elapsed, max_time_value)
                 except StopIteration:
                     await _call_handlers(on_giveup, **details, value=ret)
                     break
 
-                await _call_handlers(on_backoff, **details, value=ret,
-                                     wait=seconds)
+                await _call_handlers(on_backoff, **details, value=ret, wait=seconds)
 
                 # Note: there is no convenient way to pass explicit event
                 # loop to decorator, so here we assume that either default
@@ -114,11 +117,21 @@ def retry_predicate(target, wait_gen, predicate,
     return retry
 
 
-def retry_exception(target, wait_gen, exception,
-                    *,
-                    max_tries, max_time, jitter, giveup,
-                    on_success, on_backoff, on_giveup, raise_on_giveup,
-                    wait_gen_kwargs):
+def retry_exception(
+    target,
+    wait_gen,
+    exception,
+    *,
+    max_tries,
+    max_time,
+    jitter,
+    giveup,
+    on_success,
+    on_backoff,
+    on_giveup,
+    raise_on_giveup,
+    wait_gen_kwargs,
+):
     on_success = _ensure_coroutines(on_success)
     on_backoff = _ensure_coroutines(on_backoff)
     on_giveup = _ensure_coroutines(on_giveup)
@@ -130,16 +143,15 @@ def retry_exception(target, wait_gen, exception,
 
     @functools.wraps(target)
     async def retry(*args, **kwargs):
-
         max_tries_value = _maybe_call(max_tries)
         max_time_value = _maybe_call(max_time)
 
         tries = 0
-        start = datetime.datetime.now()
+        start = time.monotonic()
         wait = _init_wait_gen(wait_gen, wait_gen_kwargs)
         while True:
             tries += 1
-            elapsed = timedelta.total_seconds(datetime.datetime.now() - start)
+            elapsed = time.monotonic() - start
             details = {
                 "target": target,
                 "args": args,
@@ -152,9 +164,10 @@ def retry_exception(target, wait_gen, exception,
                 ret = await target(*args, **kwargs)
             except exception as e:
                 giveup_result = await giveup(e)
-                max_tries_exceeded = (tries == max_tries_value)
-                max_time_exceeded = (max_time_value is not None and
-                                     elapsed >= max_time_value)
+                max_tries_exceeded = tries == max_tries_value
+                max_time_exceeded = (
+                    max_time_value is not None and elapsed >= max_time_value
+                )
 
                 if giveup_result or max_tries_exceeded or max_time_exceeded:
                     await _call_handlers(on_giveup, **details, exception=e)
@@ -163,14 +176,12 @@ def retry_exception(target, wait_gen, exception,
                     return None
 
                 try:
-                    seconds = _next_wait(wait, e, jitter, elapsed,
-                                         max_time_value)
+                    seconds = _next_wait(wait, e, jitter, elapsed, max_time_value)
                 except StopIteration:
                     await _call_handlers(on_giveup, **details, exception=e)
                     raise e
 
-                await _call_handlers(on_backoff, **details, wait=seconds,
-                                     exception=e)
+                await _call_handlers(on_backoff, **details, wait=seconds, exception=e)
 
                 # Note: there is no convenient way to pass explicit event
                 # loop to decorator, so here we assume that either default
@@ -186,4 +197,5 @@ def retry_exception(target, wait_gen, exception,
                 await _call_handlers(on_success, **details)
 
                 return ret
+
     return retry

backoff/_common.py

@@ -1,5 +1,3 @@
-# coding:utf-8
-
 import functools
 import logging
 import sys
@@ -8,7 +6,7 @@ import warnings
 
 
 # Use module-specific logger with a default null handler.
-_logger = logging.getLogger('backoff')
+_logger = logging.getLogger("backoff")
 _logger.addHandler(logging.NullHandler())  # pragma: no cover
 _logger.setLevel(logging.INFO)
 
@@ -34,10 +32,7 @@ def _init_wait_gen(wait_gen, wait_gen_kwargs):
 def _next_wait(wait, send_value, jitter, elapsed, max_time):
     value = wait.send(send_value)
     try:
-        if jitter is not None:
-            seconds = jitter(value)
-        else:
-            seconds = value
+        seconds = jitter(value) if jitter is not None else value
     except TypeError:
         warnings.warn(
             "Nullary jitter function signature is deprecated. Use "
@@ -65,14 +60,20 @@ def _prepare_logger(logger):
 # Configure handler list with user specified handler and optionally
 # with a default handler bound to the specified logger.
 def _config_handlers(
-    user_handlers, *, default_handler=None, logger=None, log_level=None
+    user_handlers,
+    *,
+    default_handler=None,
+    logger=None,
+    log_level=None,
 ):
     handlers = []
     if logger is not None:
         assert log_level is not None, "Log level is not specified"
         # bind the specified logger to the default log handler
         log_handler = functools.partial(
-            default_handler, logger=logger, log_level=log_level
+            default_handler,
+            logger=logger,
+            log_level=log_level,
         )
         handlers.append(log_handler)
 
@@ -81,7 +82,7 @@ def _config_handlers(
 
     # user specified handlers can either be an iterable of handlers
     # or a single handler. either way append them to the list.
-    if hasattr(user_handlers, '__iter__'):
+    if hasattr(user_handlers, "__iter__"):
         # add all handlers in the iterable
         handlers += list(user_handlers)
     else:
@@ -94,27 +95,27 @@ def _config_handlers(
 # Default backoff handler
 def _log_backoff(details, logger, log_level):
     msg = "Backing off %s(...) for %.1fs (%s)"
-    log_args = [details['target'].__name__, details['wait']]
+    log_args = [details["target"].__name__, details["wait"]]
 
     exc_typ, exc, _ = sys.exc_info()
     if exc is not None:
         exc_fmt = traceback.format_exception_only(exc_typ, exc)[-1]
         log_args.append(exc_fmt.rstrip("\n"))
     else:
-        log_args.append(details['value'])
+        log_args.append(details["value"])
     logger.log(log_level, msg, *log_args)
 
 
 # Default giveup handler
 def _log_giveup(details, logger, log_level):
     msg = "Giving up %s(...) after %d tries (%s)"
-    log_args = [details['target'].__name__, details['tries']]
+    log_args = [details["target"].__name__, details["tries"]]
 
     exc_typ, exc, _ = sys.exc_info()
     if exc is not None:
         exc_fmt = traceback.format_exception_only(exc_typ, exc)[-1]
         log_args.append(exc_fmt.rstrip("\n"))
     else:
-        log_args.append(details['value'])
+        log_args.append(details["value"])
 
     logger.log(log_level, msg, *log_args)

backoff/_decorator.py

@@ -1,4 +1,3 @@
-# coding:utf-8
 import inspect
 import logging
 import operator
@@ -8,7 +7,7 @@ from backoff._common import (
     _prepare_logger,
     _config_handlers,
     _log_backoff,
-    _log_giveup
+    _log_giveup,
 )
 from backoff._jitter import full_jitter
 from backoff import _async, _sync
@@ -24,19 +23,21 @@ from backoff._typing import (
 )
 
 
-def on_predicate(wait_gen: _WaitGenerator,
-                 predicate: _Predicate[Any] = operator.not_,
-                 *,
-                 max_tries: Optional[_MaybeCallable[int]] = None,
-                 max_time: Optional[_MaybeCallable[float]] = None,
-                 jitter: Union[_Jitterer, None] = full_jitter,
-                 on_success: Union[_Handler, Iterable[_Handler], None] = None,
-                 on_backoff: Union[_Handler, Iterable[_Handler], None] = None,
-                 on_giveup: Union[_Handler, Iterable[_Handler], None] = None,
-                 logger: _MaybeLogger = 'backoff',
-                 backoff_log_level: int = logging.INFO,
-                 giveup_log_level: int = logging.ERROR,
-                 **wait_gen_kwargs: Any) -> Callable[[_CallableT], _CallableT]:
+def on_predicate(
+    wait_gen: _WaitGenerator,
+    predicate: _Predicate[Any] = operator.not_,
+    *,
+    max_tries: Optional[_MaybeCallable[int]] = None,
+    max_time: Optional[_MaybeCallable[float]] = None,
+    jitter: Union[_Jitterer, None] = full_jitter,
+    on_success: Union[_Handler, Iterable[_Handler], None] = None,
+    on_backoff: Union[_Handler, Iterable[_Handler], None] = None,
+    on_giveup: Union[_Handler, Iterable[_Handler], None] = None,
+    logger: _MaybeLogger = "backoff",
+    backoff_log_level: int = logging.INFO,
+    giveup_log_level: int = logging.ERROR,
+    **wait_gen_kwargs: Any,
+) -> Callable[[_CallableT], _CallableT]:
     """Returns decorator for backoff and retry triggered by predicate.
 
     Args:
@@ -80,6 +81,7 @@ def on_predicate(wait_gen: _WaitGenerator,
             args will first be evaluated and their return values passed.
             This is useful for runtime configuration.
     """
+
     def decorate(target):
         nonlocal logger, on_success, on_backoff, on_giveup
 
@@ -89,13 +91,13 @@ def on_predicate(wait_gen: _WaitGenerator,
             on_backoff,
             default_handler=_log_backoff,
             logger=logger,
-            log_level=backoff_log_level
+            log_level=backoff_log_level,
         )
         on_giveup = _config_handlers(
             on_giveup,
             default_handler=_log_giveup,
             logger=logger,
-            log_level=giveup_log_level
+            log_level=giveup_log_level,
         )
 
         if inspect.iscoroutinefunction(target):
@@ -113,28 +115,30 @@ def on_predicate(wait_gen: _WaitGenerator,
             on_success=on_success,
             on_backoff=on_backoff,
             on_giveup=on_giveup,
-            wait_gen_kwargs=wait_gen_kwargs
+            wait_gen_kwargs=wait_gen_kwargs,
         )
 
     # Return a function which decorates a target with a retry loop.
     return decorate
 
 
-def on_exception(wait_gen: _WaitGenerator,
-                 exception: _MaybeSequence[Type[Exception]],
-                 *,
-                 max_tries: Optional[_MaybeCallable[int]] = None,
-                 max_time: Optional[_MaybeCallable[float]] = None,
-                 jitter: Union[_Jitterer, None] = full_jitter,
-                 giveup: _Predicate[Exception] = lambda e: False,
-                 on_success: Union[_Handler, Iterable[_Handler], None] = None,
-                 on_backoff: Union[_Handler, Iterable[_Handler], None] = None,
-                 on_giveup: Union[_Handler, Iterable[_Handler], None] = None,
-                 raise_on_giveup: bool = True,
-                 logger: _MaybeLogger = 'backoff',
-                 backoff_log_level: int = logging.INFO,
-                 giveup_log_level: int = logging.ERROR,
-                 **wait_gen_kwargs: Any) -> Callable[[_CallableT], _CallableT]:
+def on_exception(
+    wait_gen: _WaitGenerator,
+    exception: _MaybeSequence[Type[Exception]],
+    *,
+    max_tries: Optional[_MaybeCallable[int]] = None,
+    max_time: Optional[_MaybeCallable[float]] = None,
+    jitter: Union[_Jitterer, None] = full_jitter,
+    giveup: _Predicate[Exception] = lambda e: False,
+    on_success: Union[_Handler, Iterable[_Handler], None] = None,
+    on_backoff: Union[_Handler, Iterable[_Handler], None] = None,
+    on_giveup: Union[_Handler, Iterable[_Handler], None] = None,
+    raise_on_giveup: bool = True,
+    logger: _MaybeLogger = "backoff",
+    backoff_log_level: int = logging.INFO,
+    giveup_log_level: int = logging.ERROR,
+    **wait_gen_kwargs: Any,
+) -> Callable[[_CallableT], _CallableT]:
     """Returns decorator for backoff and retry triggered by exception.
 
     Args:
@@ -180,6 +184,7 @@ def on_exception(wait_gen: _WaitGenerator,
             args will first be evaluated and their return values passed.
             This is useful for runtime configuration.
     """
+
     def decorate(target):
         nonlocal logger, on_success, on_backoff, on_giveup
 
@@ -215,7 +220,7 @@ def on_exception(wait_gen: _WaitGenerator,
             on_backoff=on_backoff,
             on_giveup=on_giveup,
             raise_on_giveup=raise_on_giveup,
-            wait_gen_kwargs=wait_gen_kwargs
+            wait_gen_kwargs=wait_gen_kwargs,
         )
 
     # Return a function which decorates a target with a retry loop.

backoff/_jitter.py

@@ -1,5 +1,3 @@
-# coding:utf-8
-
 import random
 
 

backoff/_sync.py

@@ -1,42 +1,46 @@
-# coding:utf-8
-import datetime
 import functools
 import time
-from datetime import timedelta
 
-from backoff._common import (_init_wait_gen, _maybe_call, _next_wait)
+from backoff._common import _init_wait_gen, _maybe_call, _next_wait
 
 
 def _call_handlers(hdlrs, target, args, kwargs, tries, elapsed, **extra):
     details = {
-        'target': target,
-        'args': args,
-        'kwargs': kwargs,
-        'tries': tries,
-        'elapsed': elapsed,
+        "target": target,
+        "args": args,
+        "kwargs": kwargs,
+        "tries": tries,
+        "elapsed": elapsed,
     }
     details.update(extra)
     for hdlr in hdlrs:
         hdlr(details)
 
 
-def retry_predicate(target, wait_gen, predicate,
-                    *,
-                    max_tries, max_time, jitter,
-                    on_success, on_backoff, on_giveup,
-                    wait_gen_kwargs):
-
+def retry_predicate(
+    target,
+    wait_gen,
+    predicate,
+    *,
+    max_tries,
+    max_time,
+    jitter,
+    on_success,
+    on_backoff,
+    on_giveup,
+    wait_gen_kwargs,
+):
     @functools.wraps(target)
     def retry(*args, **kwargs):
         max_tries_value = _maybe_call(max_tries)
         max_time_value = _maybe_call(max_time)
 
         tries = 0
-        start = datetime.datetime.now()
+        start = time.monotonic()
         wait = _init_wait_gen(wait_gen, wait_gen_kwargs)
         while True:
             tries += 1
-            elapsed = timedelta.total_seconds(datetime.datetime.now() - start)
+            elapsed = time.monotonic() - start
             details = {
                 "target": target,
                 "args": args,
@@ -47,23 +51,22 @@ def retry_predicate(target, wait_gen, predicate,
 
             ret = target(*args, **kwargs)
             if predicate(ret):
-                max_tries_exceeded = (tries == max_tries_value)
-                max_time_exceeded = (max_time_value is not None and
-                                     elapsed >= max_time_value)
+                max_tries_exceeded = tries == max_tries_value
+                max_time_exceeded = (
+                    max_time_value is not None and elapsed >= max_time_value
+                )
 
                 if max_tries_exceeded or max_time_exceeded:
                     _call_handlers(on_giveup, **details, value=ret)
                     break
 
                 try:
-                    seconds = _next_wait(wait, ret, jitter, elapsed,
-                                         max_time_value)
+                    seconds = _next_wait(wait, ret, jitter, elapsed, max_time_value)
                 except StopIteration:
                     _call_handlers(on_giveup, **details)
                     break
 
-                _call_handlers(on_backoff, **details,
-                               value=ret, wait=seconds)
+                _call_handlers(on_backoff, **details, value=ret, wait=seconds)
 
                 time.sleep(seconds)
                 continue
@@ -76,23 +79,32 @@ def retry_predicate(target, wait_gen, predicate,
     return retry
 
 
-def retry_exception(target, wait_gen, exception,
-                    *,
-                    max_tries, max_time, jitter, giveup,
-                    on_success, on_backoff, on_giveup, raise_on_giveup,
-                    wait_gen_kwargs):
-
+def retry_exception(
+    target,
+    wait_gen,
+    exception,
+    *,
+    max_tries,
+    max_time,
+    jitter,
+    giveup,
+    on_success,
+    on_backoff,
+    on_giveup,
+    raise_on_giveup,
+    wait_gen_kwargs,
+):
     @functools.wraps(target)
     def retry(*args, **kwargs):
         max_tries_value = _maybe_call(max_tries)
         max_time_value = _maybe_call(max_time)
 
         tries = 0
-        start = datetime.datetime.now()
+        start = time.monotonic()
         wait = _init_wait_gen(wait_gen, wait_gen_kwargs)
         while True:
             tries += 1
-            elapsed = timedelta.total_seconds(datetime.datetime.now() - start)
+            elapsed = time.monotonic() - start
             details = {
                 "target": target,
                 "args": args,
@@ -104,9 +116,10 @@ def retry_exception(target, wait_gen, exception,
             try:
                 ret = target(*args, **kwargs)
             except exception as e:
-                max_tries_exceeded = (tries == max_tries_value)
-                max_time_exceeded = (max_time_value is not None and
-                                     elapsed >= max_time_value)
+                max_tries_exceeded = tries == max_tries_value
+                max_time_exceeded = (
+                    max_time_value is not None and elapsed >= max_time_value
+                )
 
                 if giveup(e) or max_tries_exceeded or max_time_exceeded:
                     _call_handlers(on_giveup, **details, exception=e)
@@ -115,18 +128,17 @@ def retry_exception(target, wait_gen, exception,
                     return None
 
                 try:
-                    seconds = _next_wait(wait, e, jitter, elapsed,
-                                         max_time_value)
+                    seconds = _next_wait(wait, e, jitter, elapsed, max_time_value)
                 except StopIteration:
                     _call_handlers(on_giveup, **details, exception=e)
                     raise e
 
-                _call_handlers(on_backoff, **details, wait=seconds,
-                               exception=e)
+                _call_handlers(on_backoff, **details, wait=seconds, exception=e)
 
                 time.sleep(seconds)
             else:
                 _call_handlers(on_success, **details)
 
                 return ret
+
     return retry

backoff/_typing.py

@@ -1,23 +1,21 @@
-# coding:utf-8
 import logging
-import sys
-from typing import (Any, Callable, Coroutine, Dict, Generator, Sequence, Tuple,
-                    TypeVar, Union)
-
-if sys.version_info >= (3, 8):  # pragma: no cover
-    from typing import TypedDict
-else:  # pragma: no cover
-    # use typing_extensions if installed but don't require it
-    try:
-        from typing_extensions import TypedDict
-    except ImportError:
-        class TypedDict(dict):
-            def __init_subclass__(cls, **kwargs: Any) -> None:
-                return super().__init_subclass__()
+from types import FunctionType
+from typing import (
+    Any,
+    Callable,
+    Coroutine,
+    Dict,
+    Generator,
+    Sequence,
+    Tuple,
+    TypedDict,
+    TypeVar,
+    Union,
+)
 
 
 class _Details(TypedDict):
-    target: Callable[..., Any]
+    target: FunctionType
     args: Tuple[Any, ...]
     kwargs: Dict[str, Any]
     tries: int
@@ -32,7 +30,7 @@ class Details(_Details, total=False):
 
 T = TypeVar("T")
 
-_CallableT = TypeVar('_CallableT', bound=Callable[..., Any])
+_CallableT = TypeVar("_CallableT", bound=Callable[..., Any])
 _Handler = Union[
     Callable[[Details], None],
     Callable[[Details], Coroutine[Any, Any, None]],

backoff/_wait_gen.py

@@ -1,5 +1,3 @@
-# coding:utf-8
-
 import itertools
 import math
 from typing import Any, Callable, Generator, Iterable, Optional, Union
@@ -8,9 +6,8 @@ from typing import Any, Callable, Generator, Iterable, Optional, Union
 def expo(
     base: float = 2,
     factor: float = 1,
-    max_value: Optional[float] = None
+    max_value: Optional[float] = None,
 ) -> Generator[float, Any, None]:
-
     """Generator for exponential decay.
 
     Args:
@@ -22,12 +19,12 @@ def expo(
     """
     # Advance past initial .send() call
     yield  # type: ignore[misc]
-    n = 0
+    base_n: float = 1
     while True:
-        a = factor * base ** n
+        a = factor * base_n
         if max_value is None or a < max_value:
             yield a
-            n += 1
+            base_n *= base
         else:
             yield max_value
 
@@ -35,9 +32,8 @@ def expo(
 def decay(
     initial_value: float = 1,
     decay_factor: float = 1,
-    min_value: Optional[float] = None
+    min_value: Optional[float] = None,
 ) -> Generator[float, Any, None]:
-
     """Generator for exponential decay[1]:
 
     Args:
@@ -83,7 +79,7 @@ def fibo(max_value: Optional[int] = None) -> Generator[int, None, None]:
 
 
 def constant(
-    interval: Union[int, Iterable[float]] = 1
+    interval: Union[int, Iterable[float]] = 1,
 ) -> Generator[float, None, None]:
     """Generator for constant intervals.
 
@@ -104,7 +100,7 @@ def constant(
 
 def runtime(
     *,
-    value: Callable[[Any], float]
+    value: Callable[[Any], float],
 ) -> Generator[float, None, None]:
     """Generator that is based on parsing the return value or thrown
         exception of the decorated method

backoff/types.py

@@ -1,6 +1,5 @@
-# coding:utf-8
 from ._typing import Details
 
 __all__ = [
-    'Details'
+    "Details",
 ]

{python_backoff-2.2.2rc2.dist-info → python_backoff-2.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-backoff
-Version: 2.2.2rc2
+Version: 2.3.1
 Summary: Function decoration for backoff and retry
 Project-URL: Documentation, https://python-backoff.github.io/backoff
 Project-URL: Repository, https://github.com/python-backoff/backoff
@@ -16,7 +16,6 @@ Classifier: Natural Language :: English
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.7
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
@@ -28,7 +27,7 @@ Classifier: Programming Language :: Python :: 3.15
 Classifier: Topic :: Internet :: WWW/HTTP
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Utilities
-Requires-Python: >=3.7
+Requires-Python: >=3.8
 Description-Content-Type: text/x-rst
 
 backoff
@@ -59,7 +58,7 @@ for asynchronous code.
 Examples
 ========
 
-Since Kenneth Reitz's `requests <http://python-requests.org>`_ module
+Since Kenneth Reitz's `requests <https://requests.readthedocs.io>`_ module
 has become a defacto standard for synchronous HTTP clients in Python,
 networking examples below are written using it, but it is in no way required
 by the backoff module.
@@ -73,8 +72,10 @@ is raised. Here's an example using exponential backoff when any
 
 .. code-block:: python
 
-    @backoff.on_exception(backoff.expo,
-                          requests.exceptions.RequestException)
+    @backoff.on_exception(
+        backoff.expo,
+        requests.exceptions.RequestException,
+    )
     def get_url(url):
         return requests.get(url)
 
@@ -83,9 +84,13 @@ the same backoff behavior is desired for more than one exception type:
 
 .. code-block:: python
 
-    @backoff.on_exception(backoff.expo,
-                          (requests.exceptions.Timeout,
-                           requests.exceptions.ConnectionError))
+    @backoff.on_exception(
+        backoff.expo,
+        (
+            requests.exceptions.Timeout,
+            requests.exceptions.ConnectionError,
+        ),
+    )
     def get_url(url):
         return requests.get(url)
 
@@ -99,9 +104,11 @@ of total time in seconds that can elapse before giving up.
 
 .. code-block:: python
 
-    @backoff.on_exception(backoff.expo,
-                          requests.exceptions.RequestException,
-                          max_time=60)
+    @backoff.on_exception(
+        backoff.expo,
+        requests.exceptions.RequestException,
+        max_time=60,
+    )
     def get_url(url):
         return requests.get(url)
 
@@ -111,10 +118,12 @@ to make to the target function before giving up.
 
 .. code-block:: python
 
-    @backoff.on_exception(backoff.expo,
-                          requests.exceptions.RequestException,
-                          max_tries=8,
-                          jitter=None)
+    @backoff.on_exception(
+        backoff.expo,
+        requests.exceptions.RequestException,
+        max_tries=8,
+        jitter=None,
+    )
     def get_url(url):
         return requests.get(url)
 
@@ -130,10 +139,13 @@ be retried:
     def fatal_code(e):
         return 400 <= e.response.status_code < 500
 
-    @backoff.on_exception(backoff.expo,
-                          requests.exceptions.RequestException,
-                          max_time=300,
-                          giveup=fatal_code)
+
+    @backoff.on_exception(
+        backoff.expo,
+        requests.exceptions.RequestException,
+        max_time=300,
+        giveup=fatal_code,
+    )
     def get_url(url):
         return requests.get(url)
 
@@ -151,11 +163,14 @@ case, regardless of the logic in the `on_exception` handler.
     def fatal_code(e):
         return 400 <= e.response.status_code < 500
 
-    @backoff.on_exception(backoff.expo,
-                          requests.exceptions.RequestException,
-                          max_time=300,
-                          raise_on_giveup=False,
-                          giveup=fatal_code)
+
+    @backoff.on_exception(
+        backoff.expo,
+        requests.exceptions.RequestException,
+        max_time=300,
+        raise_on_giveup=False,
+        giveup=fatal_code,
+    )
     def get_url(url):
         return requests.get(url)
 
@@ -175,7 +190,11 @@ return value of the target function is the empty list:
 
 .. code-block:: python
 
-    @backoff.on_predicate(backoff.fibo, lambda x: x == [], max_value=13)
+    @backoff.on_predicate(
+        backoff.fibo,
+        lambda x: x == [],
+        max_value=13,
+    )
     def poll_for_messages(queue):
         return queue.get()
 
@@ -197,11 +216,15 @@ gets a non-falsey result could be defined like like this:
 
 .. code-block:: python
 
-    @backoff.on_predicate(backoff.constant, jitter=None, interval=1)
+    @backoff.on_predicate(
+        backoff.constant,
+        jitter=None,
+        interval=1,
+    )
     def poll_for_message(queue):
         return queue.get()
 
-The jitter is disabled in order to keep the polling frequency fixed.  
+The jitter is disabled in order to keep the polling frequency fixed.
 
 @backoff.runtime
 ----------------
@@ -250,12 +273,16 @@ backoff behavior for different cases:
 .. code-block:: python
 
     @backoff.on_predicate(backoff.fibo, max_value=13)
-    @backoff.on_exception(backoff.expo,
-                          requests.exceptions.HTTPError,
-                          max_time=60)
-    @backoff.on_exception(backoff.expo,
-                          requests.exceptions.Timeout,
-                          max_time=300)
+    @backoff.on_exception(
+        backoff.expo,
+        requests.exceptions.HTTPError,
+        max_time=60,
+    )
+    @backoff.on_exception(
+        backoff.expo,
+        requests.exceptions.Timeout,
+        max_time=300,
+    )
     def poll_for_message(queue):
         return queue.get()
 
@@ -278,9 +305,13 @@ runtime to obtain the value:
         # and that it has a dictionary-like 'config' property
         return app.config["BACKOFF_MAX_TIME"]
 
-    @backoff.on_exception(backoff.expo,
-                          ValueError,
-                          max_time=lookup_max_time)
+
+    @backoff.on_exception(
+        backoff.expo,
+        ValueError,
+        max_time=lookup_max_time,
+    )
+    def my_function(): ...
 
 Event handlers
 --------------
@@ -308,13 +339,18 @@ implemented like so:
 .. code-block:: python
 
     def backoff_hdlr(details):
-        print ("Backing off {wait:0.1f} seconds after {tries} tries "
-               "calling function {target} with args {args} and kwargs "
-               "{kwargs}".format(**details))
+        print(
+            "Backing off {wait:0.1f} seconds after {tries} tries "
+            "calling function {target} with args {args} and kwargs "
+            "{kwargs}".format(**details)
+        )
+
 
-    @backoff.on_exception(backoff.expo,
-                          requests.exceptions.RequestException,
-                          on_backoff=backoff_hdlr)
+    @backoff.on_exception(
+        backoff.expo,
+        requests.exceptions.RequestException,
+        on_backoff=backoff_hdlr,
+    )
     def get_url(url):
         return requests.get(url)
 
@@ -326,9 +362,14 @@ handler functions as the value of the ``on_backoff`` keyword arg:
 
 .. code-block:: python
 
-    @backoff.on_exception(backoff.expo,
-                          requests.exceptions.RequestException,
-                          on_backoff=[backoff_hdlr1, backoff_hdlr2])
+    @backoff.on_exception(
+        backoff.expo,
+        requests.exceptions.RequestException,
+        on_backoff=[
+            backoff_hdlr1,
+            backoff_hdlr2,
+        ],
+    )
     def get_url(url):
         return requests.get(url)
 
@@ -359,9 +400,13 @@ asynchronous HTTP client/server library.
 
 .. code-block:: python
 
-    @backoff.on_exception(backoff.expo, aiohttp.ClientError, max_time=60)
+    @backoff.on_exception(
+        backoff.expo,
+        aiohttp.ClientError,
+        max_time=60,
+    )
     async def get_url(url):
-        async with aiohttp.ClientSession(raise_for_status=True) as session:
+        async with aiohttp.ClientSession(raise_for_status=True) as session:  # noqa: SIM117
             async with session.get(url) as response:
                 return await response.text()
 
@@ -376,7 +421,7 @@ as:
 
 .. code-block:: python
 
-    logging.getLogger('backoff').addHandler(logging.StreamHandler())
+    logging.getLogger("backoff").addHandler(logging.StreamHandler())
 
 The default logging level is INFO, which corresponds to logging
 anytime a retry event occurs. If you would instead like to log
@@ -384,7 +429,7 @@ only when a giveup event occurs, set the logger level to ERROR.
 
 .. code-block:: python
 
-    logging.getLogger('backoff').setLevel(logging.ERROR)
+    logging.getLogger("backoff").setLevel(logging.ERROR)
 
 It is also possible to specify an alternate logger with the ``logger``
 keyword argument.  If a string value is specified the logger will be
@@ -392,25 +437,30 @@ looked up by name.
 
 .. code-block:: python
 
-   @backoff.on_exception(backoff.expo,
-                         requests.exceptions.RequestException,
-			 logger='my_logger')
-   # ...
+    @backoff.on_exception(
+        backoff.expo,
+        requests.exceptions.RequestException,
+        logger="my_logger",
+    )
+    def my_function(): ...
 
 It is also supported to specify a Logger (or LoggerAdapter) object
 directly.
 
 .. code-block:: python
 
-    my_logger = logging.getLogger('my_logger')
+    my_logger = logging.getLogger("my_logger")
     my_handler = logging.StreamHandler()
     my_logger.addHandler(my_handler)
     my_logger.setLevel(logging.ERROR)
 
-    @backoff.on_exception(backoff.expo,
-                          requests.exceptions.RequestException,
-			  logger=my_logger)
-    # ...
+
+    @backoff.on_exception(
+        backoff.expo,
+        requests.exceptions.RequestException,
+        logger=my_logger,
+    )
+    def my_function(): ...
 
 Default logging can be disabled all together by specifying
 ``logger=None``. In this case, if desired alternative logging behavior

python_backoff-2.3.1.dist-info/RECORD

@@ -0,0 +1,14 @@
+backoff/__init__.py,sha256=MS4ieVYpjBh-feDqzJHYJy8mjnuEEaprTWWuXgJI-1A,914
+backoff/_async.py,sha256=Ehv3H3jMF9JylzZzHTLSLwK_s0PoJa_1jeGo3qtpcOY,6370
+backoff/_common.py,sha256=Q8ZB8mCMI76WLii8JcrfoSZc11WRqu7ci_mpG1y-j9Y,3460
+backoff/_decorator.py,sha256=61iXFb5jN2mQ9-1mtRPi_gysJwuyhkKrbDVNWH8GDxo,9483
+backoff/_jitter.py,sha256=wzQHBDNuYg7owbc3fcZLOr5uhhRgqiuncU5rIYOB9lY,766
+backoff/_sync.py,sha256=7W0aTlntrL237rfhy2yaFklZheQoYxBTD5F_4TUarQI,3867
+backoff/_typing.py,sha256=hO065un_HjJEsEa_OgW66JZRyxVf-BsJ9HrswIwW3fA,1056
+backoff/_wait_gen.py,sha256=ZTZfs4WiI295EvOJeJYPIUAABQ0WBAKcvUtg0_ZId8k,3244
+backoff/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+backoff/types.py,sha256=rOQAfuetqVwfEIuzVvK5D_w97A3wrZ9lQ8HwuJ_uq5s,59
+python_backoff-2.3.1.dist-info/METADATA,sha256=o7ltpQ3fk4s05tUCVIeUgZVzGFfigmw06jNoz6HM6RI,14885
+python_backoff-2.3.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+python_backoff-2.3.1.dist-info/licenses/LICENSE,sha256=KmtNX4hNTXob8E6n3xlEzxKzLjWnmobQoHWi0_QPuaw,1077
+python_backoff-2.3.1.dist-info/RECORD,,

{python_backoff-2.2.2rc2.dist-info → python_backoff-2.3.1.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.27.0
+Generator: hatchling 1.28.0
 Root-Is-Purelib: true
 Tag: py3-none-any

python_backoff-2.2.2rc2.dist-info/RECORD

@@ -1,14 +0,0 @@
-backoff/__init__.py,sha256=cxmsrw6PUsF2VsUnaX-gyKsJ5If3iKVIKoVU5Fg2njc,928
-backoff/_async.py,sha256=gX-MFZWs1-6dyUsohHtJxAP_Zg0if5n8MSmHyNFTB5I,6790
-backoff/_common.py,sha256=8s3_5AJH8hiHd9GR2PdKqiaeE2sdEUoyf6cW9OCo1F8,3478
-backoff/_decorator.py,sha256=Vx9IlrmA22tjNgo-YN4FHqcC0W54wL-4Ug4dTdjUHZ8,9815
-backoff/_jitter.py,sha256=LjJShpjryk9sWBCWiz-3UX1DJCx6rebNJ5Bf3nPMlYQ,782
-backoff/_sync.py,sha256=DT_ktufPPb0nut9WCAKe5UE7sTYRl9f93PRPX6jP8ro,4214
-backoff/_typing.py,sha256=K4xjbkoQUuKt5E1cEAUgIPrhrV2lWD3BXmgu8_Mv7rQ,1422
-backoff/_wait_gen.py,sha256=hObFPeXDXdzcvMhkknya3nlSKYoCAMT5LFoto25emuI,3241
-backoff/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-backoff/types.py,sha256=4DGG6Ltcz0wVfXrk0YBOnp_oPpcki4c0BOnodRhgoqg,73
-python_backoff-2.2.2rc2.dist-info/METADATA,sha256=ArUoHM1YP6T5LHwR_SJ5s9FyZgOjVp6XE96xVYWrKwE,14965
-python_backoff-2.2.2rc2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-python_backoff-2.2.2rc2.dist-info/licenses/LICENSE,sha256=KmtNX4hNTXob8E6n3xlEzxKzLjWnmobQoHWi0_QPuaw,1077
-python_backoff-2.2.2rc2.dist-info/RECORD,,