flwr-nightly 1.21.0.dev20250731__tar.gz → 1.21.0.dev20250802__tar.gz

{flwr_nightly-1.21.0.dev20250731 → flwr_nightly-1.21.0.dev20250802}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: flwr-nightly
-Version: 1.21.0.dev20250731
+Version: 1.21.0.dev20250802
 Summary: Flower: A Friendly Federated AI Framework
 License: Apache-2.0
 Keywords: Artificial Intelligence,Federated AI,Federated Analytics,Federated Evaluation,Federated Learning,Flower,Machine Learning

{flwr_nightly-1.21.0.dev20250731 → flwr_nightly-1.21.0.dev20250802}/py/flwr/client/grpc_rere_client/connection.py

@@ -40,7 +40,7 @@ from flwr.common.secure_aggregation.crypto.symmetric_encryption import (
     generate_key_pairs,
 )
 from flwr.common.serde import message_from_proto, message_to_proto, run_from_proto
-from flwr.common.typing import Fab, Run, RunNotRunningException
+from flwr.common.typing import Fab, Run
 from flwr.proto.fab_pb2 import GetFabRequest, GetFabResponse  # pylint: disable=E0611
 from flwr.proto.fleet_pb2 import (  # pylint: disable=E0611
     CreateNodeRequest,
@@ -157,17 +157,6 @@ def grpc_request_response(  # pylint: disable=R0913,R0914,R0915,R0917
     stub = adapter_cls(channel)
     node: Optional[Node] = None
 
-    def _should_giveup_fn(e: Exception) -> bool:
-        if e.code() == grpc.StatusCode.PERMISSION_DENIED:  # type: ignore
-            raise RunNotRunningException
-        if e.code() == grpc.StatusCode.UNAVAILABLE:  # type: ignore
-            return False
-        return True
-
-    # Restrict retries to cases where the status code is UNAVAILABLE
-    # If the status code is PERMISSION_DENIED, additionally raise RunNotRunningException
-    retry_invoker.should_giveup = _should_giveup_fn
-
     # Wrap stub
     _wrap_stub(stub, retry_invoker)
     ###########################################################################

{flwr_nightly-1.21.0.dev20250731 → flwr_nightly-1.21.0.dev20250802}/py/flwr/client/rest_client/connection.py

@@ -176,6 +176,9 @@ def http_request_response(  # pylint: disable=R0913,R0914,R0915,R0917
     # Shared variables for inner functions
     node: Optional[Node] = None
 
+    # Remove should_giveup from RetryInvoker as REST does not support gRPC status codes
+    retry_invoker.should_giveup = None
+
     ###########################################################################
     # heartbeat/create_node/delete_node/receive/send/get_run functions
     ###########################################################################

{flwr_nightly-1.21.0.dev20250731 → flwr_nightly-1.21.0.dev20250802}/py/flwr/common/args.py

@@ -17,7 +17,7 @@
 
 import argparse
 import sys
-from logging import DEBUG, ERROR, WARN
+from logging import DEBUG, ERROR, INFO, WARN
 from os.path import isfile
 from pathlib import Path
 from typing import Optional, Union
@@ -72,11 +72,7 @@ def try_obtain_root_certificates(
     else:
         # Load the certificates if provided, or load the system certificates
         if root_cert_path is None:
-            log(
-                WARN,
-                "Both `--insecure` and `--root-certificates` were not set. "
-                "Using system certificates.",
-            )
+            log(INFO, "Using system certificates")
             root_certificates = None
         elif not isfile(root_cert_path):
             log(ERROR, "Path argument `--root-certificates` does not point to a file.")

{flwr_nightly-1.21.0.dev20250731 → flwr_nightly-1.21.0.dev20250802}/py/flwr/common/retry_invoker.py

@@ -17,6 +17,7 @@
 
 import itertools
 import random
+import threading
 import time
 from collections.abc import Generator, Iterable
 from dataclasses import dataclass
@@ -319,8 +320,12 @@ class RetryInvoker:
 
 def _make_simple_grpc_retry_invoker() -> RetryInvoker:
     """Create a simple gRPC retry invoker."""
+    lock = threading.Lock()
+    system_healthy = threading.Event()
+    system_healthy.set()  # Initially, the connection is healthy
 
-    def _on_sucess(retry_state: RetryState) -> None:
+    def _on_success(retry_state: RetryState) -> None:
+        system_healthy.set()
         if retry_state.tries > 1:
             log(
                 INFO,
@@ -329,17 +334,11 @@ def _make_simple_grpc_retry_invoker() -> RetryInvoker:
                 retry_state.tries,
             )
 
-    def _on_backoff(retry_state: RetryState) -> None:
-        if retry_state.tries == 1:
-            log(WARN, "Connection attempt failed, retrying...")
-        else:
-            log(
-                WARN,
-                "Connection attempt failed, retrying in %.2f seconds",
-                retry_state.actual_wait,
-            )
+    def _on_backoff(_: RetryState) -> None:
+        system_healthy.clear()
 
     def _on_giveup(retry_state: RetryState) -> None:
+        system_healthy.clear()
         if retry_state.tries > 1:
             log(
                 WARN,
@@ -355,15 +354,35 @@ def _make_simple_grpc_retry_invoker() -> RetryInvoker:
             return False
         return True
 
+    def _wait(wait_time: float) -> None:
+        # Use a lock to prevent multiple gRPC calls from retrying concurrently,
+        # which is unnecessary since they are all likely to fail.
+        with lock:
+            # Log the wait time
+            log(
+                WARN,
+                "Connection attempt failed, retrying in %.2f seconds",
+                wait_time,
+            )
+
+            start = time.monotonic()
+            # Avoid sequential waits if the system is healthy
+            system_healthy.wait(wait_time)
+
+        remaining_time = wait_time - (time.monotonic() - start)
+        if remaining_time > 0:
+            time.sleep(remaining_time)
+
     return RetryInvoker(
         wait_gen_factory=lambda: exponential(max_delay=MAX_RETRY_DELAY),
         recoverable_exceptions=grpc.RpcError,
         max_tries=None,
         max_time=None,
-        on_success=_on_sucess,
+        on_success=_on_success,
         on_backoff=_on_backoff,
         on_giveup=_on_giveup,
         should_giveup=_should_giveup_fn,
+        wait_function=_wait,
     )
 
 

{flwr_nightly-1.21.0.dev20250731 → flwr_nightly-1.21.0.dev20250802}/py/flwr/supernode/start_client_internal.py

@@ -21,7 +21,7 @@ import time
 from collections.abc import Iterator
 from contextlib import contextmanager
 from functools import partial
-from logging import INFO, WARN
+from logging import INFO
 from pathlib import Path
 from typing import Callable, Optional, Union, cast
 
@@ -38,7 +38,6 @@ from flwr.common.constant import (
     CLIENT_OCTET,
     CLIENTAPPIO_API_DEFAULT_SERVER_ADDRESS,
     ISOLATION_MODE_SUBPROCESS,
-    MAX_RETRY_DELAY,
     SERVER_OCTET,
     TRANSPORT_TYPE_GRPC_ADAPTER,
     TRANSPORT_TYPE_GRPC_RERE,
@@ -54,7 +53,7 @@ from flwr.common.inflatable_utils import (
     push_object_contents_from_iterable,
 )
 from flwr.common.logger import log
-from flwr.common.retry_invoker import RetryInvoker, RetryState, exponential
+from flwr.common.retry_invoker import RetryInvoker, _make_simple_grpc_retry_invoker
 from flwr.common.telemetry import EventType
 from flwr.common.typing import Fab, Run, RunNotRunningException, UserConfig
 from flwr.proto.clientappio_pb2_grpc import add_ClientAppIoServicer_to_server
@@ -521,44 +520,14 @@ def _make_fleet_connection_retry_invoker(
     connection_error_type: type[Exception] = RpcError,
 ) -> RetryInvoker:
     """Create a retry invoker for fleet connection."""
-
-    def _on_success(retry_state: RetryState) -> None:
-        if retry_state.tries > 1:
-            log(
-                INFO,
-                "Connection successful after %.2f seconds and %s tries.",
-                retry_state.elapsed_time,
-                retry_state.tries,
-            )
-
-    def _on_backoff(retry_state: RetryState) -> None:
-        if retry_state.tries == 1:
-            log(WARN, "Connection attempt failed, retrying...")
-        else:
-            log(
-                WARN,
-                "Connection attempt failed, retrying in %.2f seconds",
-                retry_state.actual_wait,
-            )
-
-    return RetryInvoker(
-        wait_gen_factory=lambda: exponential(max_delay=MAX_RETRY_DELAY),
-        recoverable_exceptions=connection_error_type,
-        max_tries=max_retries + 1 if max_retries is not None else None,
-        max_time=max_wait_time,
-        on_giveup=lambda retry_state: (
-            log(
-                WARN,
-                "Giving up reconnection after %.2f seconds and %s tries.",
-                retry_state.elapsed_time,
-                retry_state.tries,
-            )
-            if retry_state.tries > 1
-            else None
-        ),
-        on_success=_on_success,
-        on_backoff=_on_backoff,
-    )
+    retry_invoker = _make_simple_grpc_retry_invoker()
+    retry_invoker.recoverable_exceptions = connection_error_type
+    if max_retries is not None:
+        retry_invoker.max_tries = max_retries + 1
+    if max_wait_time is not None:
+        retry_invoker.max_time = max_wait_time
+
+    return retry_invoker
 
 
 def run_clientappio_api_grpc(

{flwr_nightly-1.21.0.dev20250731 → flwr_nightly-1.21.0.dev20250802}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "flwr-nightly"
-version = "1.21.0.dev20250731"
+version = "1.21.0.dev20250802"
 description = "Flower: A Friendly Federated AI Framework"
 license = "Apache-2.0"
 authors = ["The Flower Authors <hello@flower.ai>"]