tenacity 8.4.0__py3-none-any.whl → 8.4.2__py3-none-any.whl

tenacity/__init__.py

@@ -329,13 +329,19 @@ class BaseRetrying(ABC):
             f, functools.WRAPPER_ASSIGNMENTS + ("__defaults__", "__kwdefaults__")
         )
         def wrapped_f(*args: t.Any, **kw: t.Any) -> t.Any:
-            return self(f, *args, **kw)
+            # Always create a copy to prevent overwriting the local contexts when
+            # calling the same wrapped functions multiple times in the same stack
+            copy = self.copy()
+            wrapped_f.statistics = copy.statistics  # type: ignore[attr-defined]
+            return copy(f, *args, **kw)
 
         def retry_with(*args: t.Any, **kwargs: t.Any) -> WrappedFn:
             return self.copy(*args, **kwargs).wraps(f)
 
-        wrapped_f.retry = self  # type: ignore[attr-defined]
+        # Preserve attributes
+        wrapped_f.retry = wrapped_f  # type: ignore[attr-defined]
         wrapped_f.retry_with = retry_with  # type: ignore[attr-defined]
+        wrapped_f.statistics = {}  # type: ignore[attr-defined]
 
         return wrapped_f  # type: ignore[return-value]
 

tenacity/asyncio/__init__.py

@@ -0,0 +1,206 @@
+# Copyright 2016 Étienne Bersac
+# Copyright 2016 Julien Danjou
+# Copyright 2016 Joshua Harlow
+# Copyright 2013-2014 Ray Holder
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import functools
+import sys
+import typing as t
+
+import tenacity
+from tenacity import AttemptManager
+from tenacity import BaseRetrying
+from tenacity import DoAttempt
+from tenacity import DoSleep
+from tenacity import RetryCallState
+from tenacity import RetryError
+from tenacity import after_nothing
+from tenacity import before_nothing
+from tenacity import _utils
+
+# Import all built-in retry strategies for easier usage.
+from .retry import RetryBaseT
+from .retry import retry_all  # noqa
+from .retry import retry_any  # noqa
+from .retry import retry_if_exception  # noqa
+from .retry import retry_if_result  # noqa
+from ..retry import RetryBaseT as SyncRetryBaseT
+
+if t.TYPE_CHECKING:
+    from tenacity.stop import StopBaseT
+    from tenacity.wait import WaitBaseT
+
+WrappedFnReturnT = t.TypeVar("WrappedFnReturnT")
+WrappedFn = t.TypeVar("WrappedFn", bound=t.Callable[..., t.Awaitable[t.Any]])
+
+
+def _portable_async_sleep(seconds: float) -> t.Awaitable[None]:
+    # If trio is already imported, then importing it is cheap.
+    # If trio isn't already imported, then it's definitely not running, so we
+    # can skip further checks.
+    if "trio" in sys.modules:
+        # If trio is available, then sniffio is too
+        import trio
+        import sniffio
+
+        if sniffio.current_async_library() == "trio":
+            return trio.sleep(seconds)
+    # Otherwise, assume asyncio
+    # Lazy import asyncio as it's expensive (responsible for 25-50% of total import overhead).
+    import asyncio
+
+    return asyncio.sleep(seconds)
+
+
+class AsyncRetrying(BaseRetrying):
+    def __init__(
+        self,
+        sleep: t.Callable[
+            [t.Union[int, float]], t.Union[None, t.Awaitable[None]]
+        ] = _portable_async_sleep,
+        stop: "StopBaseT" = tenacity.stop.stop_never,
+        wait: "WaitBaseT" = tenacity.wait.wait_none(),
+        retry: "t.Union[SyncRetryBaseT, RetryBaseT]" = tenacity.retry_if_exception_type(),
+        before: t.Callable[
+            ["RetryCallState"], t.Union[None, t.Awaitable[None]]
+        ] = before_nothing,
+        after: t.Callable[
+            ["RetryCallState"], t.Union[None, t.Awaitable[None]]
+        ] = after_nothing,
+        before_sleep: t.Optional[
+            t.Callable[["RetryCallState"], t.Union[None, t.Awaitable[None]]]
+        ] = None,
+        reraise: bool = False,
+        retry_error_cls: t.Type["RetryError"] = RetryError,
+        retry_error_callback: t.Optional[
+            t.Callable[["RetryCallState"], t.Union[t.Any, t.Awaitable[t.Any]]]
+        ] = None,
+    ) -> None:
+        super().__init__(
+            sleep=sleep,  # type: ignore[arg-type]
+            stop=stop,
+            wait=wait,
+            retry=retry,  # type: ignore[arg-type]
+            before=before,  # type: ignore[arg-type]
+            after=after,  # type: ignore[arg-type]
+            before_sleep=before_sleep,  # type: ignore[arg-type]
+            reraise=reraise,
+            retry_error_cls=retry_error_cls,
+            retry_error_callback=retry_error_callback,
+        )
+
+    async def __call__(  # type: ignore[override]
+        self, fn: WrappedFn, *args: t.Any, **kwargs: t.Any
+    ) -> WrappedFnReturnT:
+        self.begin()
+
+        retry_state = RetryCallState(retry_object=self, fn=fn, args=args, kwargs=kwargs)
+        while True:
+            do = await self.iter(retry_state=retry_state)
+            if isinstance(do, DoAttempt):
+                try:
+                    result = await fn(*args, **kwargs)
+                except BaseException:  # noqa: B902
+                    retry_state.set_exception(sys.exc_info())  # type: ignore[arg-type]
+                else:
+                    retry_state.set_result(result)
+            elif isinstance(do, DoSleep):
+                retry_state.prepare_for_next_attempt()
+                await self.sleep(do)  # type: ignore[misc]
+            else:
+                return do  # type: ignore[no-any-return]
+
+    def _add_action_func(self, fn: t.Callable[..., t.Any]) -> None:
+        self.iter_state.actions.append(_utils.wrap_to_async_func(fn))
+
+    async def _run_retry(self, retry_state: "RetryCallState") -> None:  # type: ignore[override]
+        self.iter_state.retry_run_result = await _utils.wrap_to_async_func(self.retry)(
+            retry_state
+        )
+
+    async def _run_wait(self, retry_state: "RetryCallState") -> None:  # type: ignore[override]
+        if self.wait:
+            sleep = await _utils.wrap_to_async_func(self.wait)(retry_state)
+        else:
+            sleep = 0.0
+
+        retry_state.upcoming_sleep = sleep
+
+    async def _run_stop(self, retry_state: "RetryCallState") -> None:  # type: ignore[override]
+        self.statistics["delay_since_first_attempt"] = retry_state.seconds_since_start
+        self.iter_state.stop_run_result = await _utils.wrap_to_async_func(self.stop)(
+            retry_state
+        )
+
+    async def iter(
+        self, retry_state: "RetryCallState"
+    ) -> t.Union[DoAttempt, DoSleep, t.Any]:  # noqa: A003
+        self._begin_iter(retry_state)
+        result = None
+        for action in self.iter_state.actions:
+            result = await action(retry_state)
+        return result
+
+    def __iter__(self) -> t.Generator[AttemptManager, None, None]:
+        raise TypeError("AsyncRetrying object is not iterable")
+
+    def __aiter__(self) -> "AsyncRetrying":
+        self.begin()
+        self._retry_state = RetryCallState(self, fn=None, args=(), kwargs={})
+        return self
+
+    async def __anext__(self) -> AttemptManager:
+        while True:
+            do = await self.iter(retry_state=self._retry_state)
+            if do is None:
+                raise StopAsyncIteration
+            elif isinstance(do, DoAttempt):
+                return AttemptManager(retry_state=self._retry_state)
+            elif isinstance(do, DoSleep):
+                self._retry_state.prepare_for_next_attempt()
+                await self.sleep(do)  # type: ignore[misc]
+            else:
+                raise StopAsyncIteration
+
+    def wraps(self, fn: WrappedFn) -> WrappedFn:
+        wrapped = super().wraps(fn)
+        # Ensure wrapper is recognized as a coroutine function.
+
+        @functools.wraps(
+            fn, functools.WRAPPER_ASSIGNMENTS + ("__defaults__", "__kwdefaults__")
+        )
+        async def async_wrapped(*args: t.Any, **kwargs: t.Any) -> t.Any:
+            # Always create a copy to prevent overwriting the local contexts when
+            # calling the same wrapped functions multiple times in the same stack
+            copy = self.copy()
+            async_wrapped.statistics = copy.statistics  # type: ignore[attr-defined]
+            return await copy(fn, *args, **kwargs)
+
+        # Preserve attributes
+        async_wrapped.retry = async_wrapped  # type: ignore[attr-defined]
+        async_wrapped.retry_with = wrapped.retry_with  # type: ignore[attr-defined]
+        async_wrapped.statistics = {}  # type: ignore[attr-defined]
+
+        return async_wrapped  # type: ignore[return-value]
+
+
+__all__ = [
+    "retry_all",
+    "retry_any",
+    "retry_if_exception",
+    "retry_if_result",
+    "WrappedFn",
+    "AsyncRetrying",
+]

