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

flwr/serverapp/strategy/bulyan.py

@@ -18,10 +18,9 @@ Paper: arxiv.org/abs/1802.07927
 """
 
 
-from collections import OrderedDict
-from collections.abc import Iterable
+from collections.abc import Callable, Iterable
 from logging import INFO, WARN
-from typing import Callable, Optional, cast
+from typing import cast
 
 import numpy as np
 
@@ -104,15 +103,15 @@ class Bulyan(FedAvg):
         weighted_by_key: str = "num-examples",
         arrayrecord_key: str = "arrays",
         configrecord_key: str = "config",
-        train_metrics_aggr_fn: Optional[
-            Callable[[list[RecordDict], str], MetricRecord]
-        ] = None,
-        evaluate_metrics_aggr_fn: Optional[
-            Callable[[list[RecordDict], str], MetricRecord]
-        ] = None,
-        selection_rule: Optional[
-            Callable[[list[RecordDict], int, int], list[RecordDict]]
-        ] = None,
+        train_metrics_aggr_fn: (
+            Callable[[list[RecordDict], str], MetricRecord] | None
+        ) = None,
+        evaluate_metrics_aggr_fn: (
+            Callable[[list[RecordDict], str], MetricRecord] | None
+        ) = None,
+        selection_rule: (
+            Callable[[list[RecordDict], int, int], list[RecordDict]] | None
+        ) = None,
     ) -> None:
         super().__init__(
             fraction_train=fraction_train,
@@ -140,7 +139,7 @@ class Bulyan(FedAvg):
         self,
         server_round: int,
         replies: Iterable[Message],
-    ) -> tuple[Optional[ArrayRecord], Optional[MetricRecord]]:
+    ) -> tuple[ArrayRecord | None, MetricRecord | None]:
         """Aggregate ArrayRecords and MetricRecords in the received Messages."""
         valid_replies, _ = self._check_and_log_replies(replies, is_train=True)
 
@@ -175,7 +174,9 @@ class Bulyan(FedAvg):
         ]
 
         # Compute median
-        median_ndarrays = [np.median(arr, axis=0) for arr in zip(*selected_ndarrays)]
+        median_ndarrays = [
+            np.median(arr, axis=0) for arr in zip(*selected_ndarrays, strict=True)
+        ]
 
         # Aggregate the beta closest weights element-wise
         aggregated_ndarrays = aggregate_n_closest_weights(
@@ -184,7 +185,7 @@ class Bulyan(FedAvg):
 
         # Convert to ArrayRecord
         arrays = ArrayRecord(
-            OrderedDict(zip(array_keys, map(Array, aggregated_ndarrays)))
+            dict(zip(array_keys, map(Array, aggregated_ndarrays), strict=True))
         )
 
         # Aggregate MetricRecords

flwr/serverapp/strategy/dp_adaptive_clipping.py

@@ -19,10 +19,8 @@ Paper (Andrew et al.): https://arxiv.org/abs/1905.03871
 
 import math
 from abc import ABC
-from collections import OrderedDict
 from collections.abc import Iterable
 from logging import INFO
-from typing import Optional
 
 import numpy as np
 
@@ -53,7 +51,7 @@ class DifferentialPrivacyAdaptiveBase(Strategy, ABC):
         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__()
 
@@ -96,7 +94,7 @@ class DifferentialPrivacyAdaptiveBase(Strategy, ABC):
         add_gaussian_noise_inplace(nds, stdv)
         log(INFO, "aggregate_fit: central DP noise with %.4f stdev added", stdv)
         return ArrayRecord(
-            OrderedDict({k: Array(v) for k, v in zip(aggregated.keys(), nds)})
+            {k: Array(v) for k, v in zip(aggregated.keys(), nds, strict=True)}
         )
 
     def _noisy_fraction(self, count: int, total: int) -> float:
@@ -115,7 +113,7 @@ class DifferentialPrivacyAdaptiveBase(Strategy, ABC):
 
     def aggregate_evaluate(
         self, server_round: int, replies: Iterable[Message]
-    ) -> Optional[MetricRecord]:
+    ) -> MetricRecord | None:
         """Aggregate MetricRecords in the received Messages."""
         return self.strategy.aggregate_evaluate(server_round, replies)
 
@@ -136,7 +134,7 @@ class DifferentialPrivacyServerSideAdaptiveClipping(DifferentialPrivacyAdaptiveB
         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__(
             strategy,
@@ -171,7 +169,7 @@ class DifferentialPrivacyServerSideAdaptiveClipping(DifferentialPrivacyAdaptiveB
 
     def aggregate_train(
         self, server_round: int, replies: Iterable[Message]
-    ) -> tuple[Optional[ArrayRecord], Optional[MetricRecord]]:
+    ) -> tuple[ArrayRecord | None, MetricRecord | None]:
         """Aggregate ArrayRecords and MetricRecords in the received Messages."""
         if not validate_replies(replies, self.num_sampled_clients):
             return None, None
@@ -184,16 +182,19 @@ class DifferentialPrivacyServerSideAdaptiveClipping(DifferentialPrivacyAdaptiveB
             for arr_name, record in reply.content.array_records.items():
                 reply_nd = record.to_numpy_ndarrays()
                 model_update = [
-                    np.subtract(x, y) for (x, y) in zip(reply_nd, current_nd)
+                    np.subtract(x, y)
+                    for (x, y) in zip(reply_nd, current_nd, strict=True)
                 ]
                 norm_bit = adaptive_clip_inputs_inplace(
                     model_update, self.clipping_norm
                 )
                 clipped_indicator_count += int(norm_bit)
                 # reconstruct array using clipped contribution from current round
-                restored = [c + u for c, u in zip(current_nd, model_update)]
+                restored = [
+                    c + u for c, u in zip(current_nd, model_update, strict=True)
+                ]
                 reply.content[arr_name] = ArrayRecord(
-                    OrderedDict({k: Array(v) for k, v in zip(record.keys(), restored)})
+                    {k: Array(v) for k, v in zip(record.keys(), restored, strict=True)}
                 )
             log(
                 INFO,
@@ -287,7 +288,7 @@ class DifferentialPrivacyClientSideAdaptiveClipping(DifferentialPrivacyAdaptiveB
 
     def aggregate_train(
         self, server_round: int, replies: Iterable[Message]
-    ) -> tuple[Optional[ArrayRecord], Optional[MetricRecord]]:
+    ) -> tuple[ArrayRecord | None, MetricRecord | None]:
         """Aggregate ArrayRecords and MetricRecords in the received Messages."""
         if not validate_replies(replies, self.num_sampled_clients):
             return None, None

flwr/serverapp/strategy/dp_fixed_clipping.py

@@ -17,11 +17,10 @@
 Papers: https://arxiv.org/abs/1712.07557, https://arxiv.org/abs/1710.06963
 """
 
+
 from abc import ABC
-from collections import OrderedDict
 from collections.abc import Iterable
 from logging import INFO, WARNING
-from typing import Optional
 
 from flwr.common import Array, ArrayRecord, ConfigRecord, Message, MetricRecord, log
 from flwr.common.differential_privacy import (
@@ -112,12 +111,12 @@ class DifferentialPrivacyFixedClippingBase(Strategy, ABC):
         )
 
         return ArrayRecord(
-            OrderedDict(
-                {
-                    k: Array(v)
-                    for k, v in zip(aggregated_arrays.keys(), aggregated_ndarrays)
-                }
-            )
+            {
+                k: Array(v)
+                for k, v in zip(
+                    aggregated_arrays.keys(), aggregated_ndarrays, strict=True
+                )
+            }
         )
 
     def configure_evaluate(
@@ -130,7 +129,7 @@ class DifferentialPrivacyFixedClippingBase(Strategy, ABC):
         self,
         server_round: int,
         replies: Iterable[Message],
-    ) -> Optional[MetricRecord]:
+    ) -> MetricRecord | None:
         """Aggregate MetricRecords in the received Messages."""
         return self.strategy.aggregate_evaluate(server_round, replies)
 
@@ -199,7 +198,7 @@ class DifferentialPrivacyServerSideFixedClipping(DifferentialPrivacyFixedClippin
         self,
         server_round: int,
         replies: Iterable[Message],
-    ) -> tuple[Optional[ArrayRecord], Optional[MetricRecord]]:
+    ) -> tuple[ArrayRecord | None, MetricRecord | None]:
         """Aggregate ArrayRecords and MetricRecords in the received Messages."""
         if not validate_replies(replies, self.num_sampled_clients):
             return None, None
