flwr-nightly 1.12.0.dev20240907__py3-none-any.whl → 1.12.0.dev20240913__py3-none-any.whl

flwr/server/server.py

@@ -19,7 +19,7 @@ import concurrent.futures
 import io
 import timeit
 from logging import INFO, WARN
-from typing import Dict, List, Optional, Tuple, Union
+from typing import Optional, Union
 
 from flwr.common import (
     Code,
@@ -41,17 +41,17 @@ from flwr.server.strategy import FedAvg, Strategy
 
 from .server_config import ServerConfig
 
-FitResultsAndFailures = Tuple[
-    List[Tuple[ClientProxy, FitRes]],
-    List[Union[Tuple[ClientProxy, FitRes], BaseException]],
+FitResultsAndFailures = tuple[
+    list[tuple[ClientProxy, FitRes]],
+    list[Union[tuple[ClientProxy, FitRes], BaseException]],
 ]
-EvaluateResultsAndFailures = Tuple[
-    List[Tuple[ClientProxy, EvaluateRes]],
-    List[Union[Tuple[ClientProxy, EvaluateRes], BaseException]],
+EvaluateResultsAndFailures = tuple[
+    list[tuple[ClientProxy, EvaluateRes]],
+    list[Union[tuple[ClientProxy, EvaluateRes], BaseException]],
 ]
-ReconnectResultsAndFailures = Tuple[
-    List[Tuple[ClientProxy, DisconnectRes]],
-    List[Union[Tuple[ClientProxy, DisconnectRes], BaseException]],
+ReconnectResultsAndFailures = tuple[
+    list[tuple[ClientProxy, DisconnectRes]],
+    list[Union[tuple[ClientProxy, DisconnectRes], BaseException]],
 ]
 
 
@@ -84,7 +84,7 @@ class Server:
         return self._client_manager
 
     # pylint: disable=too-many-locals
-    def fit(self, num_rounds: int, timeout: Optional[float]) -> Tuple[History, float]:
+    def fit(self, num_rounds: int, timeout: Optional[float]) -> tuple[History, float]:
         """Run federated averaging for a number of rounds."""
         history = History()
 
@@ -163,7 +163,7 @@ class Server:
         server_round: int,
         timeout: Optional[float],
     ) -> Optional[
-        Tuple[Optional[float], Dict[str, Scalar], EvaluateResultsAndFailures]
+        tuple[Optional[float], dict[str, Scalar], EvaluateResultsAndFailures]
     ]:
         """Validate current global model on a number of clients."""
         # Get clients and their respective instructions from strategy
@@ -197,9 +197,9 @@ class Server:
         )
 
         # Aggregate the evaluation results
-        aggregated_result: Tuple[
+        aggregated_result: tuple[
             Optional[float],
-            Dict[str, Scalar],
+            dict[str, Scalar],
         ] = self.strategy.aggregate_evaluate(server_round, results, failures)
 
         loss_aggregated, metrics_aggregated = aggregated_result
@@ -210,7 +210,7 @@ class Server:
         server_round: int,
         timeout: Optional[float],
     ) -> Optional[
-        Tuple[Optional[Parameters], Dict[str, Scalar], FitResultsAndFailures]
+        tuple[Optional[Parameters], dict[str, Scalar], FitResultsAndFailures]
     ]:
         """Perform a single round of federated averaging."""
         # Get clients and their respective instructions from strategy
@@ -245,9 +245,9 @@ class Server:
         )
 
         # Aggregate training results
-        aggregated_result: Tuple[
+        aggregated_result: tuple[
             Optional[Parameters],
-            Dict[str, Scalar],
+            dict[str, Scalar],
         ] = self.strategy.aggregate_fit(server_round, results, failures)
 
         parameters_aggregated, metrics_aggregated = aggregated_result
@@ -296,7 +296,7 @@ class Server:
 
 
 def reconnect_clients(
-    client_instructions: List[Tuple[ClientProxy, ReconnectIns]],
+    client_instructions: list[tuple[ClientProxy, ReconnectIns]],
     max_workers: Optional[int],
     timeout: Optional[float],
 ) -> ReconnectResultsAndFailures:
@@ -312,8 +312,8 @@ def reconnect_clients(
         )
 
     # Gather results
-    results: List[Tuple[ClientProxy, DisconnectRes]] = []
-    failures: List[Union[Tuple[ClientProxy, DisconnectRes], BaseException]] = []
+    results: list[tuple[ClientProxy, DisconnectRes]] = []
+    failures: list[Union[tuple[ClientProxy, DisconnectRes], BaseException]] = []
     for future in finished_fs:
         failure = future.exception()
         if failure is not None:
@@ -328,7 +328,7 @@ def reconnect_client(
     client: ClientProxy,
     reconnect: ReconnectIns,
     timeout: Optional[float],
-) -> Tuple[ClientProxy, DisconnectRes]:
+) -> tuple[ClientProxy, DisconnectRes]:
     """Instruct client to disconnect and (optionally) reconnect later."""
     disconnect = client.reconnect(
         reconnect,
@@ -339,7 +339,7 @@ def reconnect_client(
 
 
 def fit_clients(
-    client_instructions: List[Tuple[ClientProxy, FitIns]],
+    client_instructions: list[tuple[ClientProxy, FitIns]],
     max_workers: Optional[int],
     timeout: Optional[float],
     group_id: int,
@@ -356,8 +356,8 @@ def fit_clients(
         )
 
     # Gather results
-    results: List[Tuple[ClientProxy, FitRes]] = []
-    failures: List[Union[Tuple[ClientProxy, FitRes], BaseException]] = []
+    results: list[tuple[ClientProxy, FitRes]] = []
+    failures: list[Union[tuple[ClientProxy, FitRes], BaseException]] = []
     for future in finished_fs:
         _handle_finished_future_after_fit(
             future=future, results=results, failures=failures
@@ -367,7 +367,7 @@ def fit_clients(
 
 def fit_client(
     client: ClientProxy, ins: FitIns, timeout: Optional[float], group_id: int
-) -> Tuple[ClientProxy, FitRes]:
+) -> tuple[ClientProxy, FitRes]:
     """Refine parameters on a single client."""
     fit_res = client.fit(ins, timeout=timeout, group_id=group_id)
     return client, fit_res
@@ -375,8 +375,8 @@ def fit_client(
 
 def _handle_finished_future_after_fit(
     future: concurrent.futures.Future,  # type: ignore
-    results: List[Tuple[ClientProxy, FitRes]],
-    failures: List[Union[Tuple[ClientProxy, FitRes], BaseException]],
+    results: list[tuple[ClientProxy, FitRes]],
+    failures: list[Union[tuple[ClientProxy, FitRes], BaseException]],
 ) -> None:
     """Convert finished future into either a result or a failure."""
     # Check if there was an exception
@@ -386,7 +386,7 @@ def _handle_finished_future_after_fit(
         return
 
     # Successfully received a result from a client
-    result: Tuple[ClientProxy, FitRes] = future.result()
+    result: tuple[ClientProxy, FitRes] = future.result()
     _, res = result
 
     # Check result status code
@@ -399,7 +399,7 @@ def _handle_finished_future_after_fit(
 
 
 def evaluate_clients(
-    client_instructions: List[Tuple[ClientProxy, EvaluateIns]],
+    client_instructions: list[tuple[ClientProxy, EvaluateIns]],
     max_workers: Optional[int],
     timeout: Optional[float],
     group_id: int,
@@ -416,8 +416,8 @@ def evaluate_clients(
         )
 
     # Gather results
-    results: List[Tuple[ClientProxy, EvaluateRes]] = []
-    failures: List[Union[Tuple[ClientProxy, EvaluateRes], BaseException]] = []
+    results: list[tuple[ClientProxy, EvaluateRes]] = []
+    failures: list[Union[tuple[ClientProxy, EvaluateRes], BaseException]] = []
     for future in finished_fs:
         _handle_finished_future_after_evaluate(
             future=future, results=results, failures=failures
@@ -430,7 +430,7 @@ def evaluate_client(
     ins: EvaluateIns,
     timeout: Optional[float],
     group_id: int,
-) -> Tuple[ClientProxy, EvaluateRes]:
+) -> tuple[ClientProxy, EvaluateRes]:
     """Evaluate parameters on a single client."""
     evaluate_res = client.evaluate(ins, timeout=timeout, group_id=group_id)
     return client, evaluate_res
@@ -438,8 +438,8 @@ def evaluate_client(
 
 def _handle_finished_future_after_evaluate(
     future: concurrent.futures.Future,  # type: ignore
-    results: List[Tuple[ClientProxy, EvaluateRes]],
-    failures: List[Union[Tuple[ClientProxy, EvaluateRes], BaseException]],
+    results: list[tuple[ClientProxy, EvaluateRes]],
+    failures: list[Union[tuple[ClientProxy, EvaluateRes], BaseException]],
 ) -> None:
     """Convert finished future into either a result or a failure."""
     # Check if there was an exception
@@ -449,7 +449,7 @@ def _handle_finished_future_after_evaluate(
         return
 
     # Successfully received a result from a client
-    result: Tuple[ClientProxy, EvaluateRes] = future.result()
+    result: tuple[ClientProxy, EvaluateRes] = future.result()
     _, res = result
 
     # Check result status code
@@ -466,7 +466,7 @@ def init_defaults(
     config: Optional[ServerConfig],
     strategy: Optional[Strategy],
     client_manager: Optional[ClientManager],
-) -> Tuple[Server, ServerConfig]:
+) -> tuple[Server, ServerConfig]:
     """Create server instance if none was given."""
     if server is None:
         if client_manager is None:

flwr/server/strategy/aggregate.py

@@ -16,7 +16,7 @@
 # mypy: disallow_untyped_calls=False
 
 from functools import reduce
-from typing import Any, Callable, List, Tuple
+from typing import Any, Callable
 
 import numpy as np
 
@@ -24,7 +24,7 @@ from flwr.common import FitRes, NDArray, NDArrays, parameters_to_ndarrays
 from flwr.server.client_proxy import ClientProxy
 
 
-def aggregate(results: List[Tuple[NDArrays, int]]) -> NDArrays:
+def aggregate(results: list[tuple[NDArrays, int]]) -> NDArrays:
     """Compute weighted average."""
     # Calculate the total number of examples used during training
     num_examples_total = sum(num_examples for (_, num_examples) in results)
@@ -42,7 +42,7 @@ def aggregate(results: List[Tuple[NDArrays, int]]) -> NDArrays:
     return weights_prime
 
 
-def aggregate_inplace(results: List[Tuple[ClientProxy, FitRes]]) -> NDArrays:
+def aggregate_inplace(results: list[tuple[ClientProxy, FitRes]]) -> NDArrays:
     """Compute in-place weighted average."""
     # Count total examples
     num_examples_total = sum(fit_res.num_examples for (_, fit_res) in results)
@@ -67,7 +67,7 @@ def aggregate_inplace(results: List[Tuple[ClientProxy, FitRes]]) -> NDArrays:
     return params
 
 
-def aggregate_median(results: List[Tuple[NDArrays, int]]) -> NDArrays:
+def aggregate_median(results: list[tuple[NDArrays, int]]) -> NDArrays:
     """Compute median."""
     # Create a list of weights and ignore the number of examples
     weights = [weights for weights, _ in results]
@@ -80,7 +80,7 @@ def aggregate_median(results: List[Tuple[NDArrays, int]]) -> NDArrays:
 
 
 def aggregate_krum(
-    results: List[Tuple[NDArrays, int]], num_malicious: int, to_keep: int
+    results: list[tuple[NDArrays, int]], num_malicious: int, to_keep: int
 ) -> NDArrays:
     """Choose one parameter vector according to the Krum function.
 
@@ -119,7 +119,7 @@ def aggregate_krum(
 
 # pylint: disable=too-many-locals
 def aggregate_bulyan(
-    results: List[Tuple[NDArrays, int]],
+    results: list[tuple[NDArrays, int]],
     num_malicious: int,
     aggregation_rule: Callable,  # type: ignore
     **aggregation_rule_kwargs: Any,
@@ -155,7 +155,7 @@ def aggregate_bulyan(
             "It is needed to ensure that the method reduces the attacker's leeway to "
             "the one proved in the paper."
         )
-    selected_models_set: List[Tuple[NDArrays, int]] = []
+    selected_models_set: list[tuple[NDArrays, int]] = []
 
     theta = len(results) - 2 * num_malicious
     beta = theta - 2 * num_malicious
@@ -200,7 +200,7 @@ def aggregate_bulyan(
     return parameters_aggregated
 
 
-def weighted_loss_avg(results: List[Tuple[int, float]]) -> float:
+def weighted_loss_avg(results: list[tuple[int, float]]) -> float:
     """Aggregate evaluation results obtained from multiple clients."""
     num_total_evaluation_examples = sum(num_examples for (num_examples, _) in results)
     weighted_losses = [num_examples * loss for num_examples, loss in results]
@@ -208,7 +208,7 @@ def weighted_loss_avg(results: List[Tuple[int, float]]) -> float:
 
 
 def aggregate_qffl(
-    parameters: NDArrays, deltas: List[NDArrays], hs_fll: List[NDArrays]
+    parameters: NDArrays, deltas: list[NDArrays], hs_fll: list[NDArrays]
 ) -> NDArrays:
     """Compute weighted average based on Q-FFL paper."""
     demominator: float = np.sum(np.asarray(hs_fll))
@@ -225,7 +225,7 @@ def aggregate_qffl(
     return new_parameters
 
 
-def _compute_distances(weights: List[NDArrays]) -> NDArray:
+def _compute_distances(weights: list[NDArrays]) -> NDArray:
     """Compute distances between vectors.
 
     Input: weights - list of weights vectors
@@ -265,7 +265,7 @@ def _trim_mean(array: NDArray, proportiontocut: float) -> NDArray:
 
 
 def aggregate_trimmed_avg(
-    results: List[Tuple[NDArrays, int]], proportiontocut: float
+    results: list[tuple[NDArrays, int]], proportiontocut: float
 ) -> NDArrays:
     """Compute trimmed average."""
     # Create a list of weights and ignore the number of examples
@@ -290,7 +290,7 @@ def _check_weights_equality(weights1: NDArrays, weights2: NDArrays) -> bool:
 
 
 def _find_reference_weights(
-    reference_weights: NDArrays, list_of_weights: List[NDArrays]
+    reference_weights: NDArrays, list_of_weights: list[NDArrays]
 ) -> int:
     """Find the reference weights by looping through the `list_of_weights`.
 
@@ -320,7 +320,7 @@ def _find_reference_weights(
 
 
 def _aggregate_n_closest_weights(
-    reference_weights: NDArrays, results: List[Tuple[NDArrays, int]], beta_closest: int
+    reference_weights: NDArrays, results: list[tuple[NDArrays, int]], beta_closest: int
 ) -> NDArrays:
     """Calculate element-wise mean of the `N` closest values.
 

flwr/server/strategy/bulyan.py

@@ -19,7 +19,7 @@ Paper: arxiv.org/abs/1802.07927
 
 
 from logging import WARNING
-from typing import Any, Callable, Dict, List, Optional, Tuple, Union
+from typing import Any, Callable, Optional, Union
 
 from flwr.common import (
     FitRes,
@@ -86,12 +86,12 @@ class Bulyan(FedAvg):
         num_malicious_clients: int = 0,
         evaluate_fn: Optional[
             Callable[
-                [int, NDArrays, Dict[str, Scalar]],
-                Optional[Tuple[float, Dict[str, Scalar]]],
+                [int, NDArrays, dict[str, Scalar]],
+                Optional[tuple[float, dict[str, Scalar]]],
             ]
         ] = None,
-        on_fit_config_fn: Optional[Callable[[int], Dict[str, Scalar]]] = None,
-        on_evaluate_config_fn: Optional[Callable[[int], Dict[str, Scalar]]] = None,
+        on_fit_config_fn: Optional[Callable[[int], dict[str, Scalar]]] = None,
+        on_evaluate_config_fn: Optional[Callable[[int], dict[str, Scalar]]] = None,
         accept_failures: bool = True,
         initial_parameters: Optional[Parameters] = None,
         fit_metrics_aggregation_fn: Optional[MetricsAggregationFn] = None,
@@ -125,9 +125,9 @@ class Bulyan(FedAvg):
     def aggregate_fit(
         self,
         server_round: int,
-        results: List[Tuple[ClientProxy, FitRes]],
-        failures: List[Union[Tuple[ClientProxy, FitRes], BaseException]],
-    ) -> Tuple[Optional[Parameters], Dict[str, Scalar]]:
+        results: list[tuple[ClientProxy, FitRes]],
+        failures: list[Union[tuple[ClientProxy, FitRes], BaseException]],
+    ) -> tuple[Optional[Parameters], dict[str, Scalar]]:
         """Aggregate fit results using Bulyan."""
         if not results:
             return None, {}

flwr/server/strategy/dp_adaptive_clipping.py

@@ -20,7 +20,7 @@ Paper (Andrew et al.): https://arxiv.org/abs/1905.03871
 
 import math
 from logging import INFO, WARNING
-from typing import Dict, List, Optional, Tuple, Union
+from typing import Optional, Union
 
 import numpy as np
 
@@ -156,14 +156,14 @@ class DifferentialPrivacyServerSideAdaptiveClipping(Strategy):
 
     def configure_fit(
         self, server_round: int, parameters: Parameters, client_manager: ClientManager
-    ) -> List[Tuple[ClientProxy, FitIns]]:
+    ) -> list[tuple[ClientProxy, FitIns]]:
         """Configure the next round of training."""
         self.current_round_params = parameters_to_ndarrays(parameters)
         return self.strategy.configure_fit(server_round, parameters, client_manager)
 
     def configure_evaluate(
         self, server_round: int, parameters: Parameters, client_manager: ClientManager
-    ) -> List[Tuple[ClientProxy, EvaluateIns]]:
+    ) -> list[tuple[ClientProxy, EvaluateIns]]:
         """Configure the next round of evaluation."""
         return self.strategy.configure_evaluate(
             server_round, parameters, client_manager
@@ -172,9 +172,9 @@ class DifferentialPrivacyServerSideAdaptiveClipping(Strategy):
     def aggregate_fit(
         self,
         server_round: int,
-        results: List[Tuple[ClientProxy, FitRes]],
-        failures: List[Union[Tuple[ClientProxy, FitRes], BaseException]],
-    ) -> Tuple[Optional[Parameters], Dict[str, Scalar]]:
+        results: list[tuple[ClientProxy, FitRes]],
+        failures: list[Union[tuple[ClientProxy, FitRes], BaseException]],
+    ) -> tuple[Optional[Parameters], dict[str, Scalar]]:
         """Aggregate training results and update clip norms."""
         if failures:
             return None, {}
@@ -245,15 +245,15 @@ class DifferentialPrivacyServerSideAdaptiveClipping(Strategy):
     def aggregate_evaluate(
         self,
         server_round: int,
-        results: List[Tuple[ClientProxy, EvaluateRes]],
-        failures: List[Union[Tuple[ClientProxy, EvaluateRes], BaseException]],
-    ) -> Tuple[Optional[float], Dict[str, Scalar]]:
+        results: list[tuple[ClientProxy, EvaluateRes]],
+        failures: list[Union[tuple[ClientProxy, EvaluateRes], BaseException]],
+    ) -> tuple[Optional[float], 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]]]:
+    ) -> Optional[tuple[float, dict[str, Scalar]]]:
         """Evaluate model parameters using an evaluation function from the strategy."""
         return self.strategy.evaluate(server_round, parameters)
 
@@ -372,7 +372,7 @@ class DifferentialPrivacyClientSideAdaptiveClipping(Strategy):
 
     def configure_fit(
         self, server_round: int, parameters: Parameters, client_manager: ClientManager
-    ) -> List[Tuple[ClientProxy, FitIns]]:
+    ) -> list[tuple[ClientProxy, FitIns]]:
         """Configure the next round of training."""
         additional_config = {KEY_CLIPPING_NORM: self.clipping_norm}
         inner_strategy_config_result = self.strategy.configure_fit(
@@ -385,7 +385,7 @@ class DifferentialPrivacyClientSideAdaptiveClipping(Strategy):
 
     def configure_evaluate(
         self, server_round: int, parameters: Parameters, client_manager: ClientManager
-    ) -> List[Tuple[ClientProxy, EvaluateIns]]:
+    ) -> list[tuple[ClientProxy, EvaluateIns]]:
         """Configure the next round of evaluation."""
         return self.strategy.configure_evaluate(
             server_round, parameters, client_manager
@@ -394,9 +394,9 @@ class DifferentialPrivacyClientSideAdaptiveClipping(Strategy):
     def aggregate_fit(
         self,
         server_round: int,
-        results: List[Tuple[ClientProxy, FitRes]],
-        failures: List[Union[Tuple[ClientProxy, FitRes], BaseException]],
-    ) -> Tuple[Optional[Parameters], Dict[str, Scalar]]:
+        results: list[tuple[ClientProxy, FitRes]],
+        failures: list[Union[tuple[ClientProxy, FitRes], BaseException]],
+    ) -> tuple[Optional[Parameters], dict[str, Scalar]]:
         """Aggregate training results and update clip norms."""
         if failures:
             return None, {}
@@ -432,7 +432,7 @@ class DifferentialPrivacyClientSideAdaptiveClipping(Strategy):
 
         return aggregated_params, metrics
 
-    def _update_clip_norm(self, results: List[Tuple[ClientProxy, FitRes]]) -> None:
+    def _update_clip_norm(self, results: list[tuple[ClientProxy, FitRes]]) -> None:
         # Calculate the number of clients which set the norm indicator bit
         norm_bit_set_count = 0
         for client_proxy, fit_res in results:
@@ -457,14 +457,14 @@ class DifferentialPrivacyClientSideAdaptiveClipping(Strategy):
     def aggregate_evaluate(
         self,
         server_round: int,
-        results: List[Tuple[ClientProxy, EvaluateRes]],
-        failures: List[Union[Tuple[ClientProxy, EvaluateRes], BaseException]],
-    ) -> Tuple[Optional[float], Dict[str, Scalar]]:
+        results: list[tuple[ClientProxy, EvaluateRes]],
+        failures: list[Union[tuple[ClientProxy, EvaluateRes], BaseException]],
+    ) -> tuple[Optional[float], 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]]]:
+    ) -> Optional[tuple[float, dict[str, Scalar]]]:
         """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,7 @@ Papers: https://arxiv.org/abs/1712.07557, https://arxiv.org/abs/1710.06963
 
 
 from logging import INFO, WARNING
-from typing import Dict, List, Optional, Tuple, Union
+from typing import Optional, Union
 
 from flwr.common import (
     EvaluateIns,
@@ -117,14 +117,14 @@ class DifferentialPrivacyServerSideFixedClipping(Strategy):
 
     def configure_fit(
         self, server_round: int, parameters: Parameters, client_manager: ClientManager
-    ) -> List[Tuple[ClientProxy, FitIns]]:
+    ) -> list[tuple[ClientProxy, FitIns]]:
         """Configure the next round of training."""
         self.current_round_params = parameters_to_ndarrays(parameters)
         return self.strategy.configure_fit(server_round, parameters, client_manager)
 
     def configure_evaluate(
         self, server_round: int, parameters: Parameters, client_manager: ClientManager
-    ) -> List[Tuple[ClientProxy, EvaluateIns]]:
+    ) -> list[tuple[ClientProxy, EvaluateIns]]:
         """Configure the next round of evaluation."""
         return self.strategy.configure_evaluate(
             server_round, parameters, client_manager
@@ -133,9 +133,9 @@ class DifferentialPrivacyServerSideFixedClipping(Strategy):
     def aggregate_fit(
         self,
         server_round: int,
-        results: List[Tuple[ClientProxy, FitRes]],
-        failures: List[Union[Tuple[ClientProxy, FitRes], BaseException]],
-    ) -> Tuple[Optional[Parameters], Dict[str, Scalar]]:
+        results: list[tuple[ClientProxy, FitRes]],
+        failures: list[Union[tuple[ClientProxy, FitRes], BaseException]],
+    ) -> tuple[Optional[Parameters], dict[str, Scalar]]:
         """Compute the updates, clip, and pass them for aggregation.
 
         Afterward, add noise to the aggregated parameters.
