flwr-nightly 1.23.0.dev20250930__py3-none-any.whl → 1.26.0.dev20260121__py3-none-any.whl

flwr/server/strategy/fedxgb_cyclic.py

@@ -16,7 +16,7 @@
 
 
 from logging import WARNING
-from typing import Any, Optional, Union, cast
+from typing import Any, cast
 
 from flwr.common import EvaluateIns, EvaluateRes, FitIns, FitRes, Parameters, Scalar
 from flwr.common.logger import log
@@ -34,7 +34,7 @@ class FedXgbCyclic(FedAvg):
         self,
         **kwargs: Any,
     ):
-        self.global_model: Optional[bytes] = None
+        self.global_model: bytes | None = None
         super().__init__(**kwargs)
 
     def __repr__(self) -> str:
@@ -46,8 +46,8 @@ class FedXgbCyclic(FedAvg):
         self,
         server_round: int,
         results: list[tuple[ClientProxy, FitRes]],
-        failures: list[Union[tuple[ClientProxy, FitRes], BaseException]],
-    ) -> tuple[Optional[Parameters], dict[str, Scalar]]:
+        failures: list[tuple[ClientProxy, FitRes] | BaseException],
+    ) -> tuple[Parameters | None, dict[str, Scalar]]:
         """Aggregate fit results using bagging."""
         if not results:
             return None, {}
@@ -70,8 +70,8 @@ class FedXgbCyclic(FedAvg):
         self,
         server_round: int,
         results: list[tuple[ClientProxy, EvaluateRes]],
-        failures: list[Union[tuple[ClientProxy, EvaluateRes], BaseException]],
-    ) -> tuple[Optional[float], dict[str, Scalar]]:
+        failures: list[tuple[ClientProxy, EvaluateRes] | BaseException],
+    ) -> tuple[float | None, dict[str, Scalar]]:
         """Aggregate evaluation metrics using average."""
         if not results:
             return None, {}

flwr/server/strategy/fedxgb_nn_avg.py

@@ -22,7 +22,7 @@ Paper: arxiv.org/abs/2304.07537
 
 
 from logging import WARNING
-from typing import Any, Optional, Union
+from typing import Any
 
 from flwr.common import FitRes, Scalar, ndarrays_to_parameters, parameters_to_ndarrays
 from flwr.common.logger import log, warn_deprecated_feature
@@ -57,7 +57,7 @@ class FedXgbNnAvg(FedAvg):
 
     def evaluate(
         self, server_round: int, parameters: Any
-    ) -> Optional[tuple[float, dict[str, Scalar]]]:
+    ) -> tuple[float, dict[str, Scalar]] | None:
         """Evaluate model parameters using an evaluation function."""
         if self.evaluate_fn is None:
             # No evaluation function provided
@@ -72,8 +72,8 @@ class FedXgbNnAvg(FedAvg):
         self,
         server_round: int,
         results: list[tuple[ClientProxy, FitRes]],
-        failures: list[Union[tuple[ClientProxy, FitRes], BaseException]],
-    ) -> tuple[Optional[Any], dict[str, Scalar]]:
+        failures: list[tuple[ClientProxy, FitRes] | BaseException],
+    ) -> tuple[Any | None, dict[str, Scalar]]:
         """Aggregate fit results using weighted average."""
         if not results:
             return None, {}

flwr/server/strategy/fedyogi.py