tenacity/asyncio/retry.py

@@ -0,0 +1,125 @@
+# Copyright 2016–2021 Julien Danjou
+# Copyright 2016 Joshua Harlow
+# Copyright 2013-2014 Ray Holder
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import abc
+import typing
+
+from tenacity import _utils
+from tenacity import retry_base
+
+if typing.TYPE_CHECKING:
+    from tenacity import RetryCallState
+
+
+class async_retry_base(retry_base):
+    """Abstract base class for async retry strategies."""
+
+    @abc.abstractmethod
+    async def __call__(self, retry_state: "RetryCallState") -> bool:  # type: ignore[override]
+        pass
+
+    def __and__(  # type: ignore[override]
+        self, other: "typing.Union[retry_base, async_retry_base]"
+    ) -> "retry_all":
+        return retry_all(self, other)
+
+    def __rand__(  # type: ignore[misc,override]
+        self, other: "typing.Union[retry_base, async_retry_base]"
+    ) -> "retry_all":
+        return retry_all(other, self)
+
+    def __or__(  # type: ignore[override]
+        self, other: "typing.Union[retry_base, async_retry_base]"
+    ) -> "retry_any":
+        return retry_any(self, other)
+
+    def __ror__(  # type: ignore[misc,override]
+        self, other: "typing.Union[retry_base, async_retry_base]"
+    ) -> "retry_any":
+        return retry_any(other, self)
+
+
+RetryBaseT = typing.Union[
+    async_retry_base, typing.Callable[["RetryCallState"], typing.Awaitable[bool]]
+]
+
+
+class retry_if_exception(async_retry_base):
+    """Retry strategy that retries if an exception verifies a predicate."""
+
+    def __init__(
+        self, predicate: typing.Callable[[BaseException], typing.Awaitable[bool]]
+    ) -> None:
+        self.predicate = predicate
+
+    async def __call__(self, retry_state: "RetryCallState") -> bool:  # type: ignore[override]
+        if retry_state.outcome is None:
+            raise RuntimeError("__call__() called before outcome was set")
+
+        if retry_state.outcome.failed:
+            exception = retry_state.outcome.exception()
+            if exception is None:
+                raise RuntimeError("outcome failed but the exception is None")
+            return await self.predicate(exception)
+        else:
+            return False
+
+
+class retry_if_result(async_retry_base):
+    """Retries if the result verifies a predicate."""
+
+    def __init__(
+        self, predicate: typing.Callable[[typing.Any], typing.Awaitable[bool]]
+    ) -> None:
+        self.predicate = predicate
+
+    async def __call__(self, retry_state: "RetryCallState") -> bool:  # type: ignore[override]
+        if retry_state.outcome is None:
+            raise RuntimeError("__call__() called before outcome was set")
+
+        if not retry_state.outcome.failed:
+            return await self.predicate(retry_state.outcome.result())
+        else:
+            return False
+
+
+class retry_any(async_retry_base):
+    """Retries if any of the retries condition is valid."""
+
+    def __init__(self, *retries: typing.Union[retry_base, async_retry_base]) -> None:
+        self.retries = retries
+
+    async def __call__(self, retry_state: "RetryCallState") -> bool:  # type: ignore[override]
+        result = False
+        for r in self.retries:
+            result = result or await _utils.wrap_to_async_func(r)(retry_state)
+            if result:
+                break
+        return result
+
+
+class retry_all(async_retry_base):
+    """Retries if all the retries condition are valid."""
+
+    def __init__(self, *retries: typing.Union[retry_base, async_retry_base]) -> None:
+        self.retries = retries
+
+    async def __call__(self, retry_state: "RetryCallState") -> bool:  # type: ignore[override]
+        result = True
+        for r in self.retries:
+            result = result and await _utils.wrap_to_async_func(r)(retry_state)
+            if not result:
+                break
+        return result

