flwr-nightly 1.8.0.dev20240315__py3-none-any.whl → 1.15.0.dev20250115__py3-none-any.whl

flwr/client/heartbeat.py

@@ -0,0 +1,74 @@
+# Copyright 2024 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.
+# ==============================================================================
+"""Heartbeat utility functions."""
+
+
+import threading
+from typing import Callable
+
+import grpc
+
+from flwr.common.constant import PING_CALL_TIMEOUT
+from flwr.common.retry_invoker import RetryInvoker, RetryState, exponential
+
+
+def _ping_loop(ping_fn: Callable[[], None], stop_event: threading.Event) -> None:
+    def wait_fn(wait_time: float) -> None:
+        if not stop_event.is_set():
+            stop_event.wait(wait_time)
+
+    def on_backoff(state: RetryState) -> None:
+        err = state.exception
+        if not isinstance(err, grpc.RpcError):
+            return
+        status_code = err.code()
+        # If ping call timeout is triggered
+        if status_code == grpc.StatusCode.DEADLINE_EXCEEDED:
+            # Avoid long wait time.
+            if state.actual_wait is None:
+                return
+            state.actual_wait = max(state.actual_wait - PING_CALL_TIMEOUT, 0.0)
+
+    def wrapped_ping() -> None:
+        if not stop_event.is_set():
+            ping_fn()
+
+    retrier = RetryInvoker(
+        exponential,
+        grpc.RpcError,
+        max_tries=None,
+        max_time=None,
+        on_backoff=on_backoff,
+        wait_function=wait_fn,
+    )
+    while not stop_event.is_set():
+        retrier.invoke(wrapped_ping)
+
+
+def start_ping_loop(
+    ping_fn: Callable[[], None], stop_event: threading.Event
+) -> threading.Thread:
+    """Start a ping loop in a separate thread.
+
+    This function initializes a new thread that runs a ping loop, allowing for
+    asynchronous ping operations. The loop can be terminated through the provided stop
+    event.
+    """
+    thread = threading.Thread(
+        target=_ping_loop, args=(ping_fn, stop_event), daemon=True
+    )
+    thread.start()
+
+    return thread

flwr/client/message_handler/__init__.py

@@ -1,4 +1,4 @@
-# Copyright 2020 Flower Labs GmbH. All Rights Reserved.
+# Copyright 2022 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.

flwr/client/message_handler/message_handler.py

@@ -1,4 +1,4 @@
-# Copyright 2020 Flower Labs GmbH. All Rights Reserved.
+# Copyright 2022 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.
@@ -16,7 +16,7 @@
 
 
 from logging import WARN
