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

flwr/cli/new/templates/app/code/client.pytorch_msg_api.py.tpl

@@ -1,80 +0,0 @@
-"""$project_name: A Flower / $framework_str app."""
-
-import torch
-from flwr.app import ArrayRecord, Context, Message, MetricRecord, RecordDict
-from flwr.clientapp import ClientApp
-
-from $import_name.task import Net, load_data
-from $import_name.task import test as test_fn
-from $import_name.task import train as train_fn
-
-# Flower ClientApp
-app = ClientApp()
-
-
-@app.train()
-def train(msg: Message, context: Context):
-    """Train the model on local data."""
-
-    # Load the model and initialize it with the received weights
-    model = Net()
-    model.load_state_dict(msg.content["arrays"].to_torch_state_dict())
-    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
-    model.to(device)
-
-    # Load the data
-    partition_id = context.node_config["partition-id"]
-    num_partitions = context.node_config["num-partitions"]
-    trainloader, _ = load_data(partition_id, num_partitions)
-
-    # Call the training function
-    train_loss = train_fn(
-        model,
-        trainloader,
-        context.run_config["local-epochs"],
-        msg.content["config"]["lr"],
-        device,
-    )
-
-    # Construct and return reply Message
-    model_record = ArrayRecord(model.state_dict())
-    metrics = {
-        "train_loss": train_loss,
-        "num-examples": len(trainloader.dataset),
-    }
-    metric_record = MetricRecord(metrics)
-    content = RecordDict({"arrays": model_record, "metrics": metric_record})
-    return Message(content=content, reply_to=msg)
-
-
-@app.evaluate()
-def evaluate(msg: Message, context: Context):
-    """Evaluate the model on local data."""
-
-    # Load the model and initialize it with the received weights
-    model = Net()
-    model.load_state_dict(msg.content["arrays"].to_torch_state_dict())
-    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
-    model.to(device)
-
-    # Load the data
-    partition_id = context.node_config["partition-id"]
-    num_partitions = context.node_config["num-partitions"]
-    _, valloader = load_data(partition_id, num_partitions)
-
-    # Call the evaluation function
-    eval_loss, eval_acc = test_fn(
-        model,
-        valloader,
-        device,
-    )
-
-    # Construct and return reply Message
-    metrics = {
-        "eval_loss": eval_loss,
-        "eval_acc": eval_acc,
-        "num-examples": len(valloader.dataset),
-    }
-    metric_record = MetricRecord(metrics)
-    content = RecordDict({"metrics": metric_record})
-    return Message(content=content, reply_to=msg)

flwr/cli/new/templates/app/code/server.pytorch_msg_api.py.tpl

@@ -1,41 +0,0 @@
-"""$project_name: A Flower / $framework_str app."""
-
-import torch
-from flwr.app import ArrayRecord, ConfigRecord, Context
-from flwr.serverapp import Grid, ServerApp
-from flwr.serverapp.strategy import FedAvg
-
-from $import_name.task import Net
-
-# Create ServerApp
-app = ServerApp()
-
-
-@app.main()
-def main(grid: Grid, context: Context) -> None:
-    """Main entry point for the ServerApp."""
-
-    # Read run config
-    fraction_train: float = context.run_config["fraction-train"]
-    num_rounds: int = context.run_config["num-server-rounds"]
-    lr: float = context.run_config["lr"]
-
-    # Load global model
-    global_model = Net()
-    arrays = ArrayRecord(global_model.state_dict())
-
-    # Initialize FedAvg strategy
-    strategy = FedAvg(fraction_train=fraction_train)
-
-    # Start strategy, run FedAvg for `num_rounds`
-    result = strategy.start(
-        grid=grid,
-        initial_arrays=arrays,
-        train_config=ConfigRecord({"lr": lr}),
-        num_rounds=num_rounds,
-    )
-
-    # Save final model to disk
-    print("\nSaving final model to disk...")
-    state_dict = result.arrays.to_torch_state_dict()
-    torch.save(state_dict, "final_model.pt")

