backon 3.3.0__tar.gz → 3.4.0__tar.gz

{backon-3.3.0 → backon-3.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: backon
-Version: 3.3.0
+Version: 3.4.0
 Summary: Function decoration for backoff and retry
 Keywords: retry,backoff,decorators
 Author-Email: Llucs <c307lucas@gmail.com>

{backon-3.3.0 → backon-3.4.0}/backon/__init__.py

@@ -25,7 +25,7 @@ from backon._conditions import (
 from backon._decorator import on_exception, on_predicate
 from backon._jitter import full_jitter, random_jitter
 from backon._retry import Retrying, retry, sleep_using_event
-from backon._state import RetryError, RetryState, TryAgain
+from backon._state import RetryCallState, RetryError, RetryState, TryAgain
 from backon._wait_gen import (
     constant,
     decay,
@@ -66,6 +66,7 @@ __all__ = [
     "TryAgain",
     "RetryError",
     "RetryState",
+    "RetryCallState",
     "Stop",
     "RetryCondition",
     "stop_after_attempt",

{backon-3.3.0 → backon-3.4.0}/backon/_decorator.py

@@ -54,10 +54,13 @@ def on_predicate(
     retry_error_callback: Callable[[dict], Any] | None = None,
     raise_on_giveup: bool = True,
     sleep: Callable[[float], Any] | None = None,
+    before: _Handler | Iterable[_Handler] | None = None,
+    after: _Handler | Iterable[_Handler] | None = None,
     **wait_gen_kwargs: Any,
 ) -> Callable[[Callable[P, R]], Callable[P, R]]:
     def decorate(target: Callable[P, R]) -> Callable[P, R]:
         nonlocal logger, on_success, on_backoff, on_giveup, on_attempt, before_sleep
+        nonlocal before, after
 
         logger = _prepare_logger(logger)
         on_success = _config_handlers(on_success)
@@ -75,6 +78,8 @@ def on_predicate(
         )
         on_attempt = _config_handlers(on_attempt)
         before_sleep = _config_handlers(before_sleep)
+        before = _config_handlers(before)
+        after = _config_handlers(after)
 
         condition: RetryCondition = retry_if_result(predicate)
 
@@ -107,6 +112,8 @@ def on_predicate(
                         retry_error_callback=retry_error_callback,
                         raise_on_giveup=raise_on_giveup,
                         wait_gen_kwargs=wait_gen_kwargs,
+                        before=before,
+                        after=after,
                     ),
                 )
 
@@ -137,6 +144,8 @@ def on_predicate(
                         retry_error_callback=retry_error_callback,
                         raise_on_giveup=raise_on_giveup,
                         wait_gen_kwargs=wait_gen_kwargs,
+                        before=before,
+                        after=after,
                     ),
                 )
 
@@ -164,10 +173,13 @@ def on_exception(
     backoff_log_level: int = logging.INFO,
     giveup_log_level: int = logging.ERROR,
     sleep: Callable[[float], Any] | None = None,
+    before: _Handler | Iterable[_Handler] | None = None,
+    after: _Handler | Iterable[_Handler] | None = None,
     **wait_gen_kwargs: Any,
 ) -> Callable[[Callable[P, R]], Callable[P, R]]:
     def decorate(target: Callable[P, R]) -> Callable[P, R]:
         nonlocal logger, on_success, on_backoff, on_giveup, on_attempt, before_sleep
+        nonlocal before, after
 
         logger = _prepare_logger(logger)
         on_success = _config_handlers(on_success)
@@ -185,6 +197,8 @@ def on_exception(
         )
         on_attempt = _config_handlers(on_attempt)
         before_sleep = _config_handlers(before_sleep)
+        before = _config_handlers(before)
+        after = _config_handlers(after)
 
         exc_types: tuple[type[Exception], ...]
         if isinstance(exception, type):
@@ -233,6 +247,8 @@ def on_exception(
                         retry_error_callback=retry_error_callback,
                         raise_on_giveup=raise_on_giveup,
                         wait_gen_kwargs=wait_gen_kwargs,
+                        before=before,
+                        after=after,
                     ),
                 )
 
@@ -263,6 +279,8 @@ def on_exception(
                         retry_error_callback=retry_error_callback,
                         raise_on_giveup=raise_on_giveup,
                         wait_gen_kwargs=wait_gen_kwargs,
+                        before=before,
+                        after=after,
                     ),
                 )
 