@@ -191,15 +191,15 @@ class DifferentialPrivacyServerSideFixedClipping(Strategy):
     def aggregate_evaluate(
         self,
         server_round: int,
-        results: List[Tuple[ClientProxy, EvaluateRes]],
-        failures: List[Union[Tuple[ClientProxy, EvaluateRes], BaseException]],
-    ) -> Tuple[Optional[float], Dict[str, Scalar]]:
+        results: list[tuple[ClientProxy, EvaluateRes]],
+        failures: list[Union[tuple[ClientProxy, EvaluateRes], BaseException]],
+    ) -> tuple[Optional[float], 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]]]:
+    ) -> Optional[tuple[float, dict[str, Scalar]]]:
         """Evaluate model parameters using an evaluation function from the strategy."""
         return self.strategy.evaluate(server_round, parameters)
 
@@ -285,7 +285,7 @@ class DifferentialPrivacyClientSideFixedClipping(Strategy):
 
     def configure_fit(
         self, server_round: int, parameters: Parameters, client_manager: ClientManager
-    ) -> List[Tuple[ClientProxy, FitIns]]:
+    ) -> list[tuple[ClientProxy, FitIns]]:
         """Configure the next round of training."""
         additional_config = {KEY_CLIPPING_NORM: self.clipping_norm}
         inner_strategy_config_result = self.strategy.configure_fit(
@@ -298,7 +298,7 @@ class DifferentialPrivacyClientSideFixedClipping(Strategy):
 
     def configure_evaluate(
         self, server_round: int, parameters: Parameters, client_manager: ClientManager
-    ) -> List[Tuple[ClientProxy, EvaluateIns]]:
+    ) -> list[tuple[ClientProxy, EvaluateIns]]:
         """Configure the next round of evaluation."""
         return self.strategy.configure_evaluate(
             server_round, parameters, client_manager
@@ -307,9 +307,9 @@ class DifferentialPrivacyClientSideFixedClipping(Strategy):
     def aggregate_fit(
         self,
         server_round: int,
-        results: List[Tuple[ClientProxy, FitRes]],
-        failures: List[Union[Tuple[ClientProxy, FitRes], BaseException]],
-    ) -> Tuple[Optional[Parameters], Dict[str, Scalar]]:
+        results: list[tuple[ClientProxy, FitRes]],
+        failures: list[Union[tuple[ClientProxy, FitRes], BaseException]],
+    ) -> tuple[Optional[Parameters], dict[str, Scalar]]:
         """Add noise to the aggregated parameters."""
         if failures:
             return None, {}