@@ -217,9 +216,7 @@ class DifferentialPrivacyServerSideFixedClipping(DifferentialPrivacyFixedClippin
                 )
                 # Replace content while preserving keys
                 reply.content[arr_name] = ArrayRecord(
-                    OrderedDict(
-                        {k: Array(v) for k, v in zip(record.keys(), reply_ndarrays)}
-                    )
+                    dict(zip(record.keys(), map(Array, reply_ndarrays), strict=True))
                 )
             log(
                 INFO,
@@ -302,7 +299,7 @@ class DifferentialPrivacyClientSideFixedClipping(DifferentialPrivacyFixedClippin
         self,
         server_round: int,
         replies: Iterable[Message],
-    ) -> tuple[Optional[ArrayRecord], Optional[MetricRecord]]:
+    ) -> tuple[ArrayRecord | None, MetricRecord | None]:
         """Aggregate ArrayRecords and MetricRecords in the received Messages."""
         if not validate_replies(replies, self.num_sampled_clients):
             return None, None

flwr/serverapp/strategy/fedadagrad.py

@@ -19,9 +19,8 @@ Adaptive Federated Optimization using Adagrad.
 Paper: arxiv.org/abs/2003.00295
 """
 
-from collections import OrderedDict
-from collections.abc import Iterable
-from typing import Callable, Optional
+
+from collections.abc import Callable, Iterable
 
 import numpy as np
 
@@ -90,12 +89,12 @@ class FedAdagrad(FedOpt):
         weighted_by_key: str = "num-examples",
         arrayrecord_key: str = "arrays",
         configrecord_key: str = "config",
-        train_metrics_aggr_fn: Optional[
-            Callable[[list[RecordDict], str], MetricRecord]
-        ] = None,
-        evaluate_metrics_aggr_fn: Optional[
-            Callable[[list[RecordDict], str], MetricRecord]
-        ] = None,
+        train_metrics_aggr_fn: (
+            Callable[[list[RecordDict], str], MetricRecord] | None
+        ) = None,
+        evaluate_metrics_aggr_fn: (
+            Callable[[list[RecordDict], str], MetricRecord] | None
+        ) = None,
         eta: float = 1e-1,
         eta_l: float = 1e-1,
         tau: float = 1e-3,
@@ -122,7 +121,7 @@ class FedAdagrad(FedOpt):
         self,
         server_round: int,
         replies: Iterable[Message],
-    ) -> tuple[Optional[ArrayRecord], Optional[MetricRecord]]:
+    ) -> tuple[ArrayRecord | None, MetricRecord | None]:
         """Aggregate ArrayRecords and MetricRecords in the received Messages."""
         aggregated_arrayrecord, aggregated_metrics = super().aggregate_train(
             server_round, replies
@@ -154,6 +153,6 @@ class FedAdagrad(FedOpt):
         }
 
         return (
-            ArrayRecord(OrderedDict({k: Array(v) for k, v in new_arrays.items()})),
+            ArrayRecord({k: Array(v) for k, v in new_arrays.items()}),
             aggregated_metrics,
         )

flwr/serverapp/strategy/fedadam.py

@@ -19,9 +19,8 @@
 Paper: arxiv.org/abs/2003.00295
 """
 
-from collections import OrderedDict
-from collections.abc import Iterable
-from typing import Callable, Optional
+
+from collections.abc import Callable, Iterable
 
 import numpy as np
 