flwr/common/auth_plugin/auth_plugin.py

@@ -1,149 +0,0 @@
-# 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.
-# ==============================================================================
-"""Abstract classes for Flower User Auth Plugin."""
-
-
-from abc import ABC, abstractmethod
-from collections.abc import Sequence
-from pathlib import Path
-from typing import Optional, Union
-
-from flwr.common.typing import AccountInfo
-from flwr.proto.control_pb2_grpc import ControlStub
-
-from ..typing import UserAuthCredentials, UserAuthLoginDetails
-
-
-class ControlAuthPlugin(ABC):
-    """Abstract Flower Auth Plugin class for ControlServicer.
-
-    Parameters
-    ----------
-    user_auth_config_path : Path
-        Path to the YAML file containing the authentication configuration.
-    verify_tls_cert : bool
-        Boolean indicating whether to verify the TLS certificate
-        when making requests to the server.
-    """
-
-    @abstractmethod
-    def __init__(
-        self,
-        user_auth_config_path: Path,
-        verify_tls_cert: bool,
-    ):
-        """Abstract constructor."""
-
-    @abstractmethod
-    def get_login_details(self) -> Optional[UserAuthLoginDetails]:
-        """Get the login details."""
-
-    @abstractmethod
-    def validate_tokens_in_metadata(
-        self, metadata: Sequence[tuple[str, Union[str, bytes]]]
-    ) -> tuple[bool, Optional[AccountInfo]]:
-        """Validate authentication tokens in the provided metadata."""
-
-    @abstractmethod
-    def get_auth_tokens(self, device_code: str) -> Optional[UserAuthCredentials]:
-        """Get authentication tokens."""
-
-    @abstractmethod
-    def refresh_tokens(
-        self, metadata: Sequence[tuple[str, Union[str, bytes]]]
-    ) -> tuple[
-        Optional[Sequence[tuple[str, Union[str, bytes]]]], Optional[AccountInfo]
-    ]:
-        """Refresh authentication tokens in the provided metadata."""
-
-
-class ControlAuthzPlugin(ABC):  # pylint: disable=too-few-public-methods
-    """Abstract Flower Authorization Plugin class for ControlServicer.
-
-    Parameters
-    ----------
-    user_auth_config_path : Path
-        Path to the YAML file containing the authorization configuration.
-    verify_tls_cert : bool
-        Boolean indicating whether to verify the TLS certificate
-        when making requests to the server.
-    """
-
-    @abstractmethod
-    def __init__(self, user_auth_config_path: Path, verify_tls_cert: bool):
-        """Abstract constructor."""
-
-    @abstractmethod
-    def verify_user_authorization(self, account_info: AccountInfo) -> bool:
-        """Verify user authorization request."""
-
-
-class CliAuthPlugin(ABC):
-    """Abstract Flower Auth Plugin class for CLI.
-
-    Parameters
-    ----------
-    credentials_path : Path
-        Path to the user's authentication credentials file.
-    """
-
-    @staticmethod
-    @abstractmethod
-    def login(
-        login_details: UserAuthLoginDetails,
-        control_stub: ControlStub,
-    ) -> UserAuthCredentials:
-        """Authenticate the user and retrieve authentication credentials.
-
-        Parameters
-        ----------
-        login_details : UserAuthLoginDetails
-            An object containing the user's login details.
-        control_stub : ControlStub
-            A stub for executing RPC calls to the server.
-
-        Returns
-        -------
-        UserAuthCredentials
-            The authentication credentials obtained after login.
-        """
-
-    @abstractmethod
-    def __init__(self, credentials_path: Path):
-        """Abstract constructor."""
-
-    @abstractmethod
-    def store_tokens(self, credentials: UserAuthCredentials) -> None:
-        """Store authentication tokens to the `credentials_path`.
-
-        The credentials, including tokens, will be saved as a JSON file
-        at `credentials_path`.
-        """
-
-    @abstractmethod
-    def load_tokens(self) -> None:
-        """Load authentication tokens from the `credentials_path`."""
-
-    @abstractmethod
-    def write_tokens_to_metadata(
-        self, metadata: Sequence[tuple[str, Union[str, bytes]]]
-    ) -> Sequence[tuple[str, Union[str, bytes]]]:
-        """Write authentication tokens to the provided metadata."""
-
-    @abstractmethod
-    def read_tokens_from_metadata(
-        self, metadata: Sequence[tuple[str, Union[str, bytes]]]
-    ) -> Optional[UserAuthCredentials]:
-        """Read authentication tokens from the provided metadata."""