@@ -18,7 +18,7 @@ Paper: arxiv.org/abs/2003.00295
 """
 
 
-from typing import Callable, Optional, Union
+from collections.abc import Callable
 
 import numpy as np
 
@@ -91,18 +91,19 @@ class FedYogi(FedOpt):
         min_fit_clients: int = 2,
         min_evaluate_clients: int = 2,
         min_available_clients: int = 2,
-        evaluate_fn: Optional[
+        evaluate_fn: (
             Callable[
                 [int, NDArrays, dict[str, Scalar]],
-                Optional[tuple[float, dict[str, Scalar]]],
+                tuple[float, dict[str, Scalar]] | None,
             ]
-        ] = None,
-        on_fit_config_fn: Optional[Callable[[int], dict[str, Scalar]]] = None,
-        on_evaluate_config_fn: Optional[Callable[[int], dict[str, Scalar]]] = None,
+            | None
+        ) = None,
+        on_fit_config_fn: Callable[[int], dict[str, Scalar]] | None = None,
+        on_evaluate_config_fn: Callable[[int], dict[str, Scalar]] | None = None,
         accept_failures: bool = True,
         initial_parameters: Parameters,
-        fit_metrics_aggregation_fn: Optional[MetricsAggregationFn] = None,
-        evaluate_metrics_aggregation_fn: Optional[MetricsAggregationFn] = None,
+        fit_metrics_aggregation_fn: MetricsAggregationFn | None = None,
+        evaluate_metrics_aggregation_fn: MetricsAggregationFn | None = None,
         eta: float = 1e-2,
         eta_l: float = 0.0316,
         beta_1: float = 0.9,
@@ -138,8 +139,8 @@ class FedYogi(FedOpt):
         self,
         server_round: int,
         results: list[tuple[ClientProxy, FitRes]],
-        failures: list[Union[tuple[ClientProxy, FitRes], BaseException]],
-    ) -> tuple[Optional[Parameters], dict[str, Scalar]]:
+        failures: list[tuple[ClientProxy, FitRes] | BaseException],
+    ) -> tuple[Parameters | None, dict[str, Scalar]]:
         """Aggregate fit results using weighted average."""
         fedavg_parameters_aggregated, metrics_aggregated = super().aggregate_fit(
             server_round=server_round, results=results, failures=failures
@@ -151,7 +152,8 @@ class FedYogi(FedOpt):
 
         # Yogi
         delta_t: NDArrays = [
-            x - y for x, y in zip(fedavg_weights_aggregate, self.current_weights)
+            x - y
+            for x, y in zip(fedavg_weights_aggregate, self.current_weights, strict=True)
         ]
 
         # m_t
@@ -159,7 +161,7 @@ class FedYogi(FedOpt):
             self.m_t = [np.zeros_like(x) for x in delta_t]
         self.m_t = [
             np.multiply(self.beta_1, x) + (1 - self.beta_1) * y
-            for x, y in zip(self.m_t, delta_t)
+            for x, y in zip(self.m_t, delta_t, strict=True)
         ]
 
         # v_t
@@ -167,12 +169,12 @@ class FedYogi(FedOpt):
             self.v_t = [np.zeros_like(x) for x in delta_t]
         self.v_t = [
             x - (1.0 - self.beta_2) * np.multiply(y, y) * np.sign(x - np.multiply(y, y))
-            for x, y in zip(self.v_t, delta_t)
+            for x, y in zip(self.v_t, delta_t, strict=True)
         ]
 
         new_weights = [
             x + self.eta * y / (np.sqrt(z) + self.tau)
-            for x, y, z in zip(self.current_weights, self.m_t, self.v_t)
+            for x, y, z in zip(self.current_weights, self.m_t, self.v_t, strict=True)
         ]
 
         self.current_weights = new_weights

flwr/server/strategy/krum.py

@@ -20,8 +20,8 @@ Paper: proceedings.neurips.cc/paper/2017/file/f4b9ec30ad9f68f89b29639786cb62ef-P
 """
 
 
+from collections.abc import Callable
 from logging import WARNING