@@ -94,12 +93,12 @@ class FedAdam(FedOpt):
         weighted_by_key: str = "num-examples",
         arrayrecord_key: str = "arrays",
         configrecord_key: str = "config",
-        train_metrics_aggr_fn: Optional[
-            Callable[[list[RecordDict], str], MetricRecord]
-        ] = None,
-        evaluate_metrics_aggr_fn: Optional[
-            Callable[[list[RecordDict], str], MetricRecord]
-        ] = None,
+        train_metrics_aggr_fn: (
+            Callable[[list[RecordDict], str], MetricRecord] | None
+        ) = None,
+        evaluate_metrics_aggr_fn: (
+            Callable[[list[RecordDict], str], MetricRecord] | None
+        ) = None,
         eta: float = 1e-1,
         eta_l: float = 1e-1,
         beta_1: float = 0.9,
@@ -128,7 +127,7 @@ class FedAdam(FedOpt):
         self,
         server_round: int,
         replies: Iterable[Message],
-    ) -> tuple[Optional[ArrayRecord], Optional[MetricRecord]]:
+    ) -> tuple[ArrayRecord | None, MetricRecord | None]:
         """Aggregate ArrayRecords and MetricRecords in the received Messages."""
         aggregated_arrayrecord, aggregated_metrics = super().aggregate_train(
             server_round, replies
@@ -173,6 +172,6 @@ class FedAdam(FedOpt):
         }
 
         return (
-            ArrayRecord(OrderedDict({k: Array(v) for k, v in new_arrays.items()})),
+            ArrayRecord({k: Array(v) for k, v in new_arrays.items()}),
             aggregated_metrics,
         )

flwr/serverapp/strategy/fedavg.py

@@ -15,9 +15,8 @@
 """Flower message-based FedAvg strategy."""
 
 
-from collections.abc import Iterable
+from collections.abc import Callable, Iterable
 from logging import INFO, WARNING
-from typing import Callable, Optional
 
 from flwr.common import (
     ArrayRecord,
@@ -91,12 +90,12 @@ class FedAvg(Strategy):
         weighted_by_key: str = "num-examples",
         arrayrecord_key: str = "arrays",
         configrecord_key: str = "config",
-        train_metrics_aggr_fn: Optional[
-            Callable[[list[RecordDict], str], MetricRecord]
-        ] = None,
-        evaluate_metrics_aggr_fn: Optional[
-            Callable[[list[RecordDict], str], MetricRecord]
-        ] = None,
+        train_metrics_aggr_fn: (
+            Callable[[list[RecordDict], str], MetricRecord] | None
+        ) = None,
+        evaluate_metrics_aggr_fn: (
+            Callable[[list[RecordDict], str], MetricRecord] | None
+        ) = None,
     ) -> None:
         self.fraction_train = fraction_train
         self.fraction_evaluate = fraction_evaluate
@@ -251,7 +250,7 @@ class FedAvg(Strategy):
         self,
         server_round: int,
         replies: Iterable[Message],
-    ) -> tuple[Optional[ArrayRecord], Optional[MetricRecord]]:
+    ) -> tuple[ArrayRecord | None, MetricRecord | None]:
         """Aggregate ArrayRecords and MetricRecords in the received Messages."""
         valid_replies, _ = self._check_and_log_replies(replies, is_train=True)
 
@@ -304,7 +303,7 @@ class FedAvg(Strategy):
         self,
         server_round: int,
         replies: Iterable[Message],
-    ) -> Optional[MetricRecord]:
+    ) -> MetricRecord | None:
         """Aggregate MetricRecords in the received Messages."""
         valid_replies, _ = self._check_and_log_replies(replies, is_train=False)
 

flwr/serverapp/strategy/fedavgm.py

