flwr-nightly 1.6.0.dev20231030__tar.gz → 1.6.0.dev20231101__tar.gz

{flwr_nightly-1.6.0.dev20231030 → flwr_nightly-1.6.0.dev20231101}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: flwr-nightly
-Version: 1.6.0.dev20231030
+Version: 1.6.0.dev20231101
 Summary: Flower: A Friendly Federated Learning Framework
 Home-page: https://flower.dev
 License: Apache-2.0

{flwr_nightly-1.6.0.dev20231030 → flwr_nightly-1.6.0.dev20231101}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "flwr-nightly"
-version = "1.6.0-dev20231030"
+version = "1.6.0-dev20231101"
 description = "Flower: A Friendly Federated Learning Framework"
 license = "Apache-2.0"
 authors = ["The Flower Authors <hello@flower.dev>"]

{flwr_nightly-1.6.0.dev20231030 → flwr_nightly-1.6.0.dev20231101}/src/py/flwr/common/retry_invoker.py

@@ -107,7 +107,7 @@ class RetryInvoker:
 
     Parameters
     ----------
-    wait_strategy: Generator[float, None, None]
+    wait_factory: Callable[[], Generator[float, None, None]]
         A generator yielding successive wait times in seconds. If the generator
         is finite, the giveup event will be triggered when the generator raises
         `StopIteration`.
@@ -129,11 +129,11 @@ class RetryInvoker:
         data class object detailing the invocation.
     on_giveup: Optional[Callable[[RetryState], None]] (default: None)
         A callable to be executed in the event that `max_tries` or `max_time` is
-        exceeded, `should_giveup` returns True, or `wait_strategy` generator raises
+        exceeded, `should_giveup` returns True, or `wait_factory()` generator raises
         `StopInteration`. The parameter is a data class object detailing the
         invocation.
     jitter: Optional[Callable[[float], float]] (default: full_jitter)
-        A function of the value yielded by `wait_strategy` returning the actual time
+        A function of the value yielded by `wait_factory()` returning the actual time
         to wait. This function helps distribute wait times stochastically to avoid
         timing collisions across concurrent clients. Wait times are jittered by
         default using the `full_jitter` function. To disable jittering, pass
@@ -145,20 +145,20 @@ class RetryInvoker:
 
     Examples
     --------
-    Initialize a `RetryInvoker` with exponential backoff and call a function:
+    Initialize a `RetryInvoker` with exponential backoff and invoke a function:
 
     >>> invoker = RetryInvoker(
-    >>>     exponential(),
-    >>>     grpc.RpcError,
-    >>>     max_tries=3,
-    >>>     max_time=None,
-    >>> )
+    ...     exponential,  # Or use `lambda: exponential(3, 2)` to pass arguments
+    ...     grpc.RpcError,
+    ...     max_tries=3,
+    ...     max_time=None,
+    ... )
     >>> invoker.invoke(my_func, arg1, arg2, kw1=kwarg1)
     """
 
     def __init__(
         self,
-        wait_strategy: Generator[float, None, None],
+        wait_factory: Callable[[], Generator[float, None, None]],
         recoverable_exceptions: Union[Type[Exception], Tuple[Type[Exception], ...]],
         max_tries: Optional[int],
         max_time: Optional[float],
@@ -169,7 +169,7 @@ class RetryInvoker:
         jitter: Optional[Callable[[float], float]] = full_jitter,
         should_giveup: Optional[Callable[[Exception], bool]] = None,
     ) -> None:
-        self.wait_strategy = wait_strategy
+        self.wait_factory = wait_factory
         self.recoverable_exceptions = recoverable_exceptions
         self.max_tries = max_tries
         self.max_time = max_time
@@ -183,8 +183,8 @@ class RetryInvoker:
     def invoke(
         self,
         target: Callable[..., Any],
-        *args: Tuple[Any, ...],
-        **kwargs: Dict[str, Any],
+        *args: Any,
+        **kwargs: Any,
     ) -> Any:
         """Safely invoke the provided callable with retry mechanisms.
 
@@ -212,12 +212,12 @@ class RetryInvoker:
         ------
         Exception
             If the number of tries exceeds `max_tries`, if the total time
-            exceeds `max_time`, if `wait_strategy` generator raises `StopInteration`,
+            exceeds `max_time`, if `wait_factory()` generator raises `StopInteration`,
             or if the `should_giveup` returns True for a raised exception.
 
         Notes
         -----
-        The time between retries is determined by the provided `wait_strategy`
+        The time between retries is determined by the provided `wait_factory()`
         generator and can optionally be jittered using the `jitter` function.
         The recoverable exceptions that trigger a retry, as well as conditions to
         stop retries, are also determined by the class's initialization parameters.
@@ -230,6 +230,7 @@ class RetryInvoker:
                 handler(cast(RetryState, ref_state[0]))
 
         try_cnt = 0
+        wait_generator = self.wait_factory()
         start = time.time()
         ref_state: List[Optional[RetryState]] = [None]
 
@@ -265,7 +266,7 @@ class RetryInvoker:
                     raise
 
                 try:
-                    wait_time = next(self.wait_strategy)
+                    wait_time = next(wait_generator)
                     if self.jitter is not None:
                         wait_time = self.jitter(wait_time)
                     if self.max_time is not None: