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

flwr/server/serverapp/app.py

@@ -19,7 +19,8 @@ import argparse
 from logging import DEBUG, ERROR, INFO
 from pathlib import Path
 from queue import Queue
-from typing import Optional
+
+import grpc
 
 from flwr.app.exception import AppExitException
 from flwr.cli.config_utils import get_fab_metadata
@@ -38,8 +39,7 @@ from flwr.common.constant import (
     Status,
     SubStatus,
 )
-from flwr.common.exit import ExitCode, add_exit_handler, flwr_exit
-from flwr.common.heartbeat import HeartbeatSender, get_grpc_app_heartbeat_fn
+from flwr.common.exit import ExitCode, flwr_exit, register_signal_handlers
 from flwr.common.logger import (
     log,
     mirror_output_to_queue,
@@ -66,6 +66,7 @@ from flwr.proto.serverappio_pb2_grpc import ServerAppIoStub
 from flwr.server.grid.grpc_grid import GrpcGrid
 from flwr.server.run_serverapp import run as run_
 from flwr.supercore.app_utils import start_parent_process_monitor
+from flwr.supercore.heartbeat import HeartbeatSender, make_app_heartbeat_fn_grpc
 from flwr.supercore.superexec.plugin import ServerAppExecPlugin
 from flwr.supercore.superexec.run_superexec import run_with_deprecation_warning
 
@@ -73,7 +74,7 @@ from flwr.supercore.superexec.run_superexec import run_with_deprecation_warning
 def flwr_serverapp() -> None:
     """Run process-isolated Flower ServerApp."""
     # Capture stdout/stderr
-    log_queue: Queue[Optional[str]] = Queue()
+    log_queue: Queue[str | None] = Queue()
     mirror_output_to_queue(log_queue)
 
     args = _parse_args_run_flwr_serverapp().parse_args()
@@ -120,21 +121,22 @@ def flwr_serverapp() -> None:
 
 def run_serverapp(  # pylint: disable=R0913, R0914, R0915, R0917, W0212
     serverappio_api_address: str,
-    log_queue: Queue[Optional[str]],
+    log_queue: Queue[str | None],
     token: str,
-    flwr_dir: Optional[str] = None,
-    certificates: Optional[bytes] = None,
-    parent_pid: Optional[int] = None,
+    flwr_dir: str | None = None,
+    certificates: bytes | None = None,
+    parent_pid: int | None = None,
 ) -> None:
     """Run Flower ServerApp process."""
     # Monitor the main process in case of SIGKILL
     if parent_pid is not None:
         start_parent_process_monitor(parent_pid)
 
-    # Resolve directory where FABs are installed
+    # Initialize variables for exit handler
     flwr_dir_ = get_flwr_dir(flwr_dir)
     log_uploader = None
     hash_run_id = None
+    run = None
     run_status = None
     heartbeat_sender = None
     grid = None
@@ -143,7 +145,7 @@ def run_serverapp(  # pylint: disable=R0913, R0914, R0915, R0917, W0212
 
     def on_exit() -> None:
         # Stop heartbeat sender
-        if heartbeat_sender:
+        if heartbeat_sender and heartbeat_sender.is_running:
             heartbeat_sender.stop()
 
         # Stop log uploader for this run and upload final logs
@@ -151,7 +153,7 @@ def run_serverapp(  # pylint: disable=R0913, R0914, R0915, R0917, W0212
             stop_log_uploader(log_queue, log_uploader)
 
         # Update run status
-        if run_status and grid:
+        if run and run_status and grid:
             run_status_proto = run_status_to_proto(run_status)
             grid._stub.UpdateRunStatus(
                 UpdateRunStatusRequest(run_id=run.run_id, run_status=run_status_proto)
@@ -161,7 +163,12 @@ def run_serverapp(  # pylint: disable=R0913, R0914, R0915, R0917, W0212
         if grid:
             grid.close()
 
-    add_exit_handler(on_exit)
+    # Register signal handlers for graceful shutdown
+    register_signal_handlers(
+        event_type=EventType.FLWR_SERVERAPP_RUN_LEAVE,
+        exit_message="Run stopped by user.",
+        exit_handlers=[on_exit],
+    )
 
     try:
         # Initialize the GrpcGrid
@@ -171,9 +178,14 @@ def run_serverapp(  # pylint: disable=R0913, R0914, R0915, R0917, W0212
         )
 
         # Pull ServerAppInputs from LinkState
-        req = PullAppInputsRequest(token=token)
-        log(DEBUG, "[flwr-serverapp] Pull ServerAppInputs")
-        res: PullAppInputsResponse = grid._stub.PullAppInputs(req)
+        try:
+            log(DEBUG, "[flwr-serverapp] Pull ServerAppInputs")
+            req = PullAppInputsRequest(token=token)
+            res: PullAppInputsResponse = grid._stub.PullAppInputs(req)
+        except grpc.RpcError as ex:
+            if ex.code() == grpc.StatusCode.FAILED_PRECONDITION:
+                raise RuntimeError("Failed to start the run.") from ex
+            raise
         context = context_from_proto(res.context)
         run = run_from_proto(res.run)
         fab = fab_from_proto(res.fab)
@@ -214,25 +226,15 @@ def run_serverapp(  # pylint: disable=R0913, R0914, R0915, R0917, W0212
             app_path,
         )
 
-        # Change status to Running
-        run_status_proto = run_status_to_proto(RunStatus(Status.RUNNING, "", ""))
-        grid._stub.UpdateRunStatus(
-            UpdateRunStatusRequest(run_id=run.run_id, run_status=run_status_proto)
-        )
-
         event(
             EventType.FLWR_SERVERAPP_RUN_ENTER,
             event_details={"run-id-hash": hash_run_id},
         )
 
         # Set up heartbeat sender
-        heartbeat_fn = get_grpc_app_heartbeat_fn(
-            grid._stub,
-            run.run_id,
-            failure_message="Heartbeat failed unexpectedly. The SuperLink could "
-            "not find the provided run ID, or the run status is invalid.",
+        heartbeat_sender = HeartbeatSender(
+            make_app_heartbeat_fn_grpc(grid._stub, token)
         )
-        heartbeat_sender = HeartbeatSender(heartbeat_fn)
         heartbeat_sender.start()
 
         # Load and run the ServerApp with the Grid
@@ -256,11 +258,15 @@ def run_serverapp(  # pylint: disable=R0913, R0914, R0915, R0917, W0212
     # Raised when the run is already stopped by the user
     except RunNotRunningException:
         log(INFO, "")
-        log(INFO, "Run ID %s stopped.", run.run_id)
+        log(INFO, "Run ID %s stopped.", run.run_id)  # type: ignore[union-attr]
         log(INFO, "")
         run_status = None
         # No need to update the exit code since this is expected behavior
 
+    except RuntimeError:
+        log(ERROR, "Failed to start run.")
+        exit_code = ExitCode.SERVERAPP_RUN_START_REJECTED
+
     except Exception as ex:  # pylint: disable=broad-exception-caught
         exc_entity = "ServerApp"
         log(ERROR, "%s raised an exception", exc_entity, exc_info=ex)

flwr/server/serverapp_components.py

@@ -16,7 +16,6 @@
 
 
 from dataclasses import dataclass
-from typing import Optional
 
 from .client_manager import ClientManager
 from .server import Server
@@ -46,7 +45,7 @@ class ServerAppComponents:  # pylint: disable=too-many-instance-attributes
         will be used.
     """
 
-    server: Optional[Server] = None
-    config: Optional[ServerConfig] = None
-    strategy: Optional[Strategy] = None
-    client_manager: Optional[ClientManager] = None
+    server: Server | None = None
+    config: ServerConfig | None = None
+    strategy: Strategy | None = None
+    client_manager: ClientManager | None = None

flwr/server/strategy/aggregate.py

@@ -15,8 +15,9 @@
 """Aggregation functions for strategy implementations."""
 # mypy: disallow_untyped_calls=False
 
+from collections.abc import Callable
 from functools import partial, reduce
-from typing import Any, Callable, Union
+from typing import Any
 
 import numpy as np
 
@@ -37,7 +38,7 @@ def aggregate(results: list[tuple[NDArrays, int]]) -> NDArrays:
     # Compute average weights of each layer
     weights_prime: NDArrays = [
         reduce(np.add, layer_updates) / num_examples_total
-        for layer_updates in zip(*weighted_weights)
+        for layer_updates in zip(*weighted_weights, strict=True)
     ]
     return weights_prime
 
@@ -53,7 +54,7 @@ def aggregate_inplace(results: list[tuple[ClientProxy, FitRes]]) -> NDArrays:
     )
 
     def _try_inplace(
-        x: NDArray, y: Union[NDArray, np.float64], np_binary_op: np.ufunc
+        x: NDArray, y: NDArray | np.float64, np_binary_op: np.ufunc
     ) -> NDArray:
         return (  # type: ignore[no-any-return]
             np_binary_op(x, y, out=x)
@@ -75,7 +76,7 @@ def aggregate_inplace(results: list[tuple[ClientProxy, FitRes]]) -> NDArrays:
         )
         params = [
             reduce(partial(_try_inplace, np_binary_op=np.add), layer_updates)
-            for layer_updates in zip(params, res)
+            for layer_updates in zip(params, res, strict=True)
         ]
 
     return params
@@ -88,7 +89,7 @@ def aggregate_median(results: list[tuple[NDArrays, int]]) -> NDArrays:
 
     # Compute median weight of each layer
     median_w: NDArrays = [
-        np.median(np.asarray(layer), axis=0) for layer in zip(*weights)
+        np.median(np.asarray(layer), axis=0) for layer in zip(*weights, strict=True)
     ]
     return median_w
 
@@ -235,7 +236,7 @@ def aggregate_qffl(
         for j in range(1, len(deltas)):
             tmp += scaled_deltas[j][i]
         updates.append(tmp)
-    new_parameters = [(u - v) * 1.0 for u, v in zip(parameters, updates)]
+    new_parameters = [(u - v) * 1.0 for u, v in zip(parameters, updates, strict=True)]
     return new_parameters
 
 
@@ -287,7 +288,7 @@ def aggregate_trimmed_avg(
 
     trimmed_w: NDArrays = [
         _trim_mean(np.asarray(layer), proportiontocut=proportiontocut)
-        for layer in zip(*weights)
+        for layer in zip(*weights, strict=True)
     ]
 
     return trimmed_w
@@ -299,7 +300,7 @@ def _check_weights_equality(weights1: NDArrays, weights2: NDArrays) -> bool:
         return False
     return all(
         np.array_equal(layer_weights1, layer_weights2)
-        for layer_weights1, layer_weights2 in zip(weights1, weights2)
+        for layer_weights1, layer_weights2 in zip(weights1, weights2, strict=True)
     )
 
 

flwr/server/strategy/bulyan.py

@@ -18,8 +18,9 @@ Paper: arxiv.org/abs/1802.07927
 """
 
 
+from collections.abc import Callable
 from logging import WARNING
-from typing import Any, Callable, Optional, Union
+from typing import Any
 
 from flwr.common import (
     FitRes,
@@ -84,18 +85,19 @@ class Bulyan(FedAvg):
         min_evaluate_clients: int = 2,
         min_available_clients: int = 2,
         num_malicious_clients: 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,
         first_aggregation_rule: Callable = aggregate_krum,  # type: ignore
         **aggregation_rule_kwargs: Any,
     ) -> None:
@@ -126,8 +128,8 @@ class Bulyan(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 Bulyan."""
         if not results:
             return None, {}

flwr/server/strategy/dp_adaptive_clipping.py

@@ -20,7 +20,6 @@ Paper (Andrew et al.): https://arxiv.org/abs/1905.03871
 
 import math
 from logging import INFO, WARNING
-from typing import Optional, Union
 
 import numpy as np
 
@@ -97,7 +96,7 @@ class DifferentialPrivacyServerSideAdaptiveClipping(Strategy):
         initial_clipping_norm: float = 0.1,
         target_clipped_quantile: float = 0.5,
         clip_norm_lr: float = 0.2,
-        clipped_count_stddev: Optional[float] = None,
+        clipped_count_stddev: float | None = None,
     ) -> None:
         super().__init__()
 
@@ -148,9 +147,7 @@ class DifferentialPrivacyServerSideAdaptiveClipping(Strategy):
         rep = "Differential Privacy Strategy Wrapper (Server-Side Adaptive Clipping)"
         return rep
 
-    def initialize_parameters(
-        self, client_manager: ClientManager
-    ) -> Optional[Parameters]:
+    def initialize_parameters(self, client_manager: ClientManager) -> Parameters | None:
         """Initialize global model parameters using given strategy."""
         return self.strategy.initialize_parameters(client_manager)
 
@@ -173,8 +170,8 @@ class DifferentialPrivacyServerSideAdaptiveClipping(Strategy):
         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 and update clip norms."""
         if failures:
             return None, {}
@@ -192,7 +189,8 @@ class DifferentialPrivacyServerSideAdaptiveClipping(Strategy):
             param = parameters_to_ndarrays(res.parameters)
             # Compute and clip update
             model_update = [
-                np.subtract(x, y) for (x, y) in zip(param, self.current_round_params)
+                np.subtract(x, y)
+                for (x, y) in zip(param, self.current_round_params, strict=True)
             ]
 
             norm_bit = adaptive_clip_inputs_inplace(model_update, self.clipping_norm)
@@ -246,14 +244,14 @@ class DifferentialPrivacyServerSideAdaptiveClipping(Strategy):
         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 the given strategy."""
         return self.strategy.aggregate_evaluate(server_round, results, failures)
 
     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 from the strategy."""
         return self.strategy.evaluate(server_round, parameters)
 
@@ -316,7 +314,7 @@ class DifferentialPrivacyClientSideAdaptiveClipping(Strategy):
         initial_clipping_norm: float = 0.1,
         target_clipped_quantile: float = 0.5,
         clip_norm_lr: float = 0.2,
-        clipped_count_stddev: Optional[float] = None,
+        clipped_count_stddev: float | None = None,
     ) -> None:
         super().__init__()
 
@@ -364,9 +362,7 @@ class DifferentialPrivacyClientSideAdaptiveClipping(Strategy):
         rep = "Differential Privacy Strategy Wrapper (Client-Side Adaptive Clipping)"
         return rep
 
-    def initialize_parameters(
-        self, client_manager: ClientManager
-    ) -> Optional[Parameters]:
+    def initialize_parameters(self, client_manager: ClientManager) -> Parameters | None:
         """Initialize global model parameters using given strategy."""
         return self.strategy.initialize_parameters(client_manager)
 
@@ -395,8 +391,8 @@ class DifferentialPrivacyClientSideAdaptiveClipping(Strategy):
         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 and update clip norms."""
         if failures:
             return None, {}
@@ -458,13 +454,13 @@ class DifferentialPrivacyClientSideAdaptiveClipping(Strategy):
         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 the given strategy."""
         return self.strategy.aggregate_evaluate(server_round, results, failures)
 
     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 from the strategy."""
         return self.strategy.evaluate(server_round, parameters)

flwr/server/strategy/dp_fixed_clipping.py

@@ -19,7 +19,6 @@ Papers: https://arxiv.org/abs/1712.07557, https://arxiv.org/abs/1710.06963
 
 
 from logging import INFO, WARNING
-from typing import Optional, Union
 
 from flwr.common import (
     EvaluateIns,
@@ -109,9 +108,7 @@ class DifferentialPrivacyServerSideFixedClipping(Strategy):
         rep = "Differential Privacy Strategy Wrapper (Server-Side Fixed Clipping)"
         return rep
 
-    def initialize_parameters(
-        self, client_manager: ClientManager
-    ) -> Optional[Parameters]:
+    def initialize_parameters(self, client_manager: ClientManager) -> Parameters | None:
         """Initialize global model parameters using given strategy."""
         return self.strategy.initialize_parameters(client_manager)
 
@@ -134,8 +131,8 @@ class DifferentialPrivacyServerSideFixedClipping(Strategy):
         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]]:
         """Compute the updates, clip, and pass them for aggregation.
 
         Afterward, add noise to the aggregated parameters.
@@ -192,14 +189,14 @@ class DifferentialPrivacyServerSideFixedClipping(Strategy):
         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 the given strategy."""
         return self.strategy.aggregate_evaluate(server_round, results, failures)
 
     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 from the strategy."""
         return self.strategy.evaluate(server_round, parameters)
 
@@ -277,9 +274,7 @@ class DifferentialPrivacyClientSideFixedClipping(Strategy):
         rep = "Differential Privacy Strategy Wrapper (Client-Side Fixed Clipping)"
         return rep
 
-    def initialize_parameters(
-        self, client_manager: ClientManager
-    ) -> Optional[Parameters]:
+    def initialize_parameters(self, client_manager: ClientManager) -> Parameters | None:
         """Initialize global model parameters using given strategy."""
         return self.strategy.initialize_parameters(client_manager)
 
@@ -308,8 +303,8 @@ class DifferentialPrivacyClientSideFixedClipping(Strategy):
         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]]:
         """Add noise to the aggregated parameters."""
         if failures:
             return None, {}
@@ -349,13 +344,13 @@ class DifferentialPrivacyClientSideFixedClipping(Strategy):
         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 the given strategy."""
         return self.strategy.aggregate_evaluate(server_round, results, failures)
 
     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 from the strategy."""
         return self.strategy.evaluate(server_round, parameters)

flwr/server/strategy/dpfedavg_adaptive.py

@@ -19,7 +19,6 @@ Paper: arxiv.org/pdf/1905.03871.pdf
 
 
 import math
-from typing import Optional, Union
 
 import numpy as np
 
@@ -49,7 +48,7 @@ class DPFedAvgAdaptive(DPFedAvgFixed):
         server_side_noising: bool = True,
         clip_norm_lr: float = 0.2,
         clip_norm_target_quantile: float = 0.5,
-        clip_count_stddev: Optional[float] = None,
+        clip_count_stddev: float | None = None,
     ) -> None:
         warn_deprecated_feature("`DPFedAvgAdaptive` wrapper")
         super().__init__(
@@ -119,8 +118,8 @@ class DPFedAvgAdaptive(DPFedAvgFixed):
         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 as in DPFedAvgFixed and update clip norms."""
         if failures:
             return None, {}

flwr/server/strategy/dpfedavg_fixed.py

@@ -18,8 +18,6 @@ Paper: arxiv.org/pdf/1710.06963.pdf
 """
 
 
-from typing import Optional, Union
-
 from flwr.common import EvaluateIns, EvaluateRes, FitIns, FitRes, Parameters, Scalar
 from flwr.common.dp import add_gaussian_noise
 from flwr.common.logger import warn_deprecated_feature
@@ -72,9 +70,7 @@ class DPFedAvgFixed(Strategy):
             self.noise_multiplier * self.clip_norm / (self.num_sampled_clients ** (0.5))
         )
 
-    def initialize_parameters(
-        self, client_manager: ClientManager
-    ) -> Optional[Parameters]:
+    def initialize_parameters(self, client_manager: ClientManager) -> Parameters | None:
         """Initialize global model parameters using given strategy."""
         return self.strategy.initialize_parameters(client_manager)
 
@@ -149,8 +145,8 @@ class DPFedAvgFixed(Strategy):
         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 using unweighted aggregation."""
         if failures:
             return None, {}
@@ -170,13 +166,13 @@ class DPFedAvgFixed(Strategy):
         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 the given strategy."""
         return self.strategy.aggregate_evaluate(server_round, results, failures)
 
     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 from the strategy."""
         return self.strategy.evaluate(server_round, parameters)

flwr/server/strategy/fault_tolerant_fedavg.py

@@ -15,8 +15,8 @@
 """Fault-tolerant variant of FedAvg strategy."""
 
 
+from collections.abc import Callable
 from logging import WARNING
-from typing import Callable, Optional, Union
 
 from flwr.common import (
     EvaluateRes,
@@ -47,19 +47,20 @@ class FaultTolerantFedAvg(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,
         min_completion_rate_fit: float = 0.5,
         min_completion_rate_evaluate: float = 0.5,
-        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,
@@ -86,8 +87,8 @@ class FaultTolerantFedAvg(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, {}
@@ -118,8 +119,8 @@ class FaultTolerantFedAvg(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, {}