@@ -18,10 +18,8 @@ Paper: arxiv.org/pdf/1909.06335.pdf
 """
 
 
-from collections import OrderedDict
-from collections.abc import Iterable
+from collections.abc import Callable, Iterable
 from logging import INFO
-from typing import Callable, Optional
 
 from flwr.common import (
     Array,
@@ -93,12 +91,12 @@ class FedAvgM(FedAvg):
         weighted_by_key: str = "num-examples",
         arrayrecord_key: str = "arrays",
         configrecord_key: str = "config",
-        train_metrics_aggr_fn: Optional[
-            Callable[[list[RecordDict], str], MetricRecord]
-        ] = None,
-        evaluate_metrics_aggr_fn: Optional[
-            Callable[[list[RecordDict], str], MetricRecord]
-        ] = None,
+        train_metrics_aggr_fn: (
+            Callable[[list[RecordDict], str], MetricRecord] | None
+        ) = None,
+        evaluate_metrics_aggr_fn: (
+            Callable[[list[RecordDict], str], MetricRecord] | None
+        ) = None,
         server_learning_rate: float = 1.0,
         server_momentum: float = 0.0,
     ) -> None:
@@ -119,8 +117,8 @@ class FedAvgM(FedAvg):
         self.server_opt: bool = (self.server_momentum != 0.0) or (
             self.server_learning_rate != 1.0
         )
-        self.current_arrays: Optional[ArrayRecord] = None
-        self.momentum_vector: Optional[NDArrays] = None
+        self.current_arrays: ArrayRecord | None = None
+        self.momentum_vector: NDArrays | None = None
 
     def summary(self) -> None:
         """Log summary configuration of the strategy."""
@@ -143,7 +141,7 @@ class FedAvgM(FedAvg):
         self,
         server_round: int,
         replies: Iterable[Message],
-    ) -> tuple[Optional[ArrayRecord], Optional[MetricRecord]]:
+    ) -> tuple[ArrayRecord | None, MetricRecord | None]:
         """Aggregate ArrayRecords and MetricRecords in the received Messages."""
         # Call FedAvg aggregate_train to perform validation and aggregation
         aggregated_arrays, aggregated_metrics = super().aggregate_train(
@@ -168,7 +166,8 @@ class FedAvgM(FedAvg):
 
             # Remember that updates are the opposite of gradients
             pseudo_gradient = [
-                old - new for new, old in zip(aggregated_ndarrays, ndarrays)
+                old - new
+                for new, old in zip(aggregated_ndarrays, ndarrays, strict=True)
             ]
             if self.server_momentum > 0.0:
                 if self.momentum_vector is None:
@@ -177,7 +176,9 @@ class FedAvgM(FedAvg):
                 else:
                     self.momentum_vector = [
                         self.server_momentum * mv + pg
-                        for mv, pg in zip(self.momentum_vector, pseudo_gradient)
+                        for mv, pg in zip(
+                            self.momentum_vector, pseudo_gradient, strict=True
+                        )
                     ]
 
                 # No nesterov for now
@@ -186,10 +187,10 @@ class FedAvgM(FedAvg):
             # SGD and convert back to ArrayRecord
             updated_array_list = [
                 Array(old - self.server_learning_rate * pg)
-                for old, pg in zip(ndarrays, pseudo_gradient)
+                for old, pg in zip(ndarrays, pseudo_gradient, strict=True)
             ]
             aggregated_arrays = ArrayRecord(
-                OrderedDict(zip(array_keys, updated_array_list))
+                dict(zip(array_keys, updated_array_list, strict=True))
             )
 
             # Update current weights

flwr/serverapp/strategy/fedmedian.py

@@ -19,7 +19,7 @@ Paper: arxiv.org/pdf/1803.01498v1.pdf
 
 
 from collections.abc import Iterable
-from typing import Optional, cast
+from typing import cast
 
 import numpy as np
 
@@ -72,7 +72,7 @@ class FedMedian(FedAvg):
         self,
         server_round: int,
         replies: Iterable[Message],
-    ) -> tuple[Optional[ArrayRecord], Optional[MetricRecord]]:
+    ) -> tuple[ArrayRecord | None, MetricRecord | None]:
         """Aggregate ArrayRecords and MetricRecords in the received Messages."""
         # Call FedAvg aggregate_train to perform validation and aggregation
         valid_replies, _ = self._check_and_log_replies(replies, is_train=True)

flwr/serverapp/strategy/fedopt.py

@@ -17,9 +17,8 @@
 Paper: arxiv.org/abs/2003.00295
 """
 