-from typing import Callable, Optional, Union
 
 from flwr.common import (
     FitRes,
@@ -85,18 +85,19 @@ class Krum(FedAvg):
         min_available_clients: int = 2,
         num_malicious_clients: int = 0,
         num_clients_to_keep: int = 0,
-        evaluate_fn: Optional[
+        evaluate_fn: (
             Callable[
                 [int, NDArrays, dict[str, Scalar]],
-                Optional[tuple[float, dict[str, Scalar]]],
+                tuple[float, dict[str, Scalar]] | None,
             ]
-        ] = None,
-        on_fit_config_fn: Optional[Callable[[int], dict[str, Scalar]]] = None,
-        on_evaluate_config_fn: Optional[Callable[[int], dict[str, Scalar]]] = None,
+            | None
+        ) = None,
+        on_fit_config_fn: Callable[[int], dict[str, Scalar]] | None = None,
+        on_evaluate_config_fn: Callable[[int], dict[str, Scalar]] | None = None,
         accept_failures: bool = True,
-        initial_parameters: Optional[Parameters] = None,
-        fit_metrics_aggregation_fn: Optional[MetricsAggregationFn] = None,
-        evaluate_metrics_aggregation_fn: Optional[MetricsAggregationFn] = None,
+        initial_parameters: Parameters | None = None,
+        fit_metrics_aggregation_fn: MetricsAggregationFn | None = None,
+        evaluate_metrics_aggregation_fn: MetricsAggregationFn | None = None,
     ) -> None:
         super().__init__(
             fraction_fit=fraction_fit,
@@ -124,8 +125,8 @@ class Krum(FedAvg):
         self,
         server_round: int,
         results: list[tuple[ClientProxy, FitRes]],
-        failures: list[Union[tuple[ClientProxy, FitRes], BaseException]],
-    ) -> tuple[Optional[Parameters], dict[str, Scalar]]:
+        failures: list[tuple[ClientProxy, FitRes] | BaseException],
+    ) -> tuple[Parameters | None, dict[str, Scalar]]:
         """Aggregate fit results using Krum."""
         if not results:
             return None, {}

flwr/server/strategy/qfedavg.py

@@ -18,8 +18,8 @@ Paper: openreview.net/pdf?id=ByexElSYDr
 """
 
 
+from collections.abc import Callable
 from logging import WARNING
-from typing import Callable, Optional, Union
 
 import numpy as np
 
@@ -58,18 +58,19 @@ class QFedAvg(FedAvg):
         min_fit_clients: int = 1,
         min_evaluate_clients: int = 1,
         min_available_clients: int = 1,
-        evaluate_fn: Optional[
+        evaluate_fn: (
             Callable[
                 [int, NDArrays, dict[str, Scalar]],
-                Optional[tuple[float, dict[str, Scalar]]],
+                tuple[float, dict[str, Scalar]] | None,
             ]
-        ] = None,
-        on_fit_config_fn: Optional[Callable[[int], dict[str, Scalar]]] = None,
-        on_evaluate_config_fn: Optional[Callable[[int], dict[str, Scalar]]] = None,
+            | None
+        ) = None,
+        on_fit_config_fn: Callable[[int], dict[str, Scalar]] | None = None,
+        on_evaluate_config_fn: Callable[[int], dict[str, Scalar]] | None = None,
         accept_failures: bool = True,
-        initial_parameters: Optional[Parameters] = None,
-        fit_metrics_aggregation_fn: Optional[MetricsAggregationFn] = None,
-        evaluate_metrics_aggregation_fn: Optional[MetricsAggregationFn] = None,
+        initial_parameters: Parameters | None = None,
+        fit_metrics_aggregation_fn: MetricsAggregationFn | None = None,
+        evaluate_metrics_aggregation_fn: MetricsAggregationFn | None = None,
     ) -> None:
         super().__init__(
             fraction_fit=fraction_fit,
@@ -87,7 +88,7 @@ class QFedAvg(FedAvg):
         )
         self.learning_rate = qffl_learning_rate
         self.q_param = q_param
-        self.pre_weights: Optional[NDArrays] = None
+        self.pre_weights: NDArrays | None = None
 
     def __repr__(self) -> str:
         """Compute a string representation of the strategy."""
@@ -159,8 +160,8 @@ class QFedAvg(FedAvg):
         self,
         server_round: int,
         results: list[tuple[ClientProxy, FitRes]],
-        failures: list[Union[tuple[ClientProxy, FitRes], BaseException]],
-    ) -> tuple[Optional[Parameters], dict[str, Scalar]]:
+        failures: list[tuple[ClientProxy, FitRes] | BaseException],
+    ) -> tuple[Parameters | None, dict[str, Scalar]]:
         """Aggregate fit results using weighted average."""
         if not results:
             return None, {}
@@ -199,7 +200,7 @@ class QFedAvg(FedAvg):
             # plug in the weight updates into the gradient
             grads = [
                 np.multiply((u - v), 1.0 / self.learning_rate)
-                for u, v in zip(weights_before, new_weights)
+                for u, v in zip(weights_before, new_weights, strict=True)
             ]
             deltas.append(
                 [np.float_power(loss + 1e-10, self.q_param) * grad for grad in grads]
@@ -230,8 +231,8 @@ class QFedAvg(FedAvg):
         self,
         server_round: int,
         results: list[tuple[ClientProxy, EvaluateRes]],
-        failures: list[Union[tuple[ClientProxy, EvaluateRes], BaseException]],
-    ) -> tuple[Optional[float], dict[str, Scalar]]:
+        failures: list[tuple[ClientProxy, EvaluateRes] | BaseException],
+    ) -> tuple[float | None, dict[str, Scalar]]:
         """Aggregate evaluation losses using weighted average."""
         if not results:
             return None, {}

flwr/server/strategy/strategy.py

@@ -16,7 +16,6 @@
 
 
 from abc import ABC, abstractmethod
-from typing import Optional, Union
 
 from flwr.common import EvaluateIns, EvaluateRes, FitIns, FitRes, Parameters, Scalar
 from flwr.server.client_manager import ClientManager
@@ -27,9 +26,7 @@ class Strategy(ABC):
     """Abstract base class for server strategy implementations."""
 
     @abstractmethod
-    def initialize_parameters(
-        self, client_manager: ClientManager
-    ) -> Optional[Parameters]:
+    def initialize_parameters(self, client_manager: ClientManager) -> Parameters | None:
         """Initialize the (global) model parameters.
 
         Parameters