{backon-3.3.0 → backon-3.4.0}/backon/_retry.py

@@ -30,7 +30,7 @@ from backon._conditions import (
     stop_never,
 )
 from backon._jitter import full_jitter
-from backon._state import Attempt, RetryState, TryAgain
+from backon._state import Attempt, RetryCallState, RetryState, TryAgain
 from backon._typing import (
     _Handler,
     _Jitterer,
@@ -123,25 +123,37 @@ def _retry_loop_sync(
     raise_on_giveup,
     max_time,
     wait_gen_kwargs,
+    before=None,
+    after=None,
+    _holder=None,
 ):
     state = RetryState(target=target)
     start_time = _now()
     state.start_time = start_time
+    call_state = RetryCallState(fn=target, start_time=start_time)
+    if _holder is not None:
+        _holder["state"] = state
+        _holder["call_state"] = call_state
     wait = _init_wait_gen(wait_gen, wait_gen_kwargs)
 
     while True:
         state.tries += 1
         state.elapsed = _now() - start_time
+        call_state.attempt_number = state.tries
         outcome = Attempt(tries=state.tries, elapsed=state.elapsed)
 
         _call_hdlrs(on_attempt, state.to_details())
 
+        _call_hdlrs(before, state.to_details())
+
         try:
             ret = target()
         except TryAgain:
             outcome.exception = None
             outcome.value = None
             state.outcome = outcome
+            call_state.outcome = outcome
+            call_state.outcome_timestamp = _now()
             try:
                 value = wait.send(None)
                 if jitter is not None:
@@ -166,6 +178,10 @@ def _retry_loop_sync(
             outcome.value = None
             state.outcome = outcome
             state.idle_for += state.elapsed
+            call_state.outcome = outcome
+            call_state.outcome_timestamp = _now()
+            call_state.idle_for += call_state.elapsed
+            _call_hdlrs(after, state.to_details())
 
             if not condition(state):
                 details = state.to_details()
@@ -203,6 +219,7 @@ def _retry_loop_sync(
                     raise exc from None
                 return None
 
+            call_state.upcoming_sleep = seconds
             details = state.to_details()
             details["wait"] = seconds
             details["exception"] = exc
@@ -210,10 +227,14 @@ def _retry_loop_sync(
             _call_hdlrs(on_backoff, details)
             if seconds > 0:
                 sleep(seconds)
+            call_state.idle_for = call_state.idle_for + seconds
         else:
             outcome.value = ret
             outcome.exception = None
             state.outcome = outcome
+            call_state.outcome = outcome
+            call_state.outcome_timestamp = _now()
+            _call_hdlrs(after, state.to_details())
 
             if condition(state):
                 if stop(state):
@@ -236,6 +257,7 @@ def _retry_loop_sync(
                     _call_hdlrs(on_giveup, details)
                     return ret
 
+                call_state.upcoming_sleep = seconds
                 details = state.to_details()
                 details["wait"] = seconds
                 details["value"] = ret
@@ -243,6 +265,7 @@ def _retry_loop_sync(
                 _call_hdlrs(on_backoff, details)
                 if seconds > 0:
                     sleep(seconds)
+                call_state.idle_for = call_state.idle_for + seconds
             else:
                 details = state.to_details()
                 details["value"] = ret
@@ -266,25 +289,37 @@ async def _retry_loop_async(
     raise_on_giveup,
     max_time,
     wait_gen_kwargs,
+    before=None,
+    after=None,
+    _holder=None,
 ):
     state = RetryState(target=target)
     start_time = _now()
     state.start_time = start_time
+    call_state = RetryCallState(fn=target, start_time=start_time)
+    if _holder is not None:
+        _holder["state"] = state
+        _holder["call_state"] = call_state
     wait = _init_wait_gen(wait_gen, wait_gen_kwargs)
 
     while True:
         state.tries += 1
         state.elapsed = _now() - start_time
+        call_state.attempt_number = state.tries
         outcome = Attempt(tries=state.tries, elapsed=state.elapsed)
 
         await _call_hdlrs_async(on_attempt, state.to_details())
 
+        _call_hdlrs(before, state.to_details())
+
         try:
             ret = await target()
         except TryAgain:
             outcome.exception = None
             outcome.value = None
             state.outcome = outcome
+            call_state.outcome = outcome
+            call_state.outcome_timestamp = _now()
             try:
                 value = wait.send(None)
                 if jitter is not None:
@@ -309,6 +344,10 @@ async def _retry_loop_async(
             outcome.value = None
             state.outcome = outcome
             state.idle_for += state.elapsed
+            call_state.outcome = outcome
+            call_state.outcome_timestamp = _now()
+            call_state.idle_for += call_state.elapsed
+            await _call_hdlrs_async(after, state.to_details())
 
             if not condition(state):
                 details = state.to_details()
@@ -346,6 +385,7 @@ async def _retry_loop_async(
                     raise exc from None
                 return None
 
+            call_state.upcoming_sleep = seconds
             details = state.to_details()
             details["wait"] = seconds
             details["exception"] = exc
@@ -353,10 +393,14 @@ async def _retry_loop_async(
             await _call_hdlrs_async(on_backoff, details)
             if seconds > 0:
                 await sleep(seconds)
+            call_state.idle_for = call_state.idle_for + seconds
         else:
             outcome.value = ret
             outcome.exception = None
             state.outcome = outcome
+            call_state.outcome = outcome
+            call_state.outcome_timestamp = _now()
+            await _call_hdlrs_async(after, state.to_details())
 
             if condition(state):
                 if stop(state):
@@ -379,6 +423,7 @@ async def _retry_loop_async(
                     await _call_hdlrs_async(on_giveup, details)
                     return ret
 
+                call_state.upcoming_sleep = seconds
                 details = state.to_details()
                 details["wait"] = seconds
                 details["value"] = ret
@@ -386,6 +431,7 @@ async def _retry_loop_async(
                 await _call_hdlrs_async(on_backoff, details)
                 if seconds > 0:
                     await sleep(seconds)
+                call_state.idle_for = call_state.idle_for + seconds
             else:
                 details = state.to_details()
                 details["value"] = ret
@@ -411,6 +457,9 @@ def _retry_sync_inner(
     max_time=None,
     wait_gen_kwargs=None,
     max_tries=None,
+    before=None,
+    after=None,
+    _holder=None,
 ):
     if not is_enabled():
         return target()
@@ -437,6 +486,9 @@ def _retry_sync_inner(
         raise_on_giveup,
         max_time,
         wait_gen_kwargs,
+        before=before,
+        after=after,
+        _holder=_holder,
     )
 
 
@@ -458,6 +510,9 @@ async def _retry_async_inner(
     max_time=None,
     wait_gen_kwargs=None,
     max_tries=None,
+    before=None,
+    after=None,
+    _holder=None,
 ):
     if not is_enabled():
         return await target()
@@ -484,6 +539,9 @@ async def _retry_async_inner(
         raise_on_giveup,
         max_time,
         wait_gen_kwargs,
+        before=before,
+        after=after,
+        _holder=_holder,
     )
 
 
@@ -511,6 +569,9 @@ def _retry_sync(
     giveup_log_level: int = logging.ERROR,
     sleep: Callable[[float], Any] | None = None,
     wait_gen_kwargs: dict | None = None,
+    before: _Handler | Iterable[_Handler] | None = None,
+    after: _Handler | Iterable[_Handler] | None = None,
+    _holder: dict | None = None,
 ) -> Any:
     if wait_gen_kwargs is None:
         wait_gen_kwargs = {}
@@ -533,6 +594,8 @@ def _retry_sync(
     )
     on_attempt = _config_handlers(on_attempt)
     before_sleep = _config_handlers(before_sleep)
+    before = _config_handlers(before)
+    after = _config_handlers(after)
 
     if condition is None:
         condition = _make_default_condition(exception, giveup, predicate)
@@ -557,6 +620,9 @@ def _retry_sync(
         raise_on_giveup,
         max_time,
         wait_gen_kwargs,
+        before=before,
+        after=after,
+        _holder=_holder,
     )
 
 
@@ -584,6 +650,9 @@ async def _retry_async(
     giveup_log_level: int = logging.ERROR,
     sleep: Callable[[float], Any] | None = None,
     wait_gen_kwargs: dict | None = None,
+    before: _Handler | Iterable[_Handler] | None = None,
+    after: _Handler | Iterable[_Handler] | None = None,
+    _holder: dict | None = None,
 ) -> Any:
     if wait_gen_kwargs is None:
         wait_gen_kwargs = {}
@@ -606,6 +675,8 @@ async def _retry_async(
     )
     on_attempt = _config_handlers(on_attempt)
     before_sleep = _config_handlers(before_sleep)
+    before = _config_handlers(before)
+    after = _config_handlers(after)
 
     if condition is None:
         condition = _make_default_condition(exception, giveup, predicate)
@@ -630,6 +701,9 @@ async def _retry_async(
         raise_on_giveup,
         max_time,
         wait_gen_kwargs,
+        before=before,
+        after=after,
+        _holder=_holder,
     )
 
 
@@ -657,6 +731,8 @@ def retry(
     giveup_log_level: int = logging.ERROR,
     sleep: Callable[[float], Any] | None = None,
     name: str = "",
+    before: _Handler | Iterable[_Handler] | None = None,
+    after: _Handler | Iterable[_Handler] | None = None,
     **wait_gen_kwargs: Any,
 ) -> Any:
     if inspect.iscoroutinefunction(target):
@@ -683,6 +759,8 @@ def retry(
             giveup_log_level=giveup_log_level,
             sleep=sleep,
             wait_gen_kwargs=wait_gen_kwargs,
+            before=before,
+            after=after,
         )
     return _retry_sync(
         target,
@@ -707,6 +785,8 @@ def retry(
         giveup_log_level=giveup_log_level,
         sleep=sleep,
         wait_gen_kwargs=wait_gen_kwargs,
+        before=before,
+        after=after,
     )
 
 
@@ -763,6 +843,8 @@ class Retrying:
         sleep: Callable[[float], Any] | None = None,
         enabled: bool = True,
         name: str = "",
+        before: _Handler | Iterable[_Handler] | None = None,
+        after: _Handler | Iterable[_Handler] | None = None,
         **wait_gen_kwargs: Any,
     ):
         self._wait_gen = wait_gen
@@ -787,14 +869,23 @@ class Retrying:
         self._sleep = sleep
         self._enabled = enabled
         self._name = name
+        self._before = before
+        self._after = after
         self._wait_gen_kwargs = wait_gen_kwargs
         self._state: RetryState | None = None
+        self._call_state: RetryCallState | None = None
 
     @property
     def statistics(self) -> dict:
-        if self._state is None:
-            return {}
-        return self._state.statistics
+        if self._call_state is not None:
+            return self._call_state.statistics
+        if self._state is not None:
+            return self._state.statistics
+        return {}
+
+    @property
+    def call_state(self) -> RetryCallState | None:
+        return self._call_state
 
     @property
     def enabled(self) -> bool:
@@ -903,6 +994,8 @@ class Retrying:
             sleep=self._sleep,
             enabled=self._enabled,
             name=self._name,
+            before=self._before,
+            after=self._after,
             **self._wait_gen_kwargs,
         )
 
@@ -916,30 +1009,39 @@ class Retrying:
         def wrapped():
             return target(*args, **kwargs)
 
-        return _retry_sync(
-            wrapped,
-            self._wait_gen,
-            predicate=self._predicate,
-            exception=self._exception,
-            max_tries=self._max_tries,
-            max_time=self._max_time,
-            jitter=self._jitter,
-            giveup=self._giveup,
-            condition=self._condition,
-            stop=self._stop,
-            on_success=self._on_success,
-            on_backoff=self._on_backoff,
-            on_giveup=self._on_giveup,
-            on_attempt=self._on_attempt,
-            before_sleep=self._before_sleep,
-            retry_error_callback=self._retry_error_callback,
-            raise_on_giveup=self._raise_on_giveup,
-            logger=self._logger,
-            backoff_log_level=self._backoff_log_level,
-            giveup_log_level=self._giveup_log_level,
-            sleep=self._sleep,
-            wait_gen_kwargs=self._wait_gen_kwargs,
-        )
+        _holder: dict = {}
+        try:
+            result = _retry_sync(
+                wrapped,
+                self._wait_gen,
+                predicate=self._predicate,
+                exception=self._exception,
+                max_tries=self._max_tries,
+                max_time=self._max_time,
+                jitter=self._jitter,
+                giveup=self._giveup,
+                condition=self._condition,
+                stop=self._stop,
+                on_success=self._on_success,
+                on_backoff=self._on_backoff,
+                on_giveup=self._on_giveup,
+                on_attempt=self._on_attempt,
+                before_sleep=self._before_sleep,
+                retry_error_callback=self._retry_error_callback,
+                raise_on_giveup=self._raise_on_giveup,
+                logger=self._logger,
+                backoff_log_level=self._backoff_log_level,
+                giveup_log_level=self._giveup_log_level,
+                sleep=self._sleep,
+                wait_gen_kwargs=self._wait_gen_kwargs,
+                before=self._before,
+                after=self._after,
+                _holder=_holder,
+            )
+            return result
+        finally:
+            self._state = _holder.get("state")
+            self._call_state = _holder.get("call_state")
 
     async def async_call(
         self, target: Callable[..., Any], *args: Any, **kwargs: Any
@@ -947,30 +1049,39 @@ class Retrying:
         async def wrapped():
             return await target(*args, **kwargs)
 
-        return await _retry_async(
-            wrapped,
-            self._wait_gen,
-            predicate=self._predicate,
-            exception=self._exception,
-            max_tries=self._max_tries,
-            max_time=self._max_time,
-            jitter=self._jitter,
-            giveup=self._giveup,
-            condition=self._condition,
-            stop=self._stop,
-            on_success=self._on_success,
-            on_backoff=self._on_backoff,
-            on_giveup=self._on_giveup,
-            on_attempt=self._on_attempt,
-            before_sleep=self._before_sleep,
-            retry_error_callback=self._retry_error_callback,
-            raise_on_giveup=self._raise_on_giveup,
-            logger=self._logger,
-            backoff_log_level=self._backoff_log_level,
-            giveup_log_level=self._giveup_log_level,
-            sleep=self._sleep,
-            wait_gen_kwargs=self._wait_gen_kwargs,
-        )
+        _holder: dict = {}
+        try:
+            result = await _retry_async(
+                wrapped,
+                self._wait_gen,
+                predicate=self._predicate,
+                exception=self._exception,
+                max_tries=self._max_tries,
+                max_time=self._max_time,
+                jitter=self._jitter,
+                giveup=self._giveup,
+                condition=self._condition,
+                stop=self._stop,
+                on_success=self._on_success,
+                on_backoff=self._on_backoff,
+                on_giveup=self._on_giveup,
+                on_attempt=self._on_attempt,
+                before_sleep=self._before_sleep,
+                retry_error_callback=self._retry_error_callback,
+                raise_on_giveup=self._raise_on_giveup,
+                logger=self._logger,
+                backoff_log_level=self._backoff_log_level,
+                giveup_log_level=self._giveup_log_level,
+                sleep=self._sleep,
+                wait_gen_kwargs=self._wait_gen_kwargs,
+                before=self._before,
+                after=self._after,
+                _holder=_holder,
+            )
+            return result
+        finally:
+            self._state = _holder.get("state")
+            self._call_state = _holder.get("call_state")
 
 
 def sleep_using_event(event) -> Callable[[float], None]:

{backon-3.3.0 → backon-3.4.0}/backon/_state.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import threading
+import time as time_module
 from collections.abc import Callable
 from dataclasses import dataclass, field
 from typing import Any
@@ -73,3 +74,44 @@ class RetryState:
             "tries": self.tries,
             "elapsed": self.elapsed,
         }
+
+
+@dataclass
+class RetryCallState:
+    fn: Callable[..., Any] | None = None
+    args: tuple = ()
+    kwargs: dict = field(default_factory=dict)
+    attempt_number: int = 1
+    outcome: Attempt | None = None
+    outcome_timestamp: float | None = None
+    start_time: float = 0.0
+    idle_for: float = 0.0
+    upcoming_sleep: float = 0.0
+
+    @property
+    def elapsed(self) -> float:
+        if self.start_time == 0:
+            return 0.0
+        return time_module.monotonic() - self.start_time
+
+    @property
+    def seconds_since_start(self) -> float:
+        return self.elapsed
+
+    @property
+    def statistics(self) -> dict[str, Any]:
+        return {
+            "start_time": self.start_time,
+            "attempt_number": self.attempt_number,
+            "idle_for": self.idle_for,
+            "elapsed": self.elapsed,
+        }
+
+    def to_details(self) -> dict[str, Any]:
+        return {
+            "target": self.fn,
+            "args": self.args,
+            "kwargs": self.kwargs,
+            "tries": self.attempt_number,
+            "elapsed": self.elapsed,
+        }

{backon-3.3.0 → backon-3.4.0}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "pdm.backend"
 
 [project]
 name = "backon"
-version = "3.3.0"
+version = "3.4.0"
 description = "Function decoration for backoff and retry"
 readme = "README.md"
 requires-python = ">=3.10"

{backon-3.3.0 → backon-3.4.0}/tests/test_backon.py

@@ -50,6 +50,7 @@ class TestImports:
             "TryAgain",
             "RetryError",
             "RetryState",
+            "RetryCallState",
             "Stop",
             "RetryCondition",
             "stop_after_attempt",

backon-3.4.0/tests/test_retry_call_state.py

@@ -0,0 +1,292 @@
+import time
+
+import pytest
+
+import backon
+from backon._state import RetryCallState
+
+
+class TestRetryCallState:
+    def test_elapsed_property(self):
+        state = RetryCallState(start_time=time.monotonic())
+        time.sleep(0.01)
+        assert state.elapsed > 0
+
+    def test_statistics(self):
+        state = RetryCallState(
+            fn=lambda: None,
+            attempt_number=3,
+            idle_for=2.5,
+            start_time=time.monotonic(),
+        )
+        stats = state.statistics
+        assert stats["attempt_number"] == 3
+        assert stats["idle_for"] == 2.5
+        assert "start_time" in stats
+        assert "elapsed" in stats
+
+    def test_to_details(self):
+        state = RetryCallState(
+            fn=lambda: None,
+            attempt_number=3,
+            start_time=time.monotonic(),
+        )
+        details = state.to_details()
+        assert details["tries"] == 3
+        assert details["target"] is state.fn
+
+    def test_zero_start_time_elapsed(self):
+        state = RetryCallState()
+        assert state.elapsed == 0.0
+
+
+class TestBeforeAfterHooks:
+    def test_before_and_after_with_success(self):
+        order = []
+
+        def before(details):
+            order.append("before")
+
+        def after(details):
+            order.append("after")
+
+        @backon.on_exception(
+            backon.constant,
+            ValueError,
+            max_tries=3,
+            jitter=None,
+            interval=0.01,
+            before=before,
+            after=after,
+        )
+        def f():
+            return "ok"
+
+        f()
+        assert order == ["before", "after"]
+
+    def test_before_and_after_with_exception(self):
+        order = []
+
+        def before(details):
+            order.append("before")
+
+        def after(details):
+            order.append("after")
+
+        @backon.on_exception(
+            backon.constant,
+            ValueError,
+            max_tries=2,
+            jitter=None,
+            interval=0.01,
+            before=before,
+            after=after,
+            raise_on_giveup=True,
+        )
+        def f():
+            raise ValueError("fail")
+
+        with pytest.raises(ValueError):
+            f()
+        assert order == ["before", "after", "before", "after"]
+
+    def test_before_and_after_multiple_attempts_success(self):
+        calls = []
+        order = []
+
+        def before(details):
+            order.append("before")
+
+        def after(details):
+            order.append("after")
+
+        @backon.on_exception(
+            backon.constant,
+            ValueError,
+            max_tries=3,
+            jitter=None,
+            interval=0.01,
+            before=before,
+            after=after,
+        )
+        def f():
+            calls.append(1)
+            if len(calls) < 3:
+                raise ValueError("fail")
+            return "ok"
+
+        f()
+        assert order == ["before", "after", "before", "after", "before", "after"]
+        assert len(calls) == 3
+
+    def test_before_after_via_retry_functional_api(self):
+        order = []
+        calls = []
+
+        def before(details):
+            order.append("before")
+
+        def after(details):
+            order.append("after")
+
+        def flaky():
+            calls.append(1)
+            if len(calls) < 2:
+                raise ValueError("fail")
+            return "ok"
+
+        result = backon.retry(
+            flaky,
+            backon.constant,
+            exception=ValueError,
+            max_tries=3,
+            jitter=None,
+            interval=0.01,
+            before=before,
+            after=after,
+        )
+        assert result == "ok"
+        assert order == ["before", "after", "before", "after"]
+
+    def test_before_after_multiple_handlers(self):
+        order = []
+
+        def h1(d):
+            order.append("h1")
+
+        def h2(d):
+            order.append("h2")
+
+        @backon.on_exception(
+            backon.constant,
+            ValueError,
+            max_tries=2,
+            jitter=None,
+            interval=0.01,
+            before=[h1, h2],
+            after=[h2, h1],
+        )
+        def f():
+            raise ValueError("fail")
+
+        with pytest.raises(ValueError):
+            f()
+        assert order == ["h1", "h2", "h2", "h1", "h1", "h2", "h2", "h1"]
+
+    @pytest.mark.asyncio
+    async def test_before_after_async(self):
+        order = []
+
+        def before(details):
+            order.append("before")
+
+        def after(details):
+            order.append("after")
+
+        @backon.on_exception(
+            backon.constant,
+            ValueError,
+            max_tries=3,
+            jitter=None,
+            interval=0.01,
+            before=before,
+            after=after,
+        )
+        async def f():
+            return "ok"
+
+        await f()
+        assert order == ["before", "after"]
+
+    @pytest.mark.asyncio
+    async def test_before_after_async_exception(self):
+        order = []
+
+        def before(details):
+            order.append("before")
+
+        def after(details):
+            order.append("after")
+
+        @backon.on_exception(
+            backon.constant,
+            ValueError,
+            max_tries=2,
+            jitter=None,
+            interval=0.01,
+            before=before,
+            after=after,
+            raise_on_giveup=True,
+        )
+        async def f():
+            raise ValueError("fail")
+
+        with pytest.raises(ValueError):
+            await f()
+        assert order == ["before", "after", "before", "after"]
+
+
+class TestRetryingStatistics:
+    def test_statistics_available_after_call(self):
+        r = backon.Retrying(
+            backon.constant,
+            exception=ValueError,
+            max_tries=2,
+            jitter=None,
+            interval=0.01,
+        )
+
+        def flaky():
+            raise ValueError("fail")
+
+        with pytest.raises(ValueError):
+            r.call(flaky)
+
+        stats = r.statistics
+        assert "attempt_number" in stats
+        assert stats["attempt_number"] == 2
+
+    def test_statistics_before_call(self):
+        r = backon.Retrying(backon.constant)
+        assert r.statistics == {}
+
+    def test_call_state_after_call(self):
+        r = backon.Retrying(
+            backon.constant,
+            exception=ValueError,
+            max_tries=2,
+            jitter=None,
+            interval=0.01,
+        )
+
+        def flaky():
+            raise ValueError("fail")
+
+        with pytest.raises(ValueError):
+            r.call(flaky)
+
+        cs = r.call_state
+        assert cs is not None
+        assert cs.attempt_number == 2
+
+    def test_call_state_before_call(self):
+        r = backon.Retrying(backon.constant)
+        assert r.call_state is None
+
+    def test_on_predicate_statistics(self):
+        r = backon.Retrying(
+            backon.constant,
+            predicate=lambda x: x is None,
+            max_tries=3,
+            jitter=None,
+            interval=0.01,
+        )
+
+        def flaky():
+            return None
+
+        r.call(flaky)
+        stats = r.statistics
+        assert "attempt_number" in stats
+        assert stats["attempt_number"] == 3