-from collections.abc import Iterable
+from collections.abc import Callable, Iterable
 from logging import INFO
-from typing import Callable, Optional
 
 import numpy as np
 
@@ -101,12 +100,12 @@ class FedOpt(FedAvg):
         weighted_by_key: str = "num-examples",
         arrayrecord_key: str = "arrays",
         configrecord_key: str = "config",
-        train_metrics_aggr_fn: Optional[
-            Callable[[list[RecordDict], str], MetricRecord]
-        ] = None,
-        evaluate_metrics_aggr_fn: Optional[
-            Callable[[list[RecordDict], str], MetricRecord]
-        ] = None,
+        train_metrics_aggr_fn: (
+            Callable[[list[RecordDict], str], MetricRecord] | None
+        ) = None,
+        evaluate_metrics_aggr_fn: (
+            Callable[[list[RecordDict], str], MetricRecord] | None
+        ) = None,
         eta: float = 1e-1,
         eta_l: float = 1e-1,
         beta_1: float = 0.0,
@@ -125,14 +124,14 @@ class FedOpt(FedAvg):
             train_metrics_aggr_fn=train_metrics_aggr_fn,
             evaluate_metrics_aggr_fn=evaluate_metrics_aggr_fn,
         )
-        self.current_arrays: Optional[dict[str, NDArray]] = None
+        self.current_arrays: dict[str, NDArray] | None = None
         self.eta = eta
         self.eta_l = eta_l
         self.tau = tau
         self.beta_1 = beta_1
         self.beta_2 = beta_2
-        self.m_t: Optional[dict[str, NDArray]] = None
-        self.v_t: Optional[dict[str, NDArray]] = None
+        self.m_t: dict[str, NDArray] | None = None
+        self.v_t: dict[str, NDArray] | None = None
 
     def summary(self) -> None:
         """Log summary configuration of the strategy."""

flwr/serverapp/strategy/fedprox.py

@@ -18,9 +18,8 @@ Paper: arxiv.org/abs/1812.06127
 """
 
 
-from collections.abc import Iterable
+from collections.abc import Callable, Iterable
 from logging import INFO, WARN
-from typing import Callable, Optional
 
 from flwr.common import (
     ArrayRecord,
@@ -130,12 +129,12 @@ class FedProx(FedAvg):
         weighted_by_key: str = "num-examples",
         arrayrecord_key: str = "arrays",
         configrecord_key: str = "config",
-        train_metrics_aggr_fn: Optional[
-            Callable[[list[RecordDict], str], MetricRecord]
-        ] = None,
-        evaluate_metrics_aggr_fn: Optional[
-            Callable[[list[RecordDict], str], MetricRecord]
-        ] = None,
+        train_metrics_aggr_fn: (
+            Callable[[list[RecordDict], str], MetricRecord] | None
+        ) = None,
+        evaluate_metrics_aggr_fn: (
+            Callable[[list[RecordDict], str], MetricRecord] | None
+        ) = None,
         proximal_mu: float = 0.0,
     ) -> None:
         super().__init__(

flwr/serverapp/strategy/fedtrimmedavg.py

@@ -18,9 +18,9 @@ Paper: arxiv.org/abs/1803.01498
 """
 
 
-from collections.abc import Iterable
+from collections.abc import Callable, Iterable
 from logging import INFO
-from typing import Callable, Optional, cast
+from typing import cast
 
 import numpy as np
 
@@ -83,12 +83,12 @@ class FedTrimmedAvg(FedAvg):
         weighted_by_key: str = "num-examples",
         arrayrecord_key: str = "arrays",
         configrecord_key: str = "config",