@@ -348,14 +348,14 @@ class DifferentialPrivacyClientSideFixedClipping(Strategy):
     def aggregate_evaluate(
         self,
         server_round: int,
-        results: List[Tuple[ClientProxy, EvaluateRes]],
-        failures: List[Union[Tuple[ClientProxy, EvaluateRes], BaseException]],
-    ) -> Tuple[Optional[float], Dict[str, Scalar]]:
+        results: list[tuple[ClientProxy, EvaluateRes]],
+        failures: list[Union[tuple[ClientProxy, EvaluateRes], BaseException]],
+    ) -> tuple[Optional[float], 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]]]:
+    ) -> Optional[tuple[float, dict[str, Scalar]]]:
         """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,7 @@ Paper: arxiv.org/pdf/1905.03871.pdf
 
 
 import math
-from typing import Dict, List, Optional, Tuple, Union
+from typing import Optional, Union
 
 import numpy as np
 
@@ -80,7 +80,7 @@ class DPFedAvgAdaptive(DPFedAvgFixed):
 
     def configure_fit(
         self, server_round: int, parameters: Parameters, client_manager: ClientManager
-    ) -> List[Tuple[ClientProxy, FitIns]]:
+    ) -> list[tuple[ClientProxy, FitIns]]:
         """Configure the next round of training."""
         additional_config = {"dpfedavg_adaptive_clip_enabled": True}
 
@@ -93,7 +93,7 @@ class DPFedAvgAdaptive(DPFedAvgFixed):
 
         return client_instructions
 
-    def _update_clip_norm(self, results: List[Tuple[ClientProxy, FitRes]]) -> None:
+    def _update_clip_norm(self, results: list[tuple[ClientProxy, FitRes]]) -> None:
         # Calculating number of clients which set the norm indicator bit
         norm_bit_set_count = 0
         for client_proxy, fit_res in results:
@@ -118,9 +118,9 @@ class DPFedAvgAdaptive(DPFedAvgFixed):
     def aggregate_fit(
         self,
         server_round: int,
-        results: List[Tuple[ClientProxy, FitRes]],
-        failures: List[Union[Tuple[ClientProxy, FitRes], BaseException]],
-    ) -> Tuple[Optional[Parameters], Dict[str, Scalar]]:
+        results: list[tuple[ClientProxy, FitRes]],
+        failures: list[Union[tuple[ClientProxy, FitRes], BaseException]],
+    ) -> tuple[Optional[Parameters], dict[str, Scalar]]:
         """Aggregate training results as in DPFedAvgFixed and update clip norms."""
         if failures:
             return None, {}