flwr-nightly 1.22.0.dev20250919__py3-none-any.whl → 1.23.0.dev20250921__py3-none-any.whl

flwr/cli/new/templates/app/pyproject.baseline.toml.tpl

@@ -14,7 +14,7 @@ description = ""
 license = "Apache-2.0"
 # Dependencies for your Flower App
 dependencies = [
-    "flwr[simulation]>=1.22.0",
+    "flwr[simulation]>=1.23.0",
     "flwr-datasets[vision]>=0.5.0",
     "torch==2.8.0",
     "torchvision==0.23.0",

flwr/cli/new/templates/app/pyproject.flowertune.toml.tpl

@@ -14,7 +14,7 @@ description = ""
 license = "Apache-2.0"
 # Dependencies for your Flower App
 dependencies = [
-    "flwr[simulation]>=1.22.0",
+    "flwr[simulation]>=1.23.0",
     "flwr-datasets>=0.5.0",
     "torch==2.4.0",
     "trl==0.8.1",

flwr/cli/new/templates/app/pyproject.huggingface.toml.tpl

@@ -14,7 +14,7 @@ description = ""
 license = "Apache-2.0"
 # Dependencies for your Flower App
 dependencies = [
-    "flwr[simulation]>=1.22.0",
+    "flwr[simulation]>=1.23.0",
     "flwr-datasets>=0.5.0",
     "torch>=2.7.1",
     "transformers>=4.30.0,<5.0",

flwr/cli/new/templates/app/pyproject.jax.toml.tpl

@@ -14,7 +14,7 @@ description = ""
 license = "Apache-2.0"
 # Dependencies for your Flower App
 dependencies = [
-    "flwr[simulation]>=1.22.0",
+    "flwr[simulation]>=1.23.0",
     "jax==0.4.30",
     "jaxlib==0.4.30",
     "scikit-learn==1.6.1",

flwr/cli/new/templates/app/pyproject.mlx.toml.tpl

@@ -14,7 +14,7 @@ description = ""
 license = "Apache-2.0"
 # Dependencies for your Flower App
 dependencies = [
-    "flwr[simulation]>=1.22.0",
+    "flwr[simulation]>=1.23.0",
     "flwr-datasets[vision]>=0.5.0",
     "mlx==0.29.0",
 ]

flwr/cli/new/templates/app/pyproject.numpy.toml.tpl

@@ -14,7 +14,7 @@ description = ""
 license = "Apache-2.0"
 # Dependencies for your Flower App
 dependencies = [
-    "flwr[simulation]>=1.22.0",
+    "flwr[simulation]>=1.23.0",
     "numpy>=2.0.2",
 ]
 

flwr/cli/new/templates/app/pyproject.pytorch.toml.tpl

@@ -14,7 +14,7 @@ description = ""
 license = "Apache-2.0"
 # Dependencies for your Flower App
 dependencies = [
-    "flwr[simulation]>=1.22.0",
+    "flwr[simulation]>=1.23.0",
     "flwr-datasets[vision]>=0.5.0",
     "torch==2.7.1",
     "torchvision==0.22.1",

flwr/cli/new/templates/app/pyproject.pytorch_legacy_api.toml.tpl

@@ -14,7 +14,7 @@ description = ""
 license = "Apache-2.0"
 # Dependencies for your Flower App
 dependencies = [
-    "flwr[simulation]>=1.22.0",
+    "flwr[simulation]>=1.23.0",
     "flwr-datasets[vision]>=0.5.0",
     "torch==2.7.1",
     "torchvision==0.22.1",

flwr/cli/new/templates/app/pyproject.sklearn.toml.tpl

@@ -14,7 +14,7 @@ description = ""
 license = "Apache-2.0"
 # Dependencies for your Flower App
 dependencies = [
-    "flwr[simulation]>=1.22.0",
+    "flwr[simulation]>=1.23.0",
     "flwr-datasets[vision]>=0.5.0",
     "scikit-learn>=1.6.1",
 ]

flwr/cli/new/templates/app/pyproject.tensorflow.toml.tpl

@@ -14,7 +14,7 @@ description = ""
 license = "Apache-2.0"
 # Dependencies for your Flower App
 dependencies = [
-    "flwr[simulation]>=1.22.0",
+    "flwr[simulation]>=1.23.0",
     "flwr-datasets[vision]>=0.5.0",
     "tensorflow>=2.11.1,<2.18.0",
 ]

flwr/cli/new/templates/app/pyproject.xgboost.toml.tpl

@@ -14,7 +14,7 @@ description = ""
 license = "Apache-2.0"
 # Dependencies for your Flower App
 dependencies = [
-    "flwr[simulation]>=1.22.0",
+    "flwr[simulation]>=1.23.0",
     "flwr-datasets>=0.5.0",
     "xgboost>=2.0.0",
 ]

flwr/clientapp/mod/__init__.py

@@ -18,8 +18,10 @@
 from flwr.client.mod.comms_mods import arrays_size_mod, message_size_mod
 
 from .centraldp_mods import adaptiveclipping_mod, fixedclipping_mod
+from .localdp_mod import LocalDpMod
 
 __all__ = [
+    "LocalDpMod",
     "adaptiveclipping_mod",
     "arrays_size_mod",
     "fixedclipping_mod",

flwr/clientapp/mod/centraldp_mods.py

@@ -89,7 +89,7 @@ def fixedclipping_mod(
         iter(out_msg.content.array_records.items())
     )
     # Ensure keys in returned ArrayRecord match those in the one sent from server
-    if set(original_array_record.keys()) != set(client_to_server_arrecord.keys()):
+    if list(original_array_record.keys()) != list(client_to_server_arrecord.keys()):
         return _handle_array_key_mismatch_err("fixedclipping_mod", out_msg)
 
     client_to_server_ndarrays = client_to_server_arrecord.to_numpy_ndarrays()
@@ -158,6 +158,10 @@ def adaptiveclipping_mod(
     # Call inner app
     out_msg = call_next(msg, ctxt)
 
+    # Check if the msg has error
+    if out_msg.has_error():
+        return out_msg
+
     # Ensure reply has a single ArrayRecord
     if len(out_msg.content.array_records) != 1:
         return _handle_multi_record_err("adaptiveclipping_mod", out_msg, ArrayRecord)
@@ -166,16 +170,12 @@ def adaptiveclipping_mod(
     if len(out_msg.content.metric_records) != 1:
         return _handle_multi_record_err("adaptiveclipping_mod", out_msg, MetricRecord)
 
-    # Check if the msg has error
-    if out_msg.has_error():
-        return out_msg
-
     new_array_record_key, client_to_server_arrecord = next(
         iter(out_msg.content.array_records.items())
     )
 
     # Ensure keys in returned ArrayRecord match those in the one sent from server
-    if set(original_array_record.keys()) != set(client_to_server_arrecord.keys()):
+    if list(original_array_record.keys()) != list(client_to_server_arrecord.keys()):
         return _handle_array_key_mismatch_err("adaptiveclipping_mod", out_msg)
 
     client_to_server_ndarrays = client_to_server_arrecord.to_numpy_ndarrays()

flwr/clientapp/mod/localdp_mod.py

@@ -0,0 +1,169 @@
+# Copyright 2025 Flower Labs GmbH. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Local DP modifier."""
+
+
+from collections import OrderedDict
+from logging import INFO
+
+import numpy as np
+
+from flwr.clientapp.typing import ClientAppCallable
+from flwr.common import Array, ArrayRecord
+from flwr.common.context import Context
+from flwr.common.differential_privacy import (
+    add_gaussian_noise_inplace,
+    compute_clip_model_update,
+)
+from flwr.common.logger import log
+from flwr.common.message import Message
+
+from .centraldp_mods import _handle_array_key_mismatch_err, _handle_multi_record_err
+
+
+class LocalDpMod:
+    """Modifier for local differential privacy.
+
+    This mod clips the client model updates and
+    adds noise to the params before sending them to the server.
+
+    It operates on messages of type `MessageType.TRAIN`.
+
+    Parameters
+    ----------
+    clipping_norm : float
+        The value of the clipping norm.
+    sensitivity : float
+        The sensitivity of the client model.
+    epsilon : float
+        The privacy budget.
+        Smaller value of epsilon indicates a higher level of privacy protection.
+    delta : float
+        The failure probability.
+        The probability that the privacy mechanism
+        fails to provide the desired level of privacy.
+        A smaller value of delta indicates a stricter privacy guarantee.
+
+    Examples
+    --------
+    Create an instance of the local DP mod and add it to the client-side mods::
+
+        local_dp_mod = LocalDpMod( ... )
+        app = fl.client.ClientApp(mods=[local_dp_mod])
+    """
+
+    def __init__(
+        self, clipping_norm: float, sensitivity: float, epsilon: float, delta: float
+    ) -> None:
+        if clipping_norm <= 0:
+            raise ValueError("The clipping norm should be a positive value.")
+
+        if sensitivity < 0:
+            raise ValueError("The sensitivity should be a non-negative value.")
+
+        if epsilon < 0:
+            raise ValueError("Epsilon should be a non-negative value.")
+
+        if delta < 0:
+            raise ValueError("Delta should be a non-negative value.")
+
+        self.clipping_norm = clipping_norm
+        self.sensitivity = sensitivity
+        self.epsilon = epsilon
+        self.delta = delta
+
+    def __call__(
+        self, msg: Message, ctxt: Context, call_next: ClientAppCallable
+    ) -> Message:
+        """Perform local DP on the client model parameters.
+
+        Parameters
+        ----------
+        msg : Message
+            The message received from the ServerApp.
+        ctxt : Context
+            The context of the ClientApp.
+        call_next : ClientAppCallable
+            The callable to call the next mod (or the ClientApp) in the chain.
+
+        Returns
+        -------
+        Message
+            The modified message to be sent back to the server.
+        """
+        if len(msg.content.array_records) != 1:
+            return _handle_multi_record_err("LocalDpMod", msg, ArrayRecord)
+
+        # Record array record communicated to client and clipping norm
+        original_array_record = next(iter(msg.content.array_records.values()))
+
+        # Call inner app
+        out_msg = call_next(msg, ctxt)
+
+        # Check if the msg has error
+        if out_msg.has_error():
+            return out_msg
+
+        # Ensure reply has a single ArrayRecord
+        if len(out_msg.content.array_records) != 1:
+            return _handle_multi_record_err("LocalDpMod", out_msg, ArrayRecord)
+
+        new_array_record_key, client_to_server_arrecord = next(
+            iter(out_msg.content.array_records.items())
+        )
+
+        # Ensure keys in returned ArrayRecord match those in the one sent from server
+        if list(original_array_record.keys()) != list(client_to_server_arrecord.keys()):
+            return _handle_array_key_mismatch_err("LocalDpMod", out_msg)
+
+        client_to_server_ndarrays = client_to_server_arrecord.to_numpy_ndarrays()
+
+        # Clip the client update
+        compute_clip_model_update(
+            client_to_server_ndarrays,
+            original_array_record.to_numpy_ndarrays(),
+            self.clipping_norm,
+        )
+        log(
+            INFO,
+            "LocalDpMod: parameters are clipped by value: %.4f.",
+            self.clipping_norm,
+        )
+
+        std_dev = (
+            self.sensitivity * np.sqrt(2 * np.log(1.25 / self.delta)) / self.epsilon
+        )
+        add_gaussian_noise_inplace(
+            client_to_server_ndarrays,
+            std_dev,
+        )
+        log(
+            INFO,
+            "LocalDpMod: local DP noise with %.4f stddev added to parameters",
+            std_dev,
+        )
+
+        # Replace outgoing ArrayRecord's Array while preserving their keys
+        out_msg.content[new_array_record_key] = ArrayRecord(
+            OrderedDict(
+                {
+                    k: Array(v)
+                    for k, v in zip(
+                        client_to_server_arrecord.keys(), client_to_server_ndarrays
+                    )
+                }
+            )
+        )
+        return out_msg

flwr/serverapp/strategy/__init__.py

@@ -15,6 +15,7 @@
 """ServerApp strategies."""
 
 
+from .bulyan import Bulyan
 from .dp_adaptive_clipping import (
     DifferentialPrivacyClientSideAdaptiveClipping,
     DifferentialPrivacyServerSideAdaptiveClipping,
@@ -34,11 +35,13 @@ from .fedxgb_bagging import FedXgbBagging
 from .fedxgb_cyclic import FedXgbCyclic
 from .fedyogi import FedYogi
 from .krum import Krum
+from .multikrum import MultiKrum
 from .qfedavg import QFedAvg
 from .result import Result
 from .strategy import Strategy
 
 __all__ = [
+    "Bulyan",
     "DifferentialPrivacyClientSideAdaptiveClipping",
     "DifferentialPrivacyClientSideFixedClipping",
     "DifferentialPrivacyServerSideAdaptiveClipping",
@@ -54,6 +57,7 @@ __all__ = [
     "FedXgbCyclic",
     "FedYogi",
     "Krum",
+    "MultiKrum",
     "QFedAvg",
     "Result",
     "Strategy",

flwr/serverapp/strategy/bulyan.py

@@ -0,0 +1,238 @@
+# Copyright 2025 Flower Labs GmbH. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Bulyan [El Mhamdi et al., 2018] strategy.
+
+Paper: arxiv.org/abs/1802.07927
+"""
+
+
+from collections import OrderedDict
+from collections.abc import Iterable
+from logging import INFO, WARN
+from typing import Callable, Optional, cast
+
+import numpy as np
+
+from flwr.common import (
+    Array,
+    ArrayRecord,
+    Message,
+    MetricRecord,
+    NDArrays,
+    RecordDict,
+    log,
+)
+
+from .fedavg import FedAvg
+from .multikrum import select_multikrum
+
+
+# pylint: disable=too-many-instance-attributes
+class Bulyan(FedAvg):
+    """Bulyan strategy.
+
+    Implementation based on https://arxiv.org/abs/1802.07927.
+
+    Parameters
+    ----------
+    fraction_train : float (default: 1.0)
+        Fraction of nodes used during training. In case `min_train_nodes`
+        is larger than `fraction_train * total_connected_nodes`, `min_train_nodes`
+        will still be sampled.
+    fraction_evaluate : float (default: 1.0)
+        Fraction of nodes used during validation. In case `min_evaluate_nodes`
+        is larger than `fraction_evaluate * total_connected_nodes`,
+        `min_evaluate_nodes` will still be sampled.
+    min_train_nodes : int (default: 2)
+        Minimum number of nodes used during training.
+    min_evaluate_nodes : int (default: 2)
+        Minimum number of nodes used during validation.
+    min_available_nodes : int (default: 2)
+        Minimum number of total nodes in the system.
+    num_malicious_nodes : int (default: 0)
+        Number of malicious nodes in the system.
+    weighted_by_key : str (default: "num-examples")
+        The key within each MetricRecord whose value is used as the weight when
+        computing weighted averages for MetricRecords.
+    arrayrecord_key : str (default: "arrays")
+        Key used to store the ArrayRecord when constructing Messages.
+    configrecord_key : str (default: "config")
+        Key used to store the ConfigRecord when constructing Messages.
+    train_metrics_aggr_fn : Optional[callable] (default: None)
+        Function with signature (list[RecordDict], str) -> MetricRecord,
+        used to aggregate MetricRecords from training round replies.
+        If `None`, defaults to `aggregate_metricrecords`, which performs a weighted
+        average using the provided weight factor key.
+    evaluate_metrics_aggr_fn : Optional[callable] (default: None)
+        Function with signature (list[RecordDict], str) -> MetricRecord,
+        used to aggregate MetricRecords from training round replies.
+        If `None`, defaults to `aggregate_metricrecords`, which performs a weighted
+        average using the provided weight factor key.
+    selection_rule : Optional[Callable] (default: None)
+        Function with signature (list[RecordDict], int, int) -> list[RecordDict].
+        The inputs are:
+        - a list of contents from reply messages,
+        - the assumed number of malicious nodes (`num_malicious_nodes`),
+        - the number of nodes to select (`num_nodes_to_select`).
+
+        The function should implement a Byzantine-resilient selection rule that
+        serves as the first step of Bulyan. If None, defaults to `select_multikrum`,
+        which selects nodes according to the Multi-Krum algorithm.
+    """
+
+    # pylint: disable=too-many-arguments,too-many-positional-arguments
+    def __init__(
+        self,
+        fraction_train: float = 1.0,
+        fraction_evaluate: float = 1.0,
+        min_train_nodes: int = 2,
+        min_evaluate_nodes: int = 2,
+        min_available_nodes: int = 2,
+        num_malicious_nodes: int = 0,
+        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,
+    ) -> None:
+        super().__init__(
+            fraction_train=fraction_train,
+            fraction_evaluate=fraction_evaluate,
+            min_train_nodes=min_train_nodes,
+            min_evaluate_nodes=min_evaluate_nodes,
+            min_available_nodes=min_available_nodes,
+            weighted_by_key=weighted_by_key,
+            arrayrecord_key=arrayrecord_key,
+            configrecord_key=configrecord_key,
+            train_metrics_aggr_fn=train_metrics_aggr_fn,
+            evaluate_metrics_aggr_fn=evaluate_metrics_aggr_fn,
+        )
+        self.num_malicious_nodes = num_malicious_nodes
+        self.selection_rule = selection_rule or select_multikrum
+
+    def summary(self) -> None:
+        """Log summary configuration of the strategy."""
+        log(INFO, "\t├──> Bulyan settings:")
+        log(INFO, "\t│\t├── Number of malicious nodes: %d", self.num_malicious_nodes)
+        log(INFO, "\t│\t└── Selection rule: %s", self.selection_rule.__name__)
+        super().summary()
+
+    def aggregate_train(
+        self,
+        server_round: int,
+        replies: Iterable[Message],
+    ) -> tuple[Optional[ArrayRecord], Optional[MetricRecord]]:
+        """Aggregate ArrayRecords and MetricRecords in the received Messages."""
+        valid_replies, _ = self._check_and_log_replies(replies, is_train=True)
+
+        # Check if sufficient replies have been received
+        if len(valid_replies) < 4 * self.num_malicious_nodes + 3:
+            log(
+                WARN,
+                "Insufficient replies, skipping Bulyan aggregation: "
+                "Required at least %d (4*num_malicious_nodes + 3), but received %d.",
+                4 * self.num_malicious_nodes + 3,
+                len(valid_replies),
+            )
+            return None, None
+
+        reply_contents = [msg.content for msg in valid_replies]
+
+        # Compute theta and beta
+        theta = len(valid_replies) - 2 * self.num_malicious_nodes
+        beta = theta - 2 * self.num_malicious_nodes
+
+        # Byzantine-resilient selection rule
+        selected_contents = self.selection_rule(
+            reply_contents, self.num_malicious_nodes, theta
+        )
+
+        # Convert each ArrayRecord to a list of NDArray for easier computation
+        key = list(selected_contents[0].array_records.keys())[0]
+        array_keys = list(selected_contents[0][key].keys())
+        selected_ndarrays = [
+            cast(ArrayRecord, ctnt[key]).to_numpy_ndarrays(keep_input=False)
+            for ctnt in selected_contents
+        ]
+
+        # Compute median
+        median_ndarrays = [np.median(arr, axis=0) for arr in zip(*selected_ndarrays)]
+
+        # Aggregate the beta closest weights element-wise
+        aggregated_ndarrays = aggregate_n_closest_weights(
+            median_ndarrays, selected_ndarrays, beta
+        )
+
+        # Convert to ArrayRecord
+        arrays = ArrayRecord(
+            OrderedDict(zip(array_keys, map(Array, aggregated_ndarrays)))
+        )
+
+        # Aggregate MetricRecords
+        metrics = self.train_metrics_aggr_fn(
+            selected_contents,
+            self.weighted_by_key,
+        )
+        return arrays, metrics
+
+
+def aggregate_n_closest_weights(
+    ref_weights: NDArrays, weights_list: list[NDArrays], beta: int
+) -> NDArrays:
+    """Compute the element-wise mean of the `beta` closest weight arrays.
+
+    For each element (i-th coordinate), the output is the average of the
+    `beta` weight arrays that are closest to the reference weights.
+
+    Parameters
+    ----------
+    ref_weights : NDArrays
+        Reference weights used to compute distances.
+    weights_list : list[NDArrays]
+        List of weight arrays (e.g., from selected nodes).
+    beta : int
+        Number of closest weight arrays to include in the averaging.
+
+    Returns
+    -------
+    aggregated_weights : NDArrays
+        Element-wise average of the `beta` closest weight arrays to the
+        reference weights.
+    """
+    aggregated_weights = []
+    for layer_id, ref_layer in enumerate(ref_weights):
+        # Shape: (n_models, *layer_shape)
+        layer_stack = np.stack([weights[layer_id] for weights in weights_list])
+
+        # Compute absolute differences: shape (n_models, *layer_shape)
+        diffs = np.abs(layer_stack - ref_layer)
+
+        # Find indices of `beta` smallest per coordinate
+        idx = np.argpartition(diffs, beta - 1, axis=0)[:beta]
+
+        # Gather the closest weights
+        closest = np.take_along_axis(layer_stack, idx, axis=0)
+
+        # Average them
+        aggregated_weights.append(np.mean(closest, axis=0))
+
+    return aggregated_weights

flwr/serverapp/strategy/fedmedian.py

@@ -32,6 +32,40 @@ class FedMedian(FedAvg):
     """Federated Median (FedMedian) strategy.
 
     Implementation based on https://arxiv.org/pdf/1803.01498v1
+
+    Parameters
+    ----------
+    fraction_train : float (default: 1.0)
+        Fraction of nodes used during training. In case `min_train_nodes`
+        is larger than `fraction_train * total_connected_nodes`, `min_train_nodes`
+        will still be sampled.
+    fraction_evaluate : float (default: 1.0)
+        Fraction of nodes used during validation. In case `min_evaluate_nodes`
+        is larger than `fraction_evaluate * total_connected_nodes`,
+        `min_evaluate_nodes` will still be sampled.
+    min_train_nodes : int (default: 2)
+        Minimum number of nodes used during training.
+    min_evaluate_nodes : int (default: 2)
+        Minimum number of nodes used during validation.
+    min_available_nodes : int (default: 2)
+        Minimum number of total nodes in the system.
+    weighted_by_key : str (default: "num-examples")
+        The key within each MetricRecord whose value is used as the weight when
+        computing weighted averages for MetricRecords.
+    arrayrecord_key : str (default: "arrays")
+        Key used to store the ArrayRecord when constructing Messages.
+    configrecord_key : str (default: "config")
+        Key used to store the ConfigRecord when constructing Messages.
+    train_metrics_aggr_fn : Optional[callable] (default: None)
+        Function with signature (list[RecordDict], str) -> MetricRecord,
+        used to aggregate MetricRecords from training round replies.
+        If `None`, defaults to `aggregate_metricrecords`, which performs a weighted
+        average using the provided weight factor key.
+    evaluate_metrics_aggr_fn : Optional[callable] (default: None)
+        Function with signature (list[RecordDict], str) -> MetricRecord,
+        used to aggregate MetricRecords from training round replies.
+        If `None`, defaults to `aggregate_metricrecords`, which performs a weighted
+        average using the provided weight factor key.
     """
 
     def aggregate_train(

flwr/serverapp/strategy/fedxgb_bagging.py

@@ -28,7 +28,42 @@ from .strategy_utils import aggregate_bagging
 
 # pylint: disable=line-too-long
 class FedXgbBagging(FedAvg):
-    """Configurable FedXgbBagging strategy implementation."""
+    """Configurable FedXgbBagging strategy implementation.
+
+    Parameters
+    ----------
+    fraction_train : float (default: 1.0)
+        Fraction of nodes used during training. In case `min_train_nodes`
+        is larger than `fraction_train * total_connected_nodes`, `min_train_nodes`
+        will still be sampled.
+    fraction_evaluate : float (default: 1.0)
+        Fraction of nodes used during validation. In case `min_evaluate_nodes`
+        is larger than `fraction_evaluate * total_connected_nodes`,
+        `min_evaluate_nodes` will still be sampled.
+    min_train_nodes : int (default: 2)
+        Minimum number of nodes used during training.
+    min_evaluate_nodes : int (default: 2)
+        Minimum number of nodes used during validation.
+    min_available_nodes : int (default: 2)
+        Minimum number of total nodes in the system.
+    weighted_by_key : str (default: "num-examples")
+        The key within each MetricRecord whose value is used as the weight when
+        computing weighted averages for MetricRecords.
+    arrayrecord_key : str (default: "arrays")
+        Key used to store the ArrayRecord when constructing Messages.
+    configrecord_key : str (default: "config")
+        Key used to store the ConfigRecord when constructing Messages.
+    train_metrics_aggr_fn : Optional[callable] (default: None)
+        Function with signature (list[RecordDict], str) -> MetricRecord,
+        used to aggregate MetricRecords from training round replies.
+        If `None`, defaults to `aggregate_metricrecords`, which performs a weighted
+        average using the provided weight factor key.
+    evaluate_metrics_aggr_fn : Optional[callable] (default: None)
+        Function with signature (list[RecordDict], str) -> MetricRecord,
+        used to aggregate MetricRecords from training round replies.
+        If `None`, defaults to `aggregate_metricrecords`, which performs a weighted
+        average using the provided weight factor key.
+    """
 
     current_bst: Optional[bytes] = None
 

flwr/serverapp/strategy/fedxgb_cyclic.py

@@ -52,7 +52,7 @@ class FedXgbCyclic(FedAvg):
         Minimum number of total nodes in the system.
     weighted_by_key : str (default: "num-examples")
         The key within each MetricRecord whose value is used as the weight when
-        computing weighted averages for both ArrayRecords and MetricRecords.
+        computing weighted averages for MetricRecords.
     arrayrecord_key : str (default: "arrays")
         Key used to store the ArrayRecord when constructing Messages.
     configrecord_key : str (default: "config")

flwr/serverapp/strategy/krum.py

@@ -20,20 +20,16 @@ Paper: proceedings.neurips.cc/paper/2017/file/f4b9ec30ad9f68f89b29639786cb62ef-P
 """
 
 
-from collections.abc import Iterable
 from logging import INFO
 from typing import Callable, Optional
 
-import numpy as np
+from flwr.common import MetricRecord, RecordDict, log
 
-from flwr.common import ArrayRecord, Message, MetricRecord, NDArray, RecordDict, log
-
-from .fedavg import FedAvg
-from .strategy_utils import aggregate_arrayrecords
+from .multikrum import MultiKrum
 
 
 # pylint: disable=too-many-instance-attributes
-class Krum(FedAvg):
+class Krum(MultiKrum):
     """Krum [Blanchard et al., 2017] strategy.
 
     Implementation based on https://arxiv.org/abs/1703.02757
@@ -56,12 +52,9 @@ class Krum(FedAvg):
         Minimum number of total nodes in the system.
     num_malicious_nodes : int (default: 0)
         Number of malicious nodes in the system. Defaults to 0.
-    num_nodes_to_keep : int (default: 0)
-        Number of nodes to keep before averaging (MultiKrum). Defaults to 0, in
-        that case classical Krum is applied.
     weighted_by_key : str (default: "num-examples")
         The key within each MetricRecord whose value is used as the weight when
-        computing weighted averages for both ArrayRecords and MetricRecords.
+        computing weighted averages for MetricRecords.
     arrayrecord_key : str (default: "arrays")
         Key used to store the ArrayRecord when constructing Messages.
     configrecord_key : str (default: "config")
@@ -87,7 +80,6 @@ class Krum(FedAvg):
         min_evaluate_nodes: int = 2,
         min_available_nodes: int = 2,
         num_malicious_nodes: int = 0,
-        num_nodes_to_keep: int = 0,
         weighted_by_key: str = "num-examples",
         arrayrecord_key: str = "arrays",
         configrecord_key: str = "config",
@@ -105,126 +97,16 @@ class Krum(FedAvg):
             min_evaluate_nodes=min_evaluate_nodes,
             min_available_nodes=min_available_nodes,
             weighted_by_key=weighted_by_key,
+            num_malicious_nodes=num_malicious_nodes,
+            num_nodes_to_select=1,  # Krum selects 1 node
             arrayrecord_key=arrayrecord_key,
             configrecord_key=configrecord_key,
             train_metrics_aggr_fn=train_metrics_aggr_fn,
             evaluate_metrics_aggr_fn=evaluate_metrics_aggr_fn,
         )
-        self.num_malicious_nodes = num_malicious_nodes
-        self.num_nodes_to_keep = num_nodes_to_keep
 
     def summary(self) -> None:
         """Log summary configuration of the strategy."""
         log(INFO, "\t├──> Krum settings:")
-        log(INFO, "\t│\t├── Number of malicious nodes: %d", self.num_malicious_nodes)
-        log(INFO, "\t│\t└── Number of nodes to keep: %d", self.num_nodes_to_keep)
+        log(INFO, "\t│\t└── Number of malicious nodes: %d", self.num_malicious_nodes)
         super().summary()
-
-    def _compute_distances(self, records: list[ArrayRecord]) -> NDArray:
-        """Compute distances between ArrayRecords.
-
-        Parameters
-        ----------
-        records : list[ArrayRecord]
-            A list of ArrayRecords (arrays received in replies)
-
-        Returns
-        -------
-        NDArray
-            A 2D array representing the distance matrix of squared distances
-            between input ArrayRecords
-        """
-        flat_w = np.array(
-            [
-                np.concatenate(rec.to_numpy_ndarrays(), axis=None).ravel()
-                for rec in records
-            ]
-        )
-        distance_matrix = np.zeros((len(records), len(records)))
-        for i, flat_w_i in enumerate(flat_w):
-            for j, flat_w_j in enumerate(flat_w):
-                delta = flat_w_i - flat_w_j
-                norm = np.linalg.norm(delta)
-                distance_matrix[i, j] = norm**2
-        return distance_matrix
-
-    def _krum(self, replies: list[RecordDict]) -> list[RecordDict]:
-        """Select the set of RecordDicts to aggregate using the Krum or MultiKrum
-        algorithm.
-
-        For each node, computes the sum of squared distances to its n-f-2 closest
-        parameter vectors, where n is the number of nodes and f is the number of
-        malicious nodes. The node(s) with the lowest score(s) are selected for
-        aggregation.
-
-        Parameters
-        ----------
-        replies : list[RecordDict]
-            List of RecordDicts, each containing an ArrayRecord representing model
-            parameters from a client.
-
-        Returns
-        -------
-        list[RecordDict]
-            List of RecordDicts selected for aggregation. If `num_nodes_to_keep` > 0,
-            returns the top `num_nodes_to_keep` RecordDicts (MultiKrum); otherwise,
-            returns the single RecordDict with the lowest score (Krum).
-        """
-        # Construct list of ArrayRecord objects from replies
-        # Recall aggregate_train first ensures replies only contain one ArrayRecord
-        array_records = [list(reply.array_records.values())[0] for reply in replies]
-        distance_matrix = self._compute_distances(array_records)
-
-        # For each node, take the n-f-2 closest parameters vectors
-        num_closest = max(1, len(array_records) - self.num_malicious_nodes - 2)
-        closest_indices = []
-        for distance in distance_matrix:
-            closest_indices.append(
-                np.argsort(distance)[1 : num_closest + 1].tolist()  # noqa: E203
-            )
-
-        # Compute the score for each node, that is the sum of the distances
-        # of the n-f-2 closest parameters vectors
-        scores = [
-            np.sum(distance_matrix[i, closest_indices[i]])
-            for i in range(len(distance_matrix))
-        ]
-
-        # Return RecordDicts that should be aggregated
-        if self.num_nodes_to_keep > 0:
-            # Choose to_keep nodes and return their average (MultiKrum)
-            best_indices = np.argsort(scores)[::-1][
-                len(scores) - self.num_nodes_to_keep :
-            ]  # noqa: E203
-            return [replies[i] for i in best_indices]
-
-        # Return the RecordDict with the ArrayRecord that minimize the score (Krum)
-        return [replies[np.argmin(scores)]]
-
-    def aggregate_train(
-        self,
-        server_round: int,
-        replies: Iterable[Message],
-    ) -> tuple[Optional[ArrayRecord], Optional[MetricRecord]]:
-        """Aggregate ArrayRecords and MetricRecords in the received Messages."""
-        valid_replies, _ = self._check_and_log_replies(replies, is_train=True)
-
-        arrays, metrics = None, None
-        if valid_replies:
-            reply_contents = [msg.content for msg in valid_replies]
-
-            # Krum
-            replies_to_aggregate = self._krum(reply_contents)
-
-            # Aggregate ArrayRecords
-            arrays = aggregate_arrayrecords(
-                replies_to_aggregate,
-                self.weighted_by_key,
-            )
-
-            # Aggregate MetricRecords
-            metrics = self.train_metrics_aggr_fn(
-                replies_to_aggregate,
-                self.weighted_by_key,
-            )
-        return arrays, metrics

flwr/serverapp/strategy/multikrum.py

@@ -0,0 +1,247 @@
+# Copyright 2025 Flower Labs GmbH. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Machine Learning with Adversaries: Byzantine Tolerant Gradient Descent.
+
+[Blanchard et al., 2017].
+
+Paper: proceedings.neurips.cc/paper/2017/file/f4b9ec30ad9f68f89b29639786cb62ef-Paper.pdf
+"""
+
+
+from collections.abc import Iterable
+from logging import INFO
+from typing import Callable, Optional, cast
+
+import numpy as np
+
+from flwr.common import ArrayRecord, Message, MetricRecord, NDArray, RecordDict, log
+
+from .fedavg import FedAvg
+from .strategy_utils import aggregate_arrayrecords
+
+
+# pylint: disable=too-many-instance-attributes
+class MultiKrum(FedAvg):
+    """MultiKrum [Blanchard et al., 2017] strategy.
+
+    Implementation based on https://arxiv.org/abs/1703.02757
+
+    Parameters
+    ----------
+    fraction_train : float (default: 1.0)
+        Fraction of nodes used during training. In case `min_train_nodes`
+        is larger than `fraction_train * total_connected_nodes`, `min_train_nodes`
+        will still be sampled.
+    fraction_evaluate : float (default: 1.0)
+        Fraction of nodes used during validation. In case `min_evaluate_nodes`
+        is larger than `fraction_evaluate * total_connected_nodes`,
+        `min_evaluate_nodes` will still be sampled.
+    min_train_nodes : int (default: 2)
+        Minimum number of nodes used during training.
+    min_evaluate_nodes : int (default: 2)
+        Minimum number of nodes used during validation.
+    min_available_nodes : int (default: 2)
+        Minimum number of total nodes in the system.
+    num_malicious_nodes : int (default: 0)
+        Number of malicious nodes in the system. Defaults to 0.
+    num_nodes_to_select : int (default: 1)
+        Number of nodes to select before averaging.
+    weighted_by_key : str (default: "num-examples")
+        The key within each MetricRecord whose value is used as the weight when
+        computing weighted averages for both ArrayRecords and MetricRecords.
+    arrayrecord_key : str (default: "arrays")
+        Key used to store the ArrayRecord when constructing Messages.
+    configrecord_key : str (default: "config")
+        Key used to store the ConfigRecord when constructing Messages.
+    train_metrics_aggr_fn : Optional[callable] (default: None)
+        Function with signature (list[RecordDict], str) -> MetricRecord,
+        used to aggregate MetricRecords from training round replies.
+        If `None`, defaults to `aggregate_metricrecords`, which performs a weighted
+        average using the provided weight factor key.
+    evaluate_metrics_aggr_fn : Optional[callable] (default: None)
+        Function with signature (list[RecordDict], str) -> MetricRecord,
+        used to aggregate MetricRecords from training round replies.
+        If `None`, defaults to `aggregate_metricrecords`, which performs a weighted
+        average using the provided weight factor key.
+
+    Notes
+    -----
+    MultiKrum is a generalization of Krum. If `num_nodes_to_select` is set to 1,
+    MultiKrum will reduce to classical Krum.
+    """
+
+    # pylint: disable=too-many-arguments,too-many-positional-arguments
+    def __init__(
+        self,
+        fraction_train: float = 1.0,
+        fraction_evaluate: float = 1.0,
+        min_train_nodes: int = 2,
+        min_evaluate_nodes: int = 2,
+        min_available_nodes: int = 2,
+        num_malicious_nodes: int = 0,
+        num_nodes_to_select: int = 1,
+        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,
+    ) -> None:
+        super().__init__(
+            fraction_train=fraction_train,
+            fraction_evaluate=fraction_evaluate,
+            min_train_nodes=min_train_nodes,
+            min_evaluate_nodes=min_evaluate_nodes,
+            min_available_nodes=min_available_nodes,
+            weighted_by_key=weighted_by_key,
+            arrayrecord_key=arrayrecord_key,
+            configrecord_key=configrecord_key,
+            train_metrics_aggr_fn=train_metrics_aggr_fn,
+            evaluate_metrics_aggr_fn=evaluate_metrics_aggr_fn,
+        )
+        self.num_malicious_nodes = num_malicious_nodes
+        self.num_nodes_to_select = num_nodes_to_select
+
+    def summary(self) -> None:
+        """Log summary configuration of the strategy."""
+        log(INFO, "\t├──> MultiKrum settings:")
+        log(INFO, "\t│\t├── Number of malicious nodes: %d", self.num_malicious_nodes)
+        log(INFO, "\t│\t└── Number of nodes to select: %d", self.num_nodes_to_select)
+        super().summary()
+
+    def aggregate_train(
+        self,
+        server_round: int,
+        replies: Iterable[Message],
+    ) -> tuple[Optional[ArrayRecord], Optional[MetricRecord]]:
+        """Aggregate ArrayRecords and MetricRecords in the received Messages."""
+        valid_replies, _ = self._check_and_log_replies(replies, is_train=True)
+
+        arrays, metrics = None, None
+        if valid_replies:
+            reply_contents = [msg.content for msg in valid_replies]
+
+            # Krum or MultiKrum selection
+            replies_to_aggregate = select_multikrum(
+                reply_contents,
+                num_malicious_nodes=self.num_malicious_nodes,
+                num_nodes_to_select=self.num_nodes_to_select,
+            )
+
+            # Aggregate ArrayRecords
+            arrays = aggregate_arrayrecords(
+                replies_to_aggregate,
+                self.weighted_by_key,
+            )
+
+            # Aggregate MetricRecords
+            metrics = self.train_metrics_aggr_fn(
+                replies_to_aggregate,
+                self.weighted_by_key,
+            )
+        return arrays, metrics
+
+
+def compute_distances(records: list[ArrayRecord]) -> NDArray:
+    """Compute squared L2 distances between ArrayRecords.
+
+    Parameters
+    ----------
+    records : list[ArrayRecord]
+        A list of ArrayRecords (arrays received in replies)
+
+    Returns
+    -------
+    NDArray
+        A 2D array representing the distance matrix of squared L2 distances
+        between input ArrayRecords
+    """
+    # Formula: ||x - y||^2 = ||x||^2 + ||y||^2 - 2 * x.y
+    # Flatten records and stack them into a matrix
+    flat_w = np.stack(
+        [np.concatenate(rec.to_numpy_ndarrays(), axis=None).ravel() for rec in records],
+        axis=0,
+    )  # shape: (n, d) with n number of records and d the dimension of model
+
+    # Compute squared norms of each vector
+    norms: NDArray = np.square(flat_w).sum(axis=1)  # shape (n,)
+
+    # Use broadcasting to compute pairwise distances
+    distance_matrix: NDArray = norms[:, None] + norms[None, :] - 2 * flat_w @ flat_w.T
+    return distance_matrix
+
+
+def select_multikrum(
+    contents: list[RecordDict],
+    num_malicious_nodes: int,
+    num_nodes_to_select: int,
+) -> list[RecordDict]:
+    """Select the set of RecordDicts to aggregate using the Krum or MultiKrum algorithm.
+
+    For each node, computes the sum of squared L2 distances to its n-f-2 closest
+    parameter vectors, where n is the number of nodes and f is the number of
+    malicious nodes. The node(s) with the lowest score(s) are selected for
+    aggregation.
+
+    Parameters
+    ----------
+    contents : list[RecordDict]
+        List of contents from reply messages, where each content is a RecordDict
+        containing an ArrayRecord of model parameters from a node (client).
+    num_malicious_nodes : int
+        Number of malicious nodes in the system.
+    num_nodes_to_select : int
+        Number of client updates to select.
+        - If 1, the algorithm reduces to classical Krum (selecting a single update).
+        - If >1, Multi-Krum is applied (selecting multiple updates).
+
+    Returns
+    -------
+    list[RecordDict]
+        Selected contents following the Krum or Multi-Krum algorithm.
+
+    Notes
+    -----
+    If `num_nodes_to_select` is set to 1, Multi-Krum reduces to classical Krum
+    and only a single RecordDict is selected.
+    """
+    # Construct list of ArrayRecord objects from replies
+    record_key = list(contents[0].array_records.keys())[0]
+    # Recall aggregate_train first ensures replies only contain one ArrayRecord
+    array_records = [cast(ArrayRecord, reply[record_key]) for reply in contents]
+    distance_matrix = compute_distances(array_records)
+
+    # For each node, take the n-f-2 closest parameters vectors
+    num_closest = max(1, len(array_records) - num_malicious_nodes - 2)
+    closest_indices = []
+    for distance in distance_matrix:
+        closest_indices.append(
+            np.argsort(distance)[1 : num_closest + 1].tolist()  # noqa: E203
+        )
+
+    # Compute the score for each node, that is the sum of the distances
+    # of the n-f-2 closest parameters vectors
+    scores = [
+        np.sum(distance_matrix[i, closest_indices[i]])
+        for i in range(len(distance_matrix))
+    ]
+
+    # Choose the num_nodes_to_select lowest-scoring nodes (MultiKrum)
+    # and return their updates
+    best_indices = np.argsort(scores)[:num_nodes_to_select]
+    return [contents[i] for i in best_indices]

{flwr_nightly-1.22.0.dev20250919.dist-info → flwr_nightly-1.23.0.dev20250921.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: flwr-nightly
-Version: 1.22.0.dev20250919
+Version: 1.23.0.dev20250921
 Summary: Flower: A Friendly Federated AI Framework
 License: Apache-2.0
 Keywords: Artificial Intelligence,Federated AI,Federated Analytics,Federated Evaluation,Federated Learning,Flower,Machine Learning

{flwr_nightly-1.22.0.dev20250919.dist-info → flwr_nightly-1.23.0.dev20250921.dist-info}/RECORD

@@ -69,17 +69,17 @@ flwr/cli/new/templates/app/code/task.sklearn.py.tpl,sha256=vHdhtMp0FHxbYafXyhDT9
 flwr/cli/new/templates/app/code/task.tensorflow.py.tpl,sha256=impgWN7MfztmcWF4xh1llcZGsgTvrb1HD5ZE0t-8U08,1731
 flwr/cli/new/templates/app/code/task.xgboost.py.tpl,sha256=0xO8jQvrHuB1llVDopQPOmt5Hn6rBw8umzoNwiZZs-o,2135
 flwr/cli/new/templates/app/code/utils.baseline.py.tpl,sha256=YkHAgppUeD2BnBoGfVB6dEvBfjuIPGsU1gw4CiUi3qA,40
-flwr/cli/new/templates/app/pyproject.baseline.toml.tpl,sha256=mPIMPfneVYV03l8jWRgWZ0V5Kh_pJw-AMUvkhcKkmL8,3182
-flwr/cli/new/templates/app/pyproject.flowertune.toml.tpl,sha256=wqYW4bWcf12m0U2njR995lySSesFvnHB-eSkPWz-QdM,2501
-flwr/cli/new/templates/app/pyproject.huggingface.toml.tpl,sha256=xHGF38i7oFpvnFvqfqLdtc08CkHRYsenbLz3q1dhCXk,2020
-flwr/cli/new/templates/app/pyproject.jax.toml.tpl,sha256=fdDhwmPoMirJ095cU_vFCBf0ILQlAoa1fdnHb2LM1yk,1471
-flwr/cli/new/templates/app/pyproject.mlx.toml.tpl,sha256=PAjPT2v06sBZxacNiyMJloDwocCK5tFcGQmMXOoBqc8,1542
-flwr/cli/new/templates/app/pyproject.numpy.toml.tpl,sha256=Kb_O2iQfzwc6FTy3fWqtQYc3FwY6x9SUgQPGqZR_ILg,1409
-flwr/cli/new/templates/app/pyproject.pytorch.toml.tpl,sha256=SE4H23OFkQbqNU64nYf38igqrT4cJGA7XxEtSnNxJqg,1490
-flwr/cli/new/templates/app/pyproject.pytorch_legacy_api.toml.tpl,sha256=docQbs3MuRR-yT24lVz7N2sQL3Sj49EHuOCuRj_0djQ,1508
-flwr/cli/new/templates/app/pyproject.sklearn.toml.tpl,sha256=apauU_PUmLEbt2rjckKniEbzdRs1EnMri_qgtHtBJZ8,1484
-flwr/cli/new/templates/app/pyproject.tensorflow.toml.tpl,sha256=LQpDKJTEnRKj5Ygn5FkT44SxlnLVprkPlbrGaFf5Q50,1508
-flwr/cli/new/templates/app/pyproject.xgboost.toml.tpl,sha256=504pHibNRGFe-DLnzqHLYhKeF_n8BPMv0Xog5EfnZ0M,1661
+flwr/cli/new/templates/app/pyproject.baseline.toml.tpl,sha256=7t57rL9zAjCC0Vd1T2LMkPXvl2x0V0iVDTap4oC66LY,3182
+flwr/cli/new/templates/app/pyproject.flowertune.toml.tpl,sha256=iwUlPEC2DsDuIuY3FZmEDxqKkUqcWTLFZXxObFGAXEU,2501
+flwr/cli/new/templates/app/pyproject.huggingface.toml.tpl,sha256=PiQemjUmmLWCdjiZylXFTZer7VhqxqT4_BXbDYw1uh4,2020
+flwr/cli/new/templates/app/pyproject.jax.toml.tpl,sha256=S6PvrDW1JPGnVs6Nfn2e6GHg0taZKt3bTmM-5KKyUpo,1471
+flwr/cli/new/templates/app/pyproject.mlx.toml.tpl,sha256=K00iuPOuqJBGgNE-eFiv5-bahM6PwKtf-6g7lH7FBx8,1542
+flwr/cli/new/templates/app/pyproject.numpy.toml.tpl,sha256=1ptnw1a7wcb3UxbDVquudZ79Z6oTbJl6q33KAGq0cEo,1409
+flwr/cli/new/templates/app/pyproject.pytorch.toml.tpl,sha256=TEqf7kWd4tsN3TbNNosN0o2DAWn4W2OFHqipCf-5gCU,1490
+flwr/cli/new/templates/app/pyproject.pytorch_legacy_api.toml.tpl,sha256=ZWW31QEdrqIvIIWn0UFEYUkgufgDnWQtMSgDGOnWgv8,1508
+flwr/cli/new/templates/app/pyproject.sklearn.toml.tpl,sha256=Elh5bUTVBNRG1aDTrgQcZgjfrXcIaVXH00UduNJDZ2U,1484
+flwr/cli/new/templates/app/pyproject.tensorflow.toml.tpl,sha256=g7SYiAJr6Uhwg4ZsQI2qsLVeizU8vd0CzR0_jka99_A,1508
+flwr/cli/new/templates/app/pyproject.xgboost.toml.tpl,sha256=yAJ9jL2q6U_XXYwwUT9fpIqIKFuQR_Kgg82GpWfQ5J8,1661
 flwr/cli/pull.py,sha256=dHiMe6x8w8yRoFNKpjA-eiPD6eFiHz4Vah5HZrqNpuo,3364
 flwr/cli/run/__init__.py,sha256=RPyB7KbYTFl6YRiilCch6oezxrLQrl1kijV7BMGkLbA,790
 flwr/cli/run/run.py,sha256=ECa0kup9dn15O70H74QdgUsEaeErbzDqVX_U0zZO5IM,8173
@@ -113,8 +113,9 @@ flwr/client/rest_client/connection.py,sha256=fyiS1aXTv71jWczx7mSco94LYJTBXgTF-p2
 flwr/client/run_info_store.py,sha256=MaJ3UQ-07hWtK67wnWu0zR29jrk0fsfgJX506dvEOfE,4042
 flwr/client/typing.py,sha256=Jw3rawDzI_-ZDcRmEQcs5gZModY7oeQlEeltYsdOhlU,1048
 flwr/clientapp/__init__.py,sha256=uoTjvIynfGvMhsmc7iYK-5qJ0AdKKjCbx7WTKc0KeSk,828
-flwr/clientapp/mod/__init__.py,sha256=LZveV-U2YZVEH4FyAZMXMT-aD1Hc0I5miIkDr7p6uQQ,970
-flwr/clientapp/mod/centraldp_mods.py,sha256=a-F-ELs3lt_wtmLl8900ExJiIY792cPCrmwmJKRrerI,8950
+flwr/clientapp/mod/__init__.py,sha256=w18mDPUmjlm5P_er2GJ7l6Zbh8qyiHfMKoVqXxaTxdE,1024
+flwr/clientapp/mod/centraldp_mods.py,sha256=bL2NMxbin9nj2OYSHbuOvIPk0rKH6xyAxG-pbtP9ISY,8954
+flwr/clientapp/mod/localdp_mod.py,sha256=L3kQK3kjc-vwlhJcBwFIK6EiwBYlpHQkv4jiR7K9abQ,5642
 flwr/clientapp/typing.py,sha256=x1GvXWy112RqZh27liJqz-yZ7SSCOwiOSmAQsUxk9MY,853
 flwr/common/__init__.py,sha256=5GCLVk399Az_rTJHNticRlL0Sl_oPw_j5_LuFKfX7-M,4171
 flwr/common/address.py,sha256=9JucdTwlc-jpeJkRKeUboZoacUtErwSVtnDR9kAtLqE,4119
@@ -337,21 +338,23 @@ flwr/server/workflow/secure_aggregation/secagg_workflow.py,sha256=b_pKk7gmbahwyj
 flwr/server/workflow/secure_aggregation/secaggplus_workflow.py,sha256=DkayCsnlAya6Y2PZsueLgoUCMRtV-GbnW08RfWx_SXM,29460
 flwr/serverapp/__init__.py,sha256=ZujKNXULwhWYQhFnxOOT5Wi9MRq2JCWFhAAj7ouiQ78,884
 flwr/serverapp/exception.py,sha256=5cuH-2AafvihzosWDdDjuMmHdDqZ1XxHvCqZXNBVklw,1334
-flwr/serverapp/strategy/__init__.py,sha256=QQFa0uMXWrSCTVbd7Ixk_48U6o3K-g4nLYYJUhEVbfo,1877
+flwr/serverapp/strategy/__init__.py,sha256=dezK2TKSffjjBVXW18ATRxJLTuQ7I2M1dPuNi5y-_6c,1968
+flwr/serverapp/strategy/bulyan.py,sha256=lSFOZof5NDzDFS6206rp6V_08LsitSHIHOOckcLt4_E,9306
 flwr/serverapp/strategy/dp_adaptive_clipping.py,sha256=mssiVGMgfJw8DeP6_pBSZUKWmaXvYeG-B-p7RSt2tAU,13600
 flwr/serverapp/strategy/dp_fixed_clipping.py,sha256=C_faT0ggzeUB2bGv_r1Vss-fv7-UhDrpmfiHATESI0w,12832
 flwr/serverapp/strategy/fedadagrad.py,sha256=faFsuKZziPTCLeNrJOyKbPTNo-1xrIZOz7SWT5rdjJs,6269
 flwr/serverapp/strategy/fedadam.py,sha256=NsY_V6TGFAfCeA9vmqaLpvB_T5siJEtKozKGdxJssAI,7064
 flwr/serverapp/strategy/fedavg.py,sha256=Bq_nlmngzJbjqX1fF1mevXGVN6-pwglHv-6yNrs6lkA,12035
 flwr/serverapp/strategy/fedavgm.py,sha256=FtFmBGLzuUQ_7JWk85Xh19d8sP0YDwqczGTliGzZyGs,8333
-flwr/serverapp/strategy/fedmedian.py,sha256=b31Dk0LQBbQxi_f-jeSbWHI7iOBugcuBSN2Az-_a75E,2596
+flwr/serverapp/strategy/fedmedian.py,sha256=yhGg6WGWYEbn3oYMfnCBm1F7v9u5LHYVsSAYvdI9Pns,4498
 flwr/serverapp/strategy/fedopt.py,sha256=kqT0uV2IUE93O72XEVa1JJo61dcwbZEoT9KmYTjR2tE,8477
 flwr/serverapp/strategy/fedprox.py,sha256=J1KrcE5DFko6i4608iICv1G0t9MPXspjibPd-SF_HT8,7028
 flwr/serverapp/strategy/fedtrimmedavg.py,sha256=58xDPc_YO41QM8jXn0gZ79PFzO8zo3Mh3UlkF0UBbIA,7168
-flwr/serverapp/strategy/fedxgb_bagging.py,sha256=ktDjzov4y0BRecioq788umCEtcuwElou9olBizQKOnM,3282
-flwr/serverapp/strategy/fedxgb_cyclic.py,sha256=8H8WoLdG4Fy1_dtLLE4AYiidC-Cvaw2GxySfzAb7Xj0,8774
+flwr/serverapp/strategy/fedxgb_bagging.py,sha256=QAnsQXTE1qzj1qGkZ8mCOfmSKJ2pO_gG9YgmJH-EV6s,5189
+flwr/serverapp/strategy/fedxgb_cyclic.py,sha256=yedhRJ7dEz-Yi5yEiS9zki_LKHPHAk962PWCYLLDLoY,8752
 flwr/serverapp/strategy/fedyogi.py,sha256=Y9RFBQaNch3fPgGXF7OfnTH6eOpavZxpMWxWVIC9_SY,6579
-flwr/serverapp/strategy/krum.py,sha256=iUM7MFCKQcSqUO3Eu4JKWnMc8NV0WMQW9dZXm4onQ-s,9490
+flwr/serverapp/strategy/krum.py,sha256=kcy8TQuJC_qkYJ7jtn26lx2VYYBHlQC_LjNWOuCw9ZQ,4848
+flwr/serverapp/strategy/multikrum.py,sha256=bv44TzMQHh1NEp3ilt0ANoR5xHJ4kpb0qxzSzXD_lx0,9865
 flwr/serverapp/strategy/qfedavg.py,sha256=EM1tO_ovkybOBeW-h1PYX0lszCUAVHT6hUpwXykAEps,10204
 flwr/serverapp/strategy/result.py,sha256=E0Hl2VLnZAgQJjE2GDoKsK7JX-kPPU2KXc47Axt6hGw,4295
 flwr/serverapp/strategy/strategy.py,sha256=8uJGGm1ROLZERQ_dkRS7Z_rs-yK6XCE0UxXtIdFiEWk,10789
@@ -419,7 +422,7 @@ flwr/supernode/servicer/__init__.py,sha256=lucTzre5WPK7G1YLCfaqg3rbFWdNSb7ZTt-ca
 flwr/supernode/servicer/clientappio/__init__.py,sha256=7Oy62Y_oijqF7Dxi6tpcUQyOpLc_QpIRZ83NvwmB0Yg,813
 flwr/supernode/servicer/clientappio/clientappio_servicer.py,sha256=nIHRu38EWK-rpNOkcgBRAAKwYQQWFeCwu0lkO7OPZGQ,10239
 flwr/supernode/start_client_internal.py,sha256=Y9S1-QlO2WP6eo4JvWzIpfaCoh2aoE7bjEYyxNNnlyg,20777
-flwr_nightly-1.22.0.dev20250919.dist-info/METADATA,sha256=RuNCBGYrX4Df-vdIVKJ6Do1uDfeKomIIJ557ZlE8uLI,14559
-flwr_nightly-1.22.0.dev20250919.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-flwr_nightly-1.22.0.dev20250919.dist-info/entry_points.txt,sha256=hxHD2ixb_vJFDOlZV-zB4Ao32_BQlL34ftsDh1GXv14,420
-flwr_nightly-1.22.0.dev20250919.dist-info/RECORD,,
+flwr_nightly-1.23.0.dev20250921.dist-info/METADATA,sha256=zNvKQmiC8a35nT_ngTXES5yhX0VkHdKKjvaFIMRr4QM,14559
+flwr_nightly-1.23.0.dev20250921.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+flwr_nightly-1.23.0.dev20250921.dist-info/entry_points.txt,sha256=hxHD2ixb_vJFDOlZV-zB4Ao32_BQlL34ftsDh1GXv14,420
+flwr_nightly-1.23.0.dev20250921.dist-info/RECORD,,