-        train_metrics_aggr_fn: Optional[
-            Callable[[list[RecordDict], str], MetricRecord]
-        ] = None,
-        evaluate_metrics_aggr_fn: Optional[
-            Callable[[list[RecordDict], str], MetricRecord]
-        ] = None,
+        train_metrics_aggr_fn: (
+            Callable[[list[RecordDict], str], MetricRecord] | None
+        ) = None,
+        evaluate_metrics_aggr_fn: (
+            Callable[[list[RecordDict], str], MetricRecord] | None
+        ) = None,
         beta: float = 0.2,
     ) -> None:
         super().__init__(
@@ -115,7 +115,7 @@ class FedTrimmedAvg(FedAvg):
         self,
         server_round: int,
         replies: Iterable[Message],
-    ) -> tuple[Optional[ArrayRecord], Optional[MetricRecord]]:
+    ) -> tuple[ArrayRecord | None, MetricRecord | None]:
         """Aggregate ArrayRecords and MetricRecords in the received Messages."""
         # Call FedAvg aggregate_train to perform validation and aggregation
         valid_replies, _ = self._check_and_log_replies(replies, is_train=True)

flwr/serverapp/strategy/fedxgb_bagging.py

@@ -14,7 +14,7 @@
 # ==============================================================================
 """Flower message-based FedXgbBagging strategy."""
 from collections.abc import Iterable
-from typing import Optional, cast
+from typing import cast
 
 import numpy as np
 
@@ -65,7 +65,7 @@ class FedXgbBagging(FedAvg):
         average using the provided weight factor key.
     """
 
-    current_bst: Optional[bytes] = None
+    current_bst: bytes | None = None
 
     def _ensure_single_array(self, arrays: ArrayRecord) -> None:
         """Check that ensures there's only one Array in the ArrayRecord."""
@@ -89,7 +89,7 @@ class FedXgbBagging(FedAvg):
         self,
         server_round: int,
         replies: Iterable[Message],
-    ) -> tuple[Optional[ArrayRecord], Optional[MetricRecord]]:
+    ) -> tuple[ArrayRecord | None, MetricRecord | None]:
         """Aggregate ArrayRecords and MetricRecords in the received Messages."""
         valid_replies, _ = self._check_and_log_replies(replies, is_train=True)
 

flwr/serverapp/strategy/fedxgb_cyclic.py

@@ -15,9 +15,9 @@
 """Flower message-based FedXgbCyclic strategy."""
 
 
-from collections.abc import Iterable
+from collections.abc import Callable, Iterable
 from logging import INFO
-from typing import Callable, Optional, cast
+from typing import cast
 
 from flwr.common import (
     ArrayRecord,
@@ -78,12 +78,12 @@ class FedXgbCyclic(FedAvg):
         weighted_by_key: str = "num-examples",
         arrayrecord_key: str = "arrays",
         configrecord_key: str = "config",
-        train_metrics_aggr_fn: Optional[
-            Callable[[list[RecordDict], str], MetricRecord]
-        ] = None,
-        evaluate_metrics_aggr_fn: Optional[
-            Callable[[list[RecordDict], str], MetricRecord]
-        ] = None,
+        train_metrics_aggr_fn: (
+            Callable[[list[RecordDict], str], MetricRecord] | None
+        ) = None,
+        evaluate_metrics_aggr_fn: (
+            Callable[[list[RecordDict], str], MetricRecord] | None
+        ) = None,
     ) -> None:
         super().__init__(
             fraction_train=fraction_train,
@@ -184,7 +184,7 @@ class FedXgbCyclic(FedAvg):
         self,
         server_round: int,
         replies: Iterable[Message],
-    ) -> tuple[Optional[ArrayRecord], Optional[MetricRecord]]:
+    ) -> tuple[ArrayRecord | None, MetricRecord | None]:
         """Aggregate ArrayRecords and MetricRecords in the received Messages."""
         valid_replies, _ = self._check_and_log_replies(replies, is_train=True)