flwr 1.23.0__py3-none-any.whl → 1.24.0__py3-none-any.whl

flwr/server/strategy/fedavgm.py

@@ -18,8 +18,8 @@ Paper: arxiv.org/pdf/1909.06335.pdf
 """
 
 
+from collections.abc import Callable
 from logging import WARNING
-from typing import Callable, Optional, Union
 
 from flwr.common import (
     FitRes,
@@ -82,18 +82,19 @@ class FedAvgM(FedAvg):
         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: 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,
         server_learning_rate: float = 1.0,
         server_momentum: float = 0.0,
     ) -> None:
@@ -116,16 +117,14 @@ class FedAvgM(FedAvg):
         self.server_opt: bool = (self.server_momentum != 0.0) or (
             self.server_learning_rate != 1.0
         )
-        self.momentum_vector: Optional[NDArrays] = None
+        self.momentum_vector: NDArrays | None = None
 
     def __repr__(self) -> str:
         """Compute a string representation of the strategy."""
         rep = f"FedAvgM(accept_failures={self.accept_failures})"
         return rep
 
-    def initialize_parameters(
-        self, client_manager: ClientManager
-    ) -> Optional[Parameters]:
+    def initialize_parameters(self, client_manager: ClientManager) -> Parameters | None:
         """Initialize global model parameters."""
         return self.initial_parameters
 
@@ -133,8 +132,8 @@ class FedAvgM(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, {}
@@ -161,7 +160,9 @@ class FedAvgM(FedAvg):
             pseudo_gradient: NDArrays = [
                 x - y
                 for x, y in zip(
-                    parameters_to_ndarrays(self.initial_parameters), fedavg_result
+                    parameters_to_ndarrays(self.initial_parameters),
+                    fedavg_result,
+                    strict=True,
                 )
             ]
             if self.server_momentum > 0.0:
@@ -171,7 +172,9 @@ class FedAvgM(FedAvg):
                     ), "Momentum should have been created on round 1."
                     self.momentum_vector = [
                         self.server_momentum * x + y
-                        for x, y in zip(self.momentum_vector, pseudo_gradient)
+                        for x, y in zip(
+                            self.momentum_vector, pseudo_gradient, strict=True
+                        )
                     ]
                 else:
                     self.momentum_vector = pseudo_gradient
@@ -182,7 +185,7 @@ class FedAvgM(FedAvg):
             # SGD
             fedavg_result = [
                 x - self.server_learning_rate * y
-                for x, y in zip(initial_weights, pseudo_gradient)
+                for x, y in zip(initial_weights, pseudo_gradient, strict=True)
             ]
             # Update current weights
             self.initial_parameters = ndarrays_to_parameters(fedavg_result)

flwr/server/strategy/fedmedian.py

@@ -19,7 +19,6 @@ Paper: arxiv.org/pdf/1803.01498v1.pdf
 
 
 from logging import WARNING
-from typing import Optional, Union
 
 from flwr.common import (
     FitRes,
@@ -47,8 +46,8 @@ class FedMedian(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 median."""
         if not results:
             return None, {}

flwr/server/strategy/fedopt.py

@@ -18,7 +18,7 @@ Paper: arxiv.org/abs/2003.00295
 """
 
 
-from typing import Callable, Optional
+from collections.abc import Callable
 
 from flwr.common import (
     MetricsAggregationFn,
@@ -84,18 +84,19 @@ class FedOpt(FedAvg):
         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-1,
         eta_l: float = 1e-1,
         beta_1: float = 0.0,
@@ -122,8 +123,8 @@ class FedOpt(FedAvg):
         self.tau = tau
         self.beta_1 = beta_1
         self.beta_2 = beta_2
-        self.m_t: Optional[NDArrays] = None
-        self.v_t: Optional[NDArrays] = None
+        self.m_t: NDArrays | None = None
+        self.v_t: NDArrays | None = None
 
     def __repr__(self) -> str:
         """Compute a string representation of the strategy."""

flwr/server/strategy/fedprox.py

@@ -18,7 +18,7 @@ Paper: arxiv.org/abs/1812.06127
 """
 
 
-from typing import Callable, Optional
+from collections.abc import Callable
 
 from flwr.common import FitIns, MetricsAggregationFn, NDArrays, Parameters, Scalar
 from flwr.server.client_manager import ClientManager
@@ -111,18 +111,19 @@ class FedProx(FedAvg):
         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: 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,
         proximal_mu: float,
     ) -> None:
         super().__init__(

flwr/server/strategy/fedtrimmedavg.py

@@ -16,8 +16,8 @@
 
 Paper: arxiv.org/abs/1803.01498
 """
+from collections.abc import Callable
 from logging import WARNING
-from typing import Callable, Optional, Union
 
 from flwr.common import (
     FitRes,
@@ -76,18 +76,19 @@ class FedTrimmedAvg(FedAvg):
         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: 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,
         beta: float = 0.2,
     ) -> None:
         super().__init__(
@@ -115,8 +116,8 @@ class FedTrimmedAvg(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 trimmed average."""
         if not results:
             return None, {}

flwr/server/strategy/fedxgb_bagging.py

@@ -16,8 +16,9 @@
 
 
 import json
+from collections.abc import Callable
 from logging import WARNING
-from typing import Any, Callable, Optional, Union, cast
+from typing import Any, cast
 
 from flwr.common import EvaluateRes, FitRes, Parameters, Scalar
 from flwr.common.logger import log
@@ -32,16 +33,17 @@ class FedXgbBagging(FedAvg):
     # pylint: disable=too-many-arguments,too-many-instance-attributes, line-too-long
     def __init__(
         self,
-        evaluate_function: Optional[
+        evaluate_function: (
             Callable[
                 [int, Parameters, dict[str, Scalar]],
-                Optional[tuple[float, dict[str, Scalar]]],
+                tuple[float, dict[str, Scalar]] | None,
             ]
-        ] = None,
+            | None
+        ) = None,
         **kwargs: Any,
     ):
         self.evaluate_function = evaluate_function
-        self.global_model: Optional[bytes] = None
+        self.global_model: bytes | None = None
         super().__init__(**kwargs)
 
     def __repr__(self) -> str:
@@ -53,8 +55,8 @@ class FedXgbBagging(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, {}
@@ -80,8 +82,8 @@ class FedXgbBagging(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, {}
@@ -101,7 +103,7 @@ class FedXgbBagging(FedAvg):
 
     def evaluate(
         self, server_round: int, parameters: Parameters
-    ) -> Optional[tuple[float, dict[str, Scalar]]]:
+    ) -> tuple[float, dict[str, Scalar]] | None:
         """Evaluate model parameters using an evaluation function."""
         if self.evaluate_function is None:
             # No evaluation function provided
@@ -114,7 +116,7 @@ class FedXgbBagging(FedAvg):
 
 
 def aggregate(
-    bst_prev_org: Optional[bytes],
+    bst_prev_org: bytes | None,
     bst_curr_org: bytes,
 ) -> bytes:
     """Conduct bagging aggregation for given trees."""

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