@@ -73,8 +70,8 @@ class Strategy(ABC):
         self,
         server_round: int,
         results: list[tuple[ClientProxy, FitRes]],
-        failures: list[Union[tuple[ClientProxy, FitRes], BaseException]],
-    ) -> tuple[Optional[Parameters], dict[str, Scalar]]:
+        failures: list[tuple[ClientProxy, FitRes] | BaseException],
+    ) -> tuple[Parameters | None, dict[str, Scalar]]:
         """Aggregate training results.
 
         Parameters
@@ -135,8 +132,8 @@ class Strategy(ABC):
         self,
         server_round: int,
         results: list[tuple[ClientProxy, EvaluateRes]],
-        failures: list[Union[tuple[ClientProxy, EvaluateRes], BaseException]],
-    ) -> tuple[Optional[float], dict[str, Scalar]]:
+        failures: list[tuple[ClientProxy, EvaluateRes] | BaseException],
+    ) -> tuple[float | None, dict[str, Scalar]]:
         """Aggregate evaluation results.
 
         Parameters
@@ -164,7 +161,7 @@ class Strategy(ABC):
     @abstractmethod
     def evaluate(
         self, server_round: int, parameters: Parameters
-    ) -> Optional[tuple[float, dict[str, Scalar]]]:
+    ) -> tuple[float, dict[str, Scalar]] | None:
         """Evaluate the current model parameters.
 
         This function can be used to perform centralized (i.e., server-side) evaluation

flwr/server/superlink/fleet/grpc_adapter/grpc_adapter_servicer.py

@@ -15,8 +15,9 @@
 """Fleet API gRPC adapter servicer."""
 
 
+from collections.abc import Callable
 from logging import DEBUG
-from typing import Callable, TypeVar
+from typing import TypeVar
 
 import grpc
 from google.protobuf.message import Message as GrpcMessage
@@ -29,14 +30,15 @@ from flwr.common.constant import (
     GRPC_ADAPTER_METADATA_MESSAGE_QUALNAME_KEY,
 )
 from flwr.common.logger import log
-from flwr.common.version import package_name, package_version
 from flwr.proto import grpcadapter_pb2_grpc  # pylint: disable=E0611
 from flwr.proto.fab_pb2 import GetFabRequest  # pylint: disable=E0611
 from flwr.proto.fleet_pb2 import (  # pylint: disable=E0611
-    CreateNodeRequest,
-    DeleteNodeRequest,
+    ActivateNodeRequest,
+    DeactivateNodeRequest,
     PullMessagesRequest,
     PushMessagesRequest,
+    RegisterNodeFleetRequest,
+    UnregisterNodeFleetRequest,
 )
 from flwr.proto.grpcadapter_pb2 import MessageContainer  # pylint: disable=E0611
 from flwr.proto.heartbeat_pb2 import SendNodeHeartbeatRequest  # pylint: disable=E0611
@@ -46,6 +48,7 @@ from flwr.proto.message_pb2 import (  # pylint: disable=E0611
     PushObjectRequest,
 )
 from flwr.proto.run_pb2 import GetRunRequest  # pylint: disable=E0611
+from flwr.supercore.version import package_name, package_version
 
 from ..grpc_rere.fleet_servicer import FleetServicer
 
@@ -77,15 +80,23 @@ def _handle(
 class GrpcAdapterServicer(grpcadapter_pb2_grpc.GrpcAdapterServicer, FleetServicer):
     """Fleet API via GrpcAdapter servicer."""
 
-    def SendReceive(  # pylint: disable=too-many-return-statements
+    def SendReceive(  # pylint: disable=too-many-return-statements, too-many-branches
         self, request: MessageContainer, context: grpc.ServicerContext
     ) -> MessageContainer:
         """."""
         log(DEBUG, "GrpcAdapterServicer.SendReceive")
-        if request.grpc_message_name == CreateNodeRequest.__qualname__:
-            return _handle(request, context, CreateNodeRequest, self.CreateNode)
-        if request.grpc_message_name == DeleteNodeRequest.__qualname__:
-            return _handle(request, context, DeleteNodeRequest, self.DeleteNode)
+        if request.grpc_message_name == RegisterNodeFleetRequest.__qualname__:
+            return _handle(
+                request, context, RegisterNodeFleetRequest, self.RegisterNode
+            )
+        if request.grpc_message_name == ActivateNodeRequest.__qualname__:
+            return _handle(request, context, ActivateNodeRequest, self.ActivateNode)
+        if request.grpc_message_name == DeactivateNodeRequest.__qualname__:
+            return _handle(request, context, DeactivateNodeRequest, self.DeactivateNode)
+        if request.grpc_message_name == UnregisterNodeFleetRequest.__qualname__:
+            return _handle(
+                request, context, UnregisterNodeFleetRequest, self.UnregisterNode
+            )
         if request.grpc_message_name == SendNodeHeartbeatRequest.__qualname__:
             return _handle(
                 request, context, SendNodeHeartbeatRequest, self.SendNodeHeartbeat

flwr/server/superlink/fleet/grpc_bidi/flower_service_servicer.py

@@ -20,8 +20,7 @@ Relevant knowledge for reading this modules code:
 
 
 import uuid
-from collections.abc import Iterator
-from typing import Callable
+from collections.abc import Callable, Iterator
 
 import grpc
 from iterators import TimeoutIterator

flwr/server/superlink/fleet/grpc_bidi/grpc_bridge.py

@@ -19,7 +19,6 @@ from collections.abc import Iterator
 from dataclasses import dataclass
 from enum import Enum
 from threading import Condition
-from typing import Optional
 
 from flwr.proto.transport_pb2 import (  # pylint: disable=E0611
     ClientMessage,
@@ -32,7 +31,7 @@ class InsWrapper:
     """Instruction wrapper class for a single server message."""
 
     server_message: ServerMessage
-    timeout: Optional[float]
+    timeout: float | None
 
 
 @dataclass
@@ -70,8 +69,8 @@ class GrpcBridge:
         # pylint: disable=unsubscriptable-object
         self._cv = Condition()  # cv stands for condition variable
         self._status = Status.AWAITING_INS_WRAPPER
-        self._ins_wrapper: Optional[InsWrapper] = None
-        self._res_wrapper: Optional[ResWrapper] = None
+        self._ins_wrapper: InsWrapper | None = None
+        self._res_wrapper: ResWrapper | None = None
 
     def _is_closed(self) -> bool:
         """Return True if closed and False otherwise."""

flwr/server/superlink/fleet/grpc_bidi/grpc_client_proxy.py

@@ -15,8 +15,6 @@
 """Flower ClientProxy implementation using gRPC bidirectional streaming."""
 
 
-from typing import Optional
-
 from flwr import common
 from flwr.common import serde
 from flwr.proto.transport_pb2 import (  # pylint: disable=E0611
@@ -45,8 +43,8 @@ class GrpcClientProxy(ClientProxy):
     def get_properties(
         self,
         ins: common.GetPropertiesIns,
-        timeout: Optional[float],
-        group_id: Optional[int],
+        timeout: float | None,
+        group_id: int | None,
     ) -> common.GetPropertiesRes:
         """Request client's set of internal properties."""
         get_properties_msg = serde.get_properties_ins_to_proto(ins)
