support async sleep for sync fn

Author: Zac-HD

releasenotes/notes/async-sleep-retrying-32de5866f5d041.yaml

@@ -0,0 +1,7 @@
+---
+fixes:
+  - |
+    Passing an async ``sleep`` callable (e.g. ``trio.sleep``) to ``@retry``
+    now correctly uses ``AsyncRetrying``, even when the decorated function is
+    synchronous. Previously, the async sleep would silently not be awaited,
+    resulting in no delay between retries.

tenacity/__init__.py

@@ -89,13 +89,16 @@
 if t.TYPE_CHECKING:
     import types
 
-    from typing_extensions import Self
+    from typing_extensions import ParamSpec, Self
 
     from . import asyncio as tasyncio
     from .retry import RetryBaseT
     from .stop import StopBaseT
     from .wait import WaitBaseT
 
+    P = ParamSpec("P")
+    R = t.TypeVar("R")
+
 
 WrappedFnReturnT = t.TypeVar("WrappedFnReturnT")
 WrappedFn = t.TypeVar("WrappedFn", bound=t.Callable[..., t.Any])
@@ -600,7 +603,29 @@ def retry(func: WrappedFn) -> WrappedFn: ...
 
 @t.overload
 def retry(
-    sleep: t.Callable[[t.Union[int, float]], t.Union[None, t.Awaitable[None]]] = sleep,
+    *,
+    sleep: t.Callable[[t.Union[int, float]], t.Awaitable[None]],
+    stop: "StopBaseT" = ...,
+    wait: "WaitBaseT" = ...,
+    retry: "t.Union[RetryBaseT, tasyncio.retry.RetryBaseT]" = ...,
+    before: t.Callable[["RetryCallState"], t.Union[None, t.Awaitable[None]]] = ...,
+    after: t.Callable[["RetryCallState"], t.Union[None, t.Awaitable[None]]] = ...,
+    before_sleep: t.Optional[
+        t.Callable[["RetryCallState"], t.Union[None, t.Awaitable[None]]]
+    ] = ...,
+    reraise: bool = ...,
+    retry_error_cls: t.Type["RetryError"] = ...,
+    retry_error_callback: t.Optional[
+        t.Callable[["RetryCallState"], t.Union[t.Any, t.Awaitable[t.Any]]]
+    ] = ...,
+) -> (
+    "t.Callable[[t.Callable[P, R | t.Awaitable[R]]], t.Callable[P, t.Awaitable[R]]]"
+): ...
+
+
+@t.overload
+def retry(
+    sleep: t.Callable[[t.Union[int, float]], None] = sleep,
     stop: "StopBaseT" = stop_never,
     wait: "WaitBaseT" = wait_none(),
     retry: "t.Union[RetryBaseT, tasyncio.retry.RetryBaseT]" = retry_if_exception_type(),
@@ -639,7 +664,9 @@ def wrap(f: WrappedFn) -> WrappedFn:
                     f"this will probably hang indefinitely (did you mean retry={f.__class__.__name__}(...)?)"
                 )
             r: "BaseRetrying"
-            if _utils.is_coroutine_callable(f):
+            if _utils.is_coroutine_callable(f) or _utils.is_coroutine_callable(
+                dkw.get("sleep")
+            ):
                 r = AsyncRetrying(*dargs, **dkw)
             elif (
                 tornado

tenacity/asyncio/__init__.py

@@ -107,11 +107,15 @@ async def __call__(  # type: ignore[override]
         self.begin()
 
         retry_state = RetryCallState(retry_object=self, fn=fn, args=args, kwargs=kwargs)
+        is_async = _utils.is_coroutine_callable(fn)
         while True:
             do = await self.iter(retry_state=retry_state)
             if isinstance(do, DoAttempt):
                 try:
-                    result = await fn(*args, **kwargs)
+                    if is_async:
+                        result = await fn(*args, **kwargs)
+                    else:
+                        result = fn(*args, **kwargs)
                 except BaseException:  # noqa: B902
                     retry_state.set_exception(sys.exc_info())  # type: ignore[arg-type]
                 else:

tests/test_asyncio.py

@@ -34,7 +34,11 @@
 from tenacity import retry, retry_if_exception, retry_if_result, stop_after_attempt
 from tenacity.wait import wait_fixed
 
-from .test_tenacity import NoIOErrorAfterCount, current_time_ms
+from .test_tenacity import (
+    NoIOErrorAfterCount,
+    NoneReturnUntilAfterCount,
+    current_time_ms,
+)
 
 
 def asynctest(callable_):
@@ -463,5 +467,26 @@ async def foo():
     pass
 
 
+class TestSyncFunctionWithAsyncSleep(unittest.TestCase):
+    @asynctest
+    async def test_sync_function_with_async_sleep(self):
+        """A sync function with an async sleep callable uses AsyncRetrying."""
+        mock_sleep = mock.AsyncMock()
+
+        thing = NoneReturnUntilAfterCount(2)
+
+        @retry(
+            sleep=mock_sleep,
+            wait=wait_fixed(1),
+            retry=retry_if_result(lambda x: x is None),
+        )
+        def sync_function():
+            return thing.go()
+
+        result = await sync_function()
+        assert result is True
+        assert mock_sleep.await_count == 2
+
+
 if __name__ == "__main__":
     unittest.main()