flwr/serverapp/dp_fixed_clipping.py

@@ -1,352 +0,0 @@
-# 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.
-# ==============================================================================
-"""Message-based Central differential privacy with fixed clipping.
-
-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 (
-    add_gaussian_noise_inplace,
-    compute_clip_model_update,
-    compute_stdv,
-)
-from flwr.common.differential_privacy_constants import (
-    CLIENTS_DISCREPANCY_WARNING,
-    KEY_CLIPPING_NORM,
-)
-from flwr.server import Grid
-
-from .strategy import Strategy
-
-
-class DifferentialPrivacyFixedClippingBase(Strategy, ABC):
-    """Base class for DP strategies with fixed clipping.
-
-    This class contains common functionality shared between server-side and
-    client-side fixed clipping implementations.
-
-    Parameters
-    ----------
-    strategy : Strategy
-        The strategy to which DP functionalities will be added by this wrapper.
-    noise_multiplier : float
-        The noise multiplier for the Gaussian mechanism for model updates.
-        A value of 1.0 or higher is recommended for strong privacy.
-    clipping_norm : float
-        The value of the clipping norm.
-    num_sampled_clients : int
-        The number of clients that are sampled on each round.
-    """
-
-    # pylint: disable=too-many-arguments,too-many-instance-attributes
-    def __init__(
-        self,
-        strategy: Strategy,
-        noise_multiplier: float,
-        clipping_norm: float,
-        num_sampled_clients: int,
-    ) -> None:
-        super().__init__()
-
-        self.strategy = strategy
-
-        if noise_multiplier < 0:
-            raise ValueError("The noise multiplier should be a non-negative value.")
-
-        if clipping_norm <= 0:
-            raise ValueError("The clipping norm should be a positive value.")
-
-        if num_sampled_clients <= 0:
-            raise ValueError(
-                "The number of sampled clients should be a positive value."
-            )
-
-        self.noise_multiplier = noise_multiplier
-        self.clipping_norm = clipping_norm
-        self.num_sampled_clients = num_sampled_clients
-
-    def _validate_replies(self, replies: Iterable[Message]) -> bool:
-        """Validate replies and log errors/warnings.
-
-        Returns
-        -------
-        bool
-            True if replies are valid for aggregation, False otherwise.
-        """
-        num_errors = 0
-        num_replies_with_content = 0
-        for msg in replies:
-            if msg.has_error():
-                log(
-                    INFO,
-                    "Received error in reply from node %d: %s",
-                    msg.metadata.src_node_id,
-                    msg.error,
-                )
-                num_errors += 1
-            else:
-                num_replies_with_content += 1
-
-        # Errors are not allowed
-        if num_errors:
-            log(
-                INFO,
-                "aggregate_train: Some clients reported errors. Skipping aggregation.",
-            )
-            return False
-
-        log(
-            INFO,
-            "aggregate_train: Received %s results and %s failures",
-            num_replies_with_content,
-            num_errors,
-        )
-
-        if num_replies_with_content != self.num_sampled_clients:
-            log(
-                WARNING,
-                CLIENTS_DISCREPANCY_WARNING,
-                num_replies_with_content,
-                self.num_sampled_clients,
-            )
-
-        return True
-
-    def _add_noise_to_aggregated_arrays(
-        self, aggregated_arrays: ArrayRecord
-    ) -> ArrayRecord:
-        """Add Gaussian noise to aggregated arrays.
-
-        Parameters
-        ----------
-        aggregated_arrays : ArrayRecord
-            The aggregated arrays to add noise to.
-
-        Returns
-        -------
-        ArrayRecord
-            The aggregated arrays with noise added.
-        """
-        aggregated_ndarrays = aggregated_arrays.to_numpy_ndarrays()
-        stdv = compute_stdv(
-            self.noise_multiplier, self.clipping_norm, self.num_sampled_clients
-        )
-        add_gaussian_noise_inplace(aggregated_ndarrays, 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_arrays.keys(), aggregated_ndarrays)
-                }
-            )
-        )
-
-    def configure_evaluate(
-        self, server_round: int, arrays: ArrayRecord, config: ConfigRecord, grid: Grid
-    ) -> Iterable[Message]:
-        """Configure the next round of federated evaluation."""
-        return self.strategy.configure_evaluate(server_round, arrays, config, grid)
-
-    def aggregate_evaluate(
-        self,
-        server_round: int,
-        replies: Iterable[Message],
-    ) -> Optional[MetricRecord]:
-        """Aggregate MetricRecords in the received Messages."""
-        return self.strategy.aggregate_evaluate(server_round, replies)
-
-    def summary(self) -> None:
-        """Log summary configuration of the strategy."""
-        self.strategy.summary()
-
-
-class DifferentialPrivacyServerSideFixedClipping(DifferentialPrivacyFixedClippingBase):
-    """Strategy wrapper for central DP with server-side fixed clipping.
-
-    Parameters
-    ----------
-    strategy : Strategy
-        The strategy to which DP functionalities will be added by this wrapper.
-    noise_multiplier : float
-        The noise multiplier for the Gaussian mechanism for model updates.
-        A value of 1.0 or higher is recommended for strong privacy.
-    clipping_norm : float
-        The value of the clipping norm.
-    num_sampled_clients : int
-        The number of clients that are sampled on each round.
-
-    Examples
-    --------
-    Create a strategy::
-
-        strategy = fl.serverapp.FedAvg( ... )
-
-    Wrap the strategy with the `DifferentialPrivacyServerSideFixedClipping` wrapper::
-
-        dp_strategy = DifferentialPrivacyServerSideFixedClipping(
-            strategy, cfg.noise_multiplier, cfg.clipping_norm, cfg.num_sampled_clients
-        )
-    """
-
-    def __init__(
-        self,
-        strategy: Strategy,
-        noise_multiplier: float,
-        clipping_norm: float,
-        num_sampled_clients: int,
-    ) -> None:
-        super().__init__(strategy, noise_multiplier, clipping_norm, num_sampled_clients)
-        self.current_arrays: ArrayRecord = ArrayRecord()
-
-    def __repr__(self) -> str:
-        """Compute a string representation of the strategy."""
-        return "Differential Privacy Strategy Wrapper (Server-Side Fixed Clipping)"
-
-    def configure_train(
-        self, server_round: int, arrays: ArrayRecord, config: ConfigRecord, grid: Grid
-    ) -> Iterable[Message]:
-        """Configure the next round of training."""
-        self.current_arrays = arrays
-        return self.strategy.configure_train(server_round, arrays, config, grid)
-
-    def aggregate_train(
-        self,
-        server_round: int,
-        replies: Iterable[Message],
-    ) -> tuple[Optional[ArrayRecord], Optional[MetricRecord]]:
-        """Aggregate ArrayRecords and MetricRecords in the received Messages."""
-        if not self._validate_replies(replies):
-            return None, None
-
-        # Clip arrays in replies
-        current_ndarrays = self.current_arrays.to_numpy_ndarrays()
-        for reply in replies:
-            for arr_name, record in reply.content.array_records.items():
-                # Clip
-                reply_ndarrays = record.to_numpy_ndarrays()
-                compute_clip_model_update(
-                    param1=reply_ndarrays,
-                    param2=current_ndarrays,
-                    clipping_norm=self.clipping_norm,
-                )
-                # Replace content while preserving keys
-                reply.content[arr_name] = ArrayRecord(
-                    OrderedDict(
-                        {k: Array(v) for k, v in zip(record.keys(), reply_ndarrays)}
-                    )
-                )
-            log(
-                INFO,
-                "aggregate_fit: parameters are clipped by value: %.4f.",
-                self.clipping_norm,
-            )
-
-        # Pass the new parameters for aggregation
-        aggregated_arrays, aggregated_metrics = self.strategy.aggregate_train(
-            server_round, replies
-        )
-
-        # Add Gaussian noise to the aggregated arrays
-        if aggregated_arrays:
-            aggregated_arrays = self._add_noise_to_aggregated_arrays(aggregated_arrays)
-
-        return aggregated_arrays, aggregated_metrics
-
-
-class DifferentialPrivacyClientSideFixedClipping(DifferentialPrivacyFixedClippingBase):
-    """Strategy wrapper for central DP with client-side fixed clipping.
-
-    Use `fixedclipping_mod` modifier at the client side.
-
-    In comparison to `DifferentialPrivacyServerSideFixedClipping`,
-    which performs clipping on the server-side,
-    `DifferentialPrivacyClientSideFixedClipping` expects clipping to happen
-    on the client-side, usually by using the built-in `fixedclipping_mod`.
-
-    Parameters
-    ----------
-    strategy : Strategy
-        The strategy to which DP functionalities will be added by this wrapper.
-    noise_multiplier : float
-        The noise multiplier for the Gaussian mechanism for model updates.
-        A value of 1.0 or higher is recommended for strong privacy.
-    clipping_norm : float
-        The value of the clipping norm.
-    num_sampled_clients : int
-        The number of clients that are sampled on each round.
-
-    Examples
-    --------
-    Create a strategy::
-
-        strategy = fl.serverapp.FedAvg(...)
-
-    Wrap the strategy with the `DifferentialPrivacyClientSideFixedClipping` wrapper::
-
-        dp_strategy = DifferentialPrivacyClientSideFixedClipping(
-            strategy, cfg.noise_multiplier, cfg.clipping_norm, cfg.num_sampled_clients
-        )
-
-    On the client, add the `fixedclipping_mod` to the client-side mods::
-
-        app = fl.client.ClientApp(mods=[fixedclipping_mod])
-    """
-
-    def __repr__(self) -> str:
-        """Compute a string representation of the strategy."""
-        return "Differential Privacy Strategy Wrapper (Client-Side Fixed Clipping)"
-
-    def configure_train(
-        self, server_round: int, arrays: ArrayRecord, config: ConfigRecord, grid: Grid
-    ) -> Iterable[Message]:
-        """Configure the next round of training."""
-        # Inject clipping norm in config
-        config[KEY_CLIPPING_NORM] = self.clipping_norm
-        # Call parent method
-        return self.strategy.configure_train(server_round, arrays, config, grid)
-
-    def aggregate_train(
-        self,
-        server_round: int,
-        replies: Iterable[Message],
-    ) -> tuple[Optional[ArrayRecord], Optional[MetricRecord]]:
-        """Aggregate ArrayRecords and MetricRecords in the received Messages."""
-        if not self._validate_replies(replies):
-            return None, None
-
-        # Aggregate
-        aggregated_arrays, aggregated_metrics = self.strategy.aggregate_train(
-            server_round, replies
-        )
-
-        # Add Gaussian noise to the aggregated arrays
-        if aggregated_arrays:
-            aggregated_arrays = self._add_noise_to_aggregated_arrays(aggregated_arrays)
-
-        return aggregated_arrays, aggregated_metrics