@@ -65,8 +63,8 @@ class GrpcClientProxy(ClientProxy):
     def get_parameters(
         self,
         ins: common.GetParametersIns,
-        timeout: Optional[float],
-        group_id: Optional[int],
+        timeout: float | None,
+        group_id: int | None,
     ) -> common.GetParametersRes:
         """Return the current local model parameters."""
         get_parameters_msg = serde.get_parameters_ins_to_proto(ins)
@@ -85,8 +83,8 @@ class GrpcClientProxy(ClientProxy):
     def fit(
         self,
         ins: common.FitIns,
-        timeout: Optional[float],
-        group_id: Optional[int],
+        timeout: float | None,
+        group_id: int | None,
     ) -> common.FitRes:
         """Refine the provided parameters using the locally held dataset."""
         fit_ins_msg = serde.fit_ins_to_proto(ins)
@@ -104,8 +102,8 @@ class GrpcClientProxy(ClientProxy):
     def evaluate(
         self,
         ins: common.EvaluateIns,
-        timeout: Optional[float],
-        group_id: Optional[int],
+        timeout: float | None,
+        group_id: int | None,
     ) -> common.EvaluateRes:
         """Evaluate the provided parameters using the locally held dataset."""
         evaluate_msg = serde.evaluate_ins_to_proto(ins)
@@ -122,8 +120,8 @@ class GrpcClientProxy(ClientProxy):
     def reconnect(
         self,
         ins: common.ReconnectIns,
-        timeout: Optional[float],
-        group_id: Optional[int],
+        timeout: float | None,
+        group_id: int | None,
     ) -> common.DisconnectRes:
         """Disconnect and (optionally) reconnect later."""
         reconnect_ins_msg = serde.reconnect_ins_to_proto(ins)

flwr/server/superlink/fleet/grpc_bidi/grpc_server.py

@@ -15,8 +15,6 @@
 """Implements utility function to create a gRPC server."""
 
 
-from typing import Optional
-
 import grpc
 
 from flwr.common import GRPC_MAX_MESSAGE_LENGTH
@@ -36,7 +34,7 @@ def start_grpc_server(  # pylint: disable=too-many-arguments,R0917
     max_concurrent_workers: int = 1000,
     max_message_length: int = GRPC_MAX_MESSAGE_LENGTH,
     keepalive_time_ms: int = 210000,
-    certificates: Optional[tuple[bytes, bytes, bytes]] = None,
+    certificates: tuple[bytes, bytes, bytes] | None = None,
 ) -> grpc.Server:
     """Create and start a gRPC server running FlowerServiceServicer.