{tenacity-8.4.0.dist-info → tenacity-8.4.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tenacity
-Version: 8.4.0
+Version: 8.4.2
 Summary: Retry code until it succeeds
 Home-page: https://github.com/jd/tenacity
 Author: Julien Danjou

{tenacity-8.4.0.dist-info → tenacity-8.4.2.dist-info}/RECORD

@@ -1,4 +1,4 @@
-tenacity/__init__.py,sha256=dT216tDrncc6QKV6_1AfuhzmCMfUzM_hIwW34ivIRsQ,23651
+tenacity/__init__.py,sha256=_KlyQOzUwzhJeW9qH-_hoyFzV-AZ_aRg2f5qei8o_0I,24026
 tenacity/_utils.py,sha256=5AwPoFrGOIfPkCtqeJdFBi7KKQNcJXJ3erbtGOXtn6w,2916
 tenacity/after.py,sha256=NR4rGyslG7xF1hDJZb2Wf8wVApafX0HZwz2nFVLvaqE,1658
 tenacity/before.py,sha256=7zDTpZ3b6rkY9sOdS-qbpjBgSjVr3xBqcIqdYAh9ZKM,1544
@@ -9,8 +9,10 @@ tenacity/retry.py,sha256=PVnZfXBeLN2DzsytKexw23SPLn82AdZfFPC2OhVQ_1Y,8986
 tenacity/stop.py,sha256=wQuwGfCLw8OH1C3x0G9lH9xtJCyhgviePQ40HRAUg54,4113
 tenacity/tornadoweb.py,sha256=vS1ONfPYoGzPx1asQaVbfoo6D9tPIzSysJipm61Yqw8,2125
 tenacity/wait.py,sha256=Q9XoZCtFra53aQOyfABpvRDuUeB-NpUUXImHsUiRQI0,8042
-tenacity-8.4.0.dist-info/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
-tenacity-8.4.0.dist-info/METADATA,sha256=rnsKmqyLFhyN5Ydqjehhxuls6kPQ27yu6M4l2t5WeuM,1155
-tenacity-8.4.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-tenacity-8.4.0.dist-info/top_level.txt,sha256=Zf8AOZMN7hr1EEcUo9U5KzXsM4TOC1pBZ22D8913JYs,9
-tenacity-8.4.0.dist-info/RECORD,,
+tenacity/asyncio/__init__.py,sha256=SWnrZkyPTvQHvhTAcPVTLCT3LVxg5ICzhUcyt5tMxsE,7782
+tenacity/asyncio/retry.py,sha256=ymu8F1JfAerc5vDO0V4-2kCvHXqyce2jpO1Nlt6aKxI,4244
+tenacity-8.4.2.dist-info/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
+tenacity-8.4.2.dist-info/METADATA,sha256=lEJwjb1dtrlcvg7A-aGxccyqNws7q-sROWoF_1U_O44,1155
+tenacity-8.4.2.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+tenacity-8.4.2.dist-info/top_level.txt,sha256=Zf8AOZMN7hr1EEcUo9U5KzXsM4TOC1pBZ22D8913JYs,9
+tenacity-8.4.2.dist-info/RECORD,,