-from typing import Optional, Tuple, cast
+from typing import Optional, cast
 
 from flwr.client.client import (
     maybe_call_evaluate,
@@ -25,7 +25,7 @@ from flwr.client.client import (
     maybe_call_get_properties,
 )
 from flwr.client.numpy_client import NumPyClient
-from flwr.client.typing import ClientFn
+from flwr.client.typing import ClientFnExt
 from flwr.common import ConfigsRecord, Context, Message, Metadata, RecordSet, log
 from flwr.common.constant import MessageType, MessageTypeLegacy
 from flwr.common.recordset_compat import (
@@ -53,7 +53,7 @@ class UnknownServerMessage(Exception):
     """Exception indicating that the received message is unknown."""
 
 
-def handle_control_message(message: Message) -> Tuple[Optional[Message], int]:
+def handle_control_message(message: Message) -> tuple[Optional[Message], int]:
     """Handle control part of the incoming message.
 
     Parameters
@@ -81,7 +81,7 @@ def handle_control_message(message: Message) -> Tuple[Optional[Message], int]:
         reason = cast(int, disconnect_msg.disconnect_res.reason)
         recordset = RecordSet()
         recordset.configs_records["config"] = ConfigsRecord({"reason": reason})
-        out_message = message.create_reply(recordset, ttl="")
+        out_message = message.create_reply(recordset)
         # Return TaskRes and sleep duration
         return out_message, sleep_duration
 
@@ -90,10 +90,10 @@ def handle_control_message(message: Message) -> Tuple[Optional[Message], int]:
 
 
 def handle_legacy_message_from_msgtype(
-    client_fn: ClientFn, message: Message, context: Context
+    client_fn: ClientFnExt, message: Message, context: Context
 ) -> Message:
     """Handle legacy message in the inner most mod."""
-    client = client_fn(str(message.metadata.partition_id))
+    client = client_fn(context)
 
     # Check if NumPyClient is returend
     if isinstance(client, NumPyClient):
@@ -105,8 +105,6 @@ def handle_legacy_message_from_msgtype(
             "Please use `NumPyClient.to_client()` method to convert it to `Client`.",
         )
 
-    client.set_context(context)
-
     message_type = message.metadata.message_type
 
     # Handle GetPropertiesIns
@@ -143,12 +141,12 @@ def handle_legacy_message_from_msgtype(
         raise ValueError(f"Invalid message type: {message_type}")
 
     # Return Message
-    return message.create_reply(out_recordset, ttl="")
+    return message.create_reply(out_recordset)
 
 
 def _reconnect(
     reconnect_msg: ServerMessage.ReconnectIns,
-) -> Tuple[ClientMessage, int]:
+) -> tuple[ClientMessage, int]:
     # Determine the reason for sending DisconnectRes message
     reason = Reason.ACK
     sleep_duration = None
@@ -172,6 +170,7 @@ def validate_out_message(out_message: Message, in_message_metadata: Metadata) ->
         and out_meta.reply_to_message == in_meta.message_id
         and out_meta.group_id == in_meta.group_id
         and out_meta.message_type == in_meta.message_type
+        and out_meta.created_at > in_meta.created_at
     ):
         return True
     return False

flwr/client/mod/__init__.py

@@ -1,4 +1,4 @@
-# Copyright 2023 Flower Labs GmbH. All Rights Reserved.
+# Copyright 2024 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.
@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ==============================================================================
-"""Mods."""
+"""Flower Built-in Mods."""
 
 
 from .centraldp_mods import adaptiveclipping_mod, fixedclipping_mod
@@ -22,12 +22,12 @@ from .secure_aggregation import secagg_mod, secaggplus_mod
 from .utils import make_ffn
 
 __all__ = [
+    "LocalDpMod",
     "adaptiveclipping_mod",
     "fixedclipping_mod",
-    "LocalDpMod",
     "make_ffn",
-    "secagg_mod",
-    "secaggplus_mod",
     "message_size_mod",
     "parameters_size_mod",
+    "secagg_mod",
+    "secaggplus_mod",
 ]

flwr/client/mod/centraldp_mods.py

@@ -82,7 +82,9 @@ def fixedclipping_mod(
         clipping_norm,
     )
 
-    log(INFO, "fixedclipping_mod: parameters are clipped by value: %s.", clipping_norm)
+    log(
+        INFO, "fixedclipping_mod: parameters are clipped by value: %.4f.", clipping_norm
+    )
 
     fit_res.parameters = ndarrays_to_parameters(client_to_server_params)
     out_msg.content = compat.fitres_to_recordset(fit_res, keep_input=True)
@@ -146,7 +148,7 @@ def adaptiveclipping_mod(
     )
     log(
         INFO,
-        "adaptiveclipping_mod: parameters are clipped by value: %s.",
+        "adaptiveclipping_mod: parameters are clipped by value: %.4f.",
         clipping_norm,
     )
 

flwr/client/mod/comms_mods.py

@@ -14,6 +14,7 @@
 # ==============================================================================
 """Mods that report statistics about message communication."""
 
+
 from logging import INFO
 
 import numpy as np
@@ -29,7 +30,7 @@ def message_size_mod(
 ) -> Message:
     """Message size mod.
 
-    This mod logs the size in Bytes of the message being transmited.
+    This mod logs the size in bytes of the message being transmited.
     """
     message_size_in_bytes = 0
 
@@ -42,7 +43,7 @@ def message_size_mod(
     for m_record in msg.content.metrics_records.values():
         message_size_in_bytes += m_record.count_bytes()
 
-    log(INFO, "Message size: %i Bytes", message_size_in_bytes)
+    log(INFO, "Message size: %i bytes", message_size_in_bytes)
 
     return call_next(msg, ctxt)
 
@@ -53,7 +54,7 @@ def parameters_size_mod(
     """Parameters size mod.
 
     This mod logs the number of parameters transmitted in the message as well as their
-    size in Bytes.
+    size in bytes.
     """
     model_size_stats = {}
     parameters_size_in_bytes = 0
@@ -74,6 +75,6 @@ def parameters_size_mod(
     if model_size_stats:
         log(INFO, model_size_stats)
 
-    log(INFO, "Total parameters transmited: %i Bytes", parameters_size_in_bytes)
+    log(INFO, "Total parameters transmitted: %i bytes", parameters_size_in_bytes)
 
     return call_next(msg, ctxt)

flwr/client/mod/localdp_mod.py

@@ -128,20 +128,25 @@ class LocalDpMod:
             self.clipping_norm,
         )
         log(
-            INFO, "LocalDpMod: parameters are clipped by value: %s.", self.clipping_norm
+            INFO,
+            "LocalDpMod: parameters are clipped by value: %.4f.",
+            self.clipping_norm,
         )
 
         fit_res.parameters = ndarrays_to_parameters(client_to_server_params)
 
         # Add noise to model params
-        add_localdp_gaussian_noise_to_params(
+        fit_res.parameters = add_localdp_gaussian_noise_to_params(
             fit_res.parameters, self.sensitivity, self.epsilon, self.delta
         )
+
+        noise_value_sd = (
+            self.sensitivity * np.sqrt(2 * np.log(1.25 / self.delta)) / self.epsilon
+        )
         log(
             INFO,
-            "LocalDpMod: local DP noise with "
-            "standard deviation: %s added to parameters.",
-            self.sensitivity * np.sqrt(2 * np.log(1.25 / self.delta)) / self.epsilon,
+            "LocalDpMod: local DP noise with %.4f stedv added to parameters",
+            noise_value_sd,
         )
 
         out_msg.content = compat.fitres_to_recordset(fit_res, keep_input=True)

flwr/client/mod/secure_aggregation/__init__.py

@@ -1,4 +1,4 @@
-# Copyright 2023 Flower Labs GmbH. All Rights Reserved.
+# Copyright 2024 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.

flwr/client/mod/secure_aggregation/secaggplus_mod.py

@@ -18,7 +18,7 @@
 import os
 from dataclasses import dataclass, field
 from logging import DEBUG, WARNING
-from typing import Any, Dict, List, Tuple, cast
+from typing import Any, cast
 
 from flwr.client.typing import ClientAppCallable
 from flwr.common import (
@@ -91,11 +91,11 @@ class SecAggPlusState:
     # Random seed for generating the private mask
     rd_seed: bytes = b""
 
-    rd_seed_share_dict: Dict[int, bytes] = field(default_factory=dict)
-    sk1_share_dict: Dict[int, bytes] = field(default_factory=dict)
+    rd_seed_share_dict: dict[int, bytes] = field(default_factory=dict)
+    sk1_share_dict: dict[int, bytes] = field(default_factory=dict)
     # The dict of the shared secrets from sk2
-    ss2_dict: Dict[int, bytes] = field(default_factory=dict)
-    public_keys_dict: Dict[int, Tuple[bytes, bytes]] = field(default_factory=dict)
+    ss2_dict: dict[int, bytes] = field(default_factory=dict)
+    public_keys_dict: dict[int, tuple[bytes, bytes]] = field(default_factory=dict)
 
     def __init__(self, **kwargs: ConfigsRecordValues) -> None:
         for k, v in kwargs.items():
@@ -104,8 +104,8 @@ class SecAggPlusState:
             new_v: Any = v
             if k.endswith(":K"):
                 k = k[:-2]
-                keys = cast(List[int], v)
-                values = cast(List[bytes], kwargs[f"{k}:V"])
+                keys = cast(list[int], v)
+                values = cast(list[bytes], kwargs[f"{k}:V"])
                 if len(values) > len(keys):
                     updated_values = [
                         tuple(values[i : i + 2]) for i in range(0, len(values), 2)
@@ -115,17 +115,17 @@ class SecAggPlusState:
                     new_v = dict(zip(keys, values))
             self.__setattr__(k, new_v)
 
-    def to_dict(self) -> Dict[str, ConfigsRecordValues]:
+    def to_dict(self) -> dict[str, ConfigsRecordValues]:
         """Convert the state to a dictionary."""
         ret = vars(self)
         for k in list(ret.keys()):
             if isinstance(ret[k], dict):
                 # Replace dict with two lists
-                v = cast(Dict[str, Any], ret.pop(k))
+                v = cast(dict[str, Any], ret.pop(k))
                 ret[f"{k}:K"] = list(v.keys())
                 if k == "public_keys_dict":
-                    v_list: List[bytes] = []
-                    for b1_b2 in cast(List[Tuple[bytes, bytes]], v.values()):
+                    v_list: list[bytes] = []
+                    for b1_b2 in cast(list[tuple[bytes, bytes]], v.values()):
                         v_list.extend(b1_b2)
                     ret[f"{k}:V"] = v_list
                 else:
@@ -187,7 +187,7 @@ def secaggplus_mod(
 
     # Return message
     out_content.configs_records[RECORD_KEY_CONFIGS] = ConfigsRecord(res, False)
-    return msg.create_reply(out_content, ttl="")
+    return msg.create_reply(out_content)
 
 
 def check_stage(current_stage: str, configs: ConfigsRecord) -> None:
@@ -276,7 +276,7 @@ def check_configs(stage: str, configs: ConfigsRecord) -> None:
                 )
             if not isinstance(configs[key], list) or any(
                 elm
-                for elm in cast(List[Any], configs[key])
+                for elm in cast(list[Any], configs[key])
                 # pylint: disable-next=unidiomatic-typecheck
                 if type(elm) is not expected_type
             ):
@@ -299,7 +299,7 @@ def check_configs(stage: str, configs: ConfigsRecord) -> None:
                 )
             if not isinstance(configs[key], list) or any(
                 elm
-                for elm in cast(List[Any], configs[key])
+                for elm in cast(list[Any], configs[key])
                 # pylint: disable-next=unidiomatic-typecheck
                 if type(elm) is not expected_type
             ):
@@ -314,7 +314,7 @@ def check_configs(stage: str, configs: ConfigsRecord) -> None:
 
 def _setup(
     state: SecAggPlusState, configs: ConfigsRecord
-) -> Dict[str, ConfigsRecordValues]:
+) -> dict[str, ConfigsRecordValues]:
     # Assigning parameter values to object fields
     sec_agg_param_dict = configs
     state.sample_num = cast(int, sec_agg_param_dict[Key.SAMPLE_NUMBER])
@@ -350,8 +350,8 @@ def _setup(
 # pylint: disable-next=too-many-locals
 def _share_keys(
     state: SecAggPlusState, configs: ConfigsRecord
-) -> Dict[str, ConfigsRecordValues]:
-    named_bytes_tuples = cast(Dict[str, Tuple[bytes, bytes]], configs)
+) -> dict[str, ConfigsRecordValues]:
+    named_bytes_tuples = cast(dict[str, tuple[bytes, bytes]], configs)
     key_dict = {int(sid): (pk1, pk2) for sid, (pk1, pk2) in named_bytes_tuples.items()}
     log(DEBUG, "Node %d: starting stage 1...", state.nid)
     state.public_keys_dict = key_dict
@@ -361,7 +361,7 @@ def _share_keys(
         raise ValueError("Available neighbours number smaller than threshold")
 
     # Check if all public keys are unique
-    pk_list: List[bytes] = []
+    pk_list: list[bytes] = []
     for pk1, pk2 in state.public_keys_dict.values():
         pk_list.append(pk1)
         pk_list.append(pk2)
@@ -415,11 +415,11 @@ def _collect_masked_vectors(
     configs: ConfigsRecord,
     num_examples: int,
     updated_parameters: Parameters,
-) -> Dict[str, ConfigsRecordValues]:
+) -> dict[str, ConfigsRecordValues]:
     log(DEBUG, "Node %d: starting stage 2...", state.nid)
-    available_clients: List[int] = []
-    ciphertexts = cast(List[bytes], configs[Key.CIPHERTEXT_LIST])
-    srcs = cast(List[int], configs[Key.SOURCE_LIST])
+    available_clients: list[int] = []
+    ciphertexts = cast(list[bytes], configs[Key.CIPHERTEXT_LIST])
+    srcs = cast(list[int], configs[Key.SOURCE_LIST])
     if len(ciphertexts) + 1 < state.threshold:
         raise ValueError("Not enough available neighbour clients.")
 
@@ -467,7 +467,7 @@ def _collect_masked_vectors(
 
     quantized_parameters = factor_combine(q_ratio, quantized_parameters)
 
-    dimensions_list: List[Tuple[int, ...]] = [a.shape for a in quantized_parameters]
+    dimensions_list: list[tuple[int, ...]] = [a.shape for a in quantized_parameters]
 
     # Add private mask
     private_mask = pseudo_rand_gen(state.rd_seed, state.mod_range, dimensions_list)
@@ -499,11 +499,11 @@ def _collect_masked_vectors(
 
 def _unmask(
     state: SecAggPlusState, configs: ConfigsRecord
-) -> Dict[str, ConfigsRecordValues]:
+) -> dict[str, ConfigsRecordValues]:
     log(DEBUG, "Node %d: starting stage 3...", state.nid)
 
-    active_nids = cast(List[int], configs[Key.ACTIVE_NODE_ID_LIST])
-    dead_nids = cast(List[int], configs[Key.DEAD_NODE_ID_LIST])
+    active_nids = cast(list[int], configs[Key.ACTIVE_NODE_ID_LIST])
+    dead_nids = cast(list[int], configs[Key.DEAD_NODE_ID_LIST])
     # Send private mask seed share for every avaliable client (including itself)
     # Send first private key share for building pairwise mask for every dropped client
     if len(active_nids) < state.threshold:

flwr/client/mod/utils.py

@@ -1,4 +1,4 @@
-# Copyright 2023 Flower Labs GmbH. All Rights Reserved.
+# Copyright 2024 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.
@@ -15,13 +15,11 @@
 """Utility functions for mods."""
 
 
-from typing import List
-
 from flwr.client.typing import ClientAppCallable, Mod
 from flwr.common import Context, Message
 
 
-def make_ffn(ffn: ClientAppCallable, mods: List[Mod]) -> ClientAppCallable:
+def make_ffn(ffn: ClientAppCallable, mods: list[Mod]) -> ClientAppCallable:
     """."""
 
     def wrap_ffn(_ffn: ClientAppCallable, _mod: Mod) -> ClientAppCallable:

flwr/client/nodestate/__init__.py

@@ -0,0 +1,26 @@
+# Copyright 2024 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.
+# ==============================================================================
+"""Flower NodeState."""
+
+
+from .in_memory_nodestate import InMemoryNodeState as InMemoryNodeState
+from .nodestate import NodeState as NodeState
+from .nodestate_factory import NodeStateFactory as NodeStateFactory
+
+__all__ = [
+    "InMemoryNodeState",
+    "NodeState",
+    "NodeStateFactory",
+]

flwr/client/nodestate/in_memory_nodestate.py

@@ -0,0 +1,38 @@
+# Copyright 2024 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.
+# ==============================================================================
+"""In-memory NodeState implementation."""
+
+
+from typing import Optional
+
+from flwr.client.nodestate.nodestate import NodeState
+
+
+class InMemoryNodeState(NodeState):
+    """In-memory NodeState implementation."""
+
+    def __init__(self) -> None:
+        # Store node_id
+        self.node_id: Optional[int] = None
+
+    def set_node_id(self, node_id: Optional[int]) -> None:
+        """Set the node ID."""
+        self.node_id = node_id
+
+    def get_node_id(self) -> int:
+        """Get the node ID."""
+        if self.node_id is None:
+            raise ValueError("Node ID not set")
+        return self.node_id

flwr/client/nodestate/nodestate.py

@@ -0,0 +1,31 @@
+# Copyright 2024 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 base class NodeState."""
+
+
+import abc
+from typing import Optional
+
+
+class NodeState(abc.ABC):
+    """Abstract NodeState."""
+
+    @abc.abstractmethod
+    def set_node_id(self, node_id: Optional[int]) -> None:
+        """Set the node ID."""
+
+    @abc.abstractmethod
+    def get_node_id(self) -> int:
+        """Get the node ID."""

flwr/client/nodestate/nodestate_factory.py

@@ -0,0 +1,38 @@
+# Copyright 2024 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.
+# ==============================================================================
+"""Factory class that creates NodeState instances."""
+
+
+import threading
+from typing import Optional
+
+from .in_memory_nodestate import InMemoryNodeState
+from .nodestate import NodeState
+
+
+class NodeStateFactory:
+    """Factory class that creates NodeState instances."""
+
+    def __init__(self) -> None:
+        self.state_instance: Optional[NodeState] = None
+        self.lock = threading.RLock()
+
+    def state(self) -> NodeState:
+        """Return a State instance and create it, if necessary."""
+        # Lock access to NodeStateFactory to prevent returning different instances
+        with self.lock:
+            if self.state_instance is None:
+                self.state_instance = InMemoryNodeState()
+            return self.state_instance