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

flwr/client/__init__.py

@@ -15,10 +15,11 @@
 """Flower client."""
 
 
+from flwr.clientapp.client_app import ClientApp
+
 from ..compat.client.app import start_client as start_client  # Deprecated
 from ..compat.client.app import start_numpy_client as start_numpy_client  # Deprecated
 from .client import Client as Client
-from .client_app import ClientApp as ClientApp
 from .numpy_client import NumPyClient as NumPyClient
 from .typing import ClientFn as ClientFn
 from .typing import ClientFnExt as ClientFnExt

flwr/client/dpfedavg_numpy_client.py

@@ -120,7 +120,10 @@ class DPFedAvgNumPyClient(NumPyClient):
         updated_params, num_examples, metrics = self.client.fit(parameters, config)
 
         # Update = updated model - original model
-        update = [np.subtract(x, y) for (x, y) in zip(updated_params, original_params)]
+        update = [
+            np.subtract(x, y)
+            for (x, y) in zip(updated_params, original_params, strict=True)
+        ]
 
         if "dpfedavg_clip_norm" not in config:
             raise KeyError("Clipping threshold not supplied by the server.")

flwr/client/grpc_adapter_client/connection.py

@@ -15,10 +15,9 @@
 """Contextmanager for a GrpcAdapter channel to the Flower server."""
 
 
-from collections.abc import Iterator
+from collections.abc import Callable, Iterator
 from contextlib import contextmanager
 from logging import ERROR
-from typing import Callable, Optional, Union
 
 from cryptography.hazmat.primitives.asymmetric import ec
 
@@ -38,16 +37,15 @@ def grpc_adapter(  # pylint: disable=R0913,too-many-positional-arguments
     insecure: bool,
     retry_invoker: RetryInvoker,
     max_message_length: int = GRPC_MAX_MESSAGE_LENGTH,  # pylint: disable=W0613
-    root_certificates: Optional[Union[bytes, str]] = None,
-    authentication_keys: Optional[  # pylint: disable=unused-argument
-        tuple[ec.EllipticCurvePrivateKey, ec.EllipticCurvePublicKey]
-    ] = None,
+    root_certificates: bytes | str | None = None,
+    authentication_keys: (
+        tuple[ec.EllipticCurvePrivateKey, ec.EllipticCurvePublicKey] | None
+    ) = None,
 ) -> Iterator[
     tuple[
-        Callable[[], Optional[tuple[Message, ObjectTree]]],
+        int,
+        Callable[[], tuple[Message, ObjectTree] | None],
         Callable[[Message, ObjectTree], set[str]],
-        Callable[[], Optional[int]],
-        Callable[[], None],
         Callable[[int], Run],
         Callable[[str, int], Fab],
         Callable[[int, str], bytes],
@@ -77,22 +75,21 @@ def grpc_adapter(  # pylint: disable=R0913,too-many-positional-arguments
         connection using the certificates will be established to an SSL-enabled
         Flower server. Bytes won't work for the REST API.
     authentication_keys : Optional[Tuple[PrivateKey, PublicKey]] (default: None)
-        Client authentication is not supported for this transport type.
+        SuperNode authentication is not supported for this transport type.
 
     Returns
     -------
+    node_id : int
     receive : Callable[[], Optional[tuple[Message, ObjectTree]]]
     send : Callable[[Message, ObjectTree], set[str]]
-    create_node : Optional[Callable]
-    delete_node : Optional[Callable]
-    get_run : Optional[Callable]
-    get_fab : Optional[Callable]
+    get_run : Callable[[int], Run]
+    get_fab : Callable[[str, int], Fab]
     pull_object : Callable[[str], bytes]
     push_object : Callable[[str, bytes], None]
     confirm_message_received : Callable[[str], None]
     """
     if authentication_keys is not None:
-        log(ERROR, "Client authentication is not supported for this transport type.")
+        log(ERROR, "SuperNode authentication is not supported for this transport type.")
     with grpc_request_response(
         server_address=server_address,
         insecure=insecure,

flwr/client/grpc_rere_client/connection.py

@@ -15,11 +15,10 @@
 """Contextmanager for a gRPC request-response channel to the Flower server."""
 
 
-from collections.abc import Iterator, Sequence
+from collections.abc import Callable, Iterator, Sequence
 from contextlib import contextmanager
 from logging import ERROR
 from pathlib import Path
-from typing import Callable, Optional, Union, cast
 
 import grpc
 from cryptography.hazmat.primitives.asymmetric import ec
@@ -27,7 +26,6 @@ from cryptography.hazmat.primitives.asymmetric import ec
 from flwr.common import GRPC_MAX_MESSAGE_LENGTH
 from flwr.common.constant import HEARTBEAT_CALL_TIMEOUT, HEARTBEAT_DEFAULT_INTERVAL
 from flwr.common.grpc import create_channel, on_channel_state_change
-from flwr.common.heartbeat import HeartbeatSender
 from flwr.common.inflatable_protobuf_utils import (
     make_confirm_message_received_fn_protobuf,
     make_pull_object_fn_protobuf,
@@ -36,19 +34,24 @@ from flwr.common.inflatable_protobuf_utils import (
 from flwr.common.logger import log
 from flwr.common.message import Message, remove_content_from_message
 from flwr.common.retry_invoker import RetryInvoker, _wrap_stub
-from flwr.common.secure_aggregation.crypto.symmetric_encryption import (
-    generate_key_pairs,
+from flwr.common.serde import (
+    fab_from_proto,
+    message_from_proto,
+    message_to_proto,
+    run_from_proto,
 )
-from flwr.common.serde import message_from_proto, message_to_proto, run_from_proto
 from flwr.common.typing import Fab, Run
 from flwr.proto.fab_pb2 import GetFabRequest, GetFabResponse  # pylint: disable=E0611
 from flwr.proto.fleet_pb2 import (  # pylint: disable=E0611
-    CreateNodeRequest,
-    DeleteNodeRequest,
+    ActivateNodeRequest,
+    ActivateNodeResponse,
+    DeactivateNodeRequest,
     PullMessagesRequest,
     PullMessagesResponse,
     PushMessagesRequest,
     PushMessagesResponse,
+    RegisterNodeFleetRequest,
+    UnregisterNodeFleetRequest,
 )
 from flwr.proto.fleet_pb2_grpc import FleetStub  # pylint: disable=E0611
 from flwr.proto.heartbeat_pb2 import (  # pylint: disable=E0611
@@ -58,9 +61,11 @@ from flwr.proto.heartbeat_pb2 import (  # pylint: disable=E0611
 from flwr.proto.message_pb2 import ObjectTree  # pylint: disable=E0611
 from flwr.proto.node_pb2 import Node  # pylint: disable=E0611
 from flwr.proto.run_pb2 import GetRunRequest, GetRunResponse  # pylint: disable=E0611
+from flwr.supercore.heartbeat import HeartbeatSender
+from flwr.supercore.primitives.asymmetric import generate_key_pairs, public_key_to_bytes
 
-from .client_interceptor import AuthenticateClientInterceptor
 from .grpc_adapter import GrpcAdapter
+from .node_auth_client_interceptor import NodeAuthClientInterceptor
 
 
 @contextmanager
@@ -69,17 +74,16 @@ def grpc_request_response(  # pylint: disable=R0913,R0914,R0915,R0917
     insecure: bool,
     retry_invoker: RetryInvoker,
     max_message_length: int = GRPC_MAX_MESSAGE_LENGTH,  # pylint: disable=W0613
-    root_certificates: Optional[Union[bytes, str]] = None,
-    authentication_keys: Optional[
-        tuple[ec.EllipticCurvePrivateKey, ec.EllipticCurvePublicKey]
-    ] = None,
-    adapter_cls: Optional[Union[type[FleetStub], type[GrpcAdapter]]] = None,
+    root_certificates: bytes | str | None = None,
+    authentication_keys: (
+        tuple[ec.EllipticCurvePrivateKey, ec.EllipticCurvePublicKey] | None
+    ) = None,
+    adapter_cls: type[FleetStub] | type[GrpcAdapter] | None = None,
 ) -> Iterator[
     tuple[
-        Callable[[], Optional[tuple[Message, ObjectTree]]],
+        int,
+        Callable[[], tuple[Message, ObjectTree] | None],
         Callable[[Message, ObjectTree], set[str]],
-        Callable[[], Optional[int]],
-        Callable[[], None],
         Callable[[int], Run],
         Callable[[str, int], Fab],
         Callable[[int, str], bytes],
@@ -122,11 +126,11 @@ def grpc_request_response(  # pylint: disable=R0913,R0914,R0915,R0917
 
     Returns
     -------
-    receive : Callable
-    send : Callable
-    create_node : Optional[Callable]
-    delete_node : Optional[Callable]
-    get_run : Optional[Callable]
+    node_id : int
+    receive : Callable[[], Optional[tuple[Message, ObjectTree]]]
+    send : Callable[[Message, ObjectTree], set[str]]
+    get_run : Callable[[int], Run]
+    get_fab : Callable[[str, int], Fab]
     pull_object : Callable[[str], bytes]
     push_object : Callable[[str, bytes], None]
     confirm_message_received : Callable[[str], None]
@@ -135,13 +139,16 @@ def grpc_request_response(  # pylint: disable=R0913,R0914,R0915,R0917
         root_certificates = Path(root_certificates).read_bytes()
 
     # Automatic node auth: generate keys if user didn't provide any
+    self_registered = False
     if authentication_keys is None:
+        self_registered = True
         authentication_keys = generate_key_pairs()
 
     # Always configure auth interceptor, with either user-provided or generated keys
     interceptors: Sequence[grpc.UnaryUnaryClientInterceptor] = [
-        AuthenticateClientInterceptor(*authentication_keys),
+        NodeAuthClientInterceptor(*authentication_keys),
     ]
+    node_pk = public_key_to_bytes(authentication_keys[1])
     channel = create_channel(
         server_address=server_address,
         insecure=insecure,
@@ -155,12 +162,12 @@ def grpc_request_response(  # pylint: disable=R0913,R0914,R0915,R0917
     if adapter_cls is None:
         adapter_cls = FleetStub
     stub = adapter_cls(channel)
-    node: Optional[Node] = None
+    node: Node | None = None
 
     # Wrap stub
     _wrap_stub(stub, retry_invoker)
     ###########################################################################
-    # send_node_heartbeat/create_node/delete_node/receive/send/get_run functions
+    # SuperNode functions
     ###########################################################################
 
     def send_node_heartbeat() -> bool:
@@ -197,22 +204,26 @@ def grpc_request_response(  # pylint: disable=R0913,R0914,R0915,R0917
 
     heartbeat_sender = HeartbeatSender(send_node_heartbeat)
 
-    def create_node() -> Optional[int]:
-        """Set create_node."""
-        # Call FleetAPI
-        create_node_request = CreateNodeRequest(
-            heartbeat_interval=HEARTBEAT_DEFAULT_INTERVAL
+    def register_node() -> None:
+        """Register node with SuperLink."""
+        stub.RegisterNode(RegisterNodeFleetRequest(public_key=node_pk))
+
+    def activate_node() -> int:
+        """Activate node and start heartbeat."""
+        req = ActivateNodeRequest(
+            public_key=node_pk,
+            heartbeat_interval=HEARTBEAT_DEFAULT_INTERVAL,
         )
-        create_node_response = stub.CreateNode(request=create_node_request)
+        res: ActivateNodeResponse = stub.ActivateNode(req)
 
         # Remember the node and start the heartbeat sender
         nonlocal node
-        node = cast(Node, create_node_response.node)
+        node = Node(node_id=res.node_id)
         heartbeat_sender.start()
         return node.node_id
 
-    def delete_node() -> None:
-        """Set delete_node."""
+    def deactivate_node() -> None:
+        """Deactivate node and stop heartbeat."""
         # Get Node
         nonlocal node
         if node is None:
@@ -223,13 +234,25 @@ def grpc_request_response(  # pylint: disable=R0913,R0914,R0915,R0917
         heartbeat_sender.stop()
 
         # Call FleetAPI
-        delete_node_request = DeleteNodeRequest(node=node)
-        stub.DeleteNode(request=delete_node_request)
+        req = DeactivateNodeRequest(node_id=node.node_id)
+        stub.DeactivateNode(req)
+
+    def unregister_node() -> None:
+        """Unregister node from SuperLink."""
+        # Get Node
+        nonlocal node
+        if node is None:
+            log(ERROR, "Node instance missing")
+            return
+
+        # Call FleetAPI
+        req = UnregisterNodeFleetRequest(node_id=node.node_id)
+        stub.UnregisterNode(req)
 
         # Cleanup
         node = None
 
-    def receive() -> Optional[tuple[Message, ObjectTree]]:
+    def receive() -> tuple[Message, ObjectTree] | None:
         """Pull a message with its ObjectTree from SuperLink."""
         # Get Node
         if node is None:
@@ -289,7 +312,7 @@ def grpc_request_response(  # pylint: disable=R0913,R0914,R0915,R0917
         get_fab_request = GetFabRequest(node=node, hash_str=fab_hash, run_id=run_id)
         get_fab_response: GetFabResponse = stub.GetFab(request=get_fab_request)
 
-        return Fab(get_fab_response.fab.hash_str, get_fab_response.fab.content)
+        return fab_from_proto(get_fab_response.fab)
 
     def pull_object(run_id: int, object_id: str) -> bytes:
         """Pull the object from the SuperLink."""
@@ -331,12 +354,14 @@ def grpc_request_response(  # pylint: disable=R0913,R0914,R0915,R0917
         fn(object_id)
 
     try:
+        if self_registered:
+            register_node()
+        node_id = activate_node()
         # Yield methods
         yield (
+            node_id,
             receive,
             send,
-            create_node,
-            delete_node,
             get_run,
             get_fab,
             pull_object,
@@ -351,7 +376,9 @@ def grpc_request_response(  # pylint: disable=R0913,R0914,R0915,R0917
             if node is not None:
                 # Disable retrying
                 retry_invoker.max_tries = 1
-                delete_node()
+                deactivate_node()
+                if self_registered:
+                    unregister_node()
         except grpc.RpcError:
             pass
         channel.close()

flwr/client/grpc_rere_client/grpc_adapter.py

@@ -15,7 +15,8 @@
 """GrpcAdapter implementation."""
 
 
-import sys
+import signal
+import time
 from logging import DEBUG
 from typing import Any, TypeVar, cast
 
@@ -34,14 +35,18 @@ from flwr.common.constant import (
 from flwr.common.version import package_name, package_version
 from flwr.proto.fab_pb2 import GetFabRequest, GetFabResponse  # pylint: disable=E0611
 from flwr.proto.fleet_pb2 import (  # pylint: disable=E0611
-    CreateNodeRequest,
-    CreateNodeResponse,
-    DeleteNodeRequest,
-    DeleteNodeResponse,
+    ActivateNodeRequest,
+    ActivateNodeResponse,
+    DeactivateNodeRequest,
+    DeactivateNodeResponse,
     PullMessagesRequest,
     PullMessagesResponse,
     PushMessagesRequest,
     PushMessagesResponse,
+    RegisterNodeFleetRequest,
+    RegisterNodeFleetResponse,
+    UnregisterNodeFleetRequest,
+    UnregisterNodeFleetResponse,
 )
 from flwr.proto.grpcadapter_pb2 import MessageContainer  # pylint: disable=E0611
 from flwr.proto.grpcadapter_pb2_grpc import GrpcAdapterStub
@@ -58,6 +63,7 @@ from flwr.proto.message_pb2 import (  # pylint: disable=E0611
     PushObjectResponse,
 )
 from flwr.proto.run_pb2 import GetRunRequest, GetRunResponse  # pylint: disable=E0611
+from flwr.supercore.constant import FORCE_EXIT_TIMEOUT_SECONDS
 
 T = TypeVar("T", bound=GrpcMessage)
 
@@ -104,7 +110,9 @@ class GrpcAdapter:
                 DEBUG,
                 'Received shutdown signal: exit flag is set to ``"true"``. Exiting...',
             )
-            sys.exit(0)
+            signal.raise_signal(signal.SIGTERM)
+            # Give some time to handle the signal
+            time.sleep(FORCE_EXIT_TIMEOUT_SECONDS + 1)
 
         # Check the grpc_message_name of the response
         if container_res.grpc_message_name != response_type.__qualname__:
@@ -118,17 +126,29 @@ class GrpcAdapter:
         response.ParseFromString(container_res.grpc_message_content)
         return response
 
-    def CreateNode(  # pylint: disable=C0103
-        self, request: CreateNodeRequest, **kwargs: Any
-    ) -> CreateNodeResponse:
+    def RegisterNode(  # pylint: disable=C0103
+        self, request: RegisterNodeFleetRequest, **kwargs: Any
+    ) -> RegisterNodeFleetResponse:
         """."""
-        return self._send_and_receive(request, CreateNodeResponse, **kwargs)
+        return self._send_and_receive(request, RegisterNodeFleetResponse, **kwargs)
 
-    def DeleteNode(  # pylint: disable=C0103
-        self, request: DeleteNodeRequest, **kwargs: Any
-    ) -> DeleteNodeResponse:
+    def ActivateNode(  # pylint: disable=C0103
+        self, request: ActivateNodeRequest, **kwargs: Any
+    ) -> ActivateNodeResponse:
         """."""
-        return self._send_and_receive(request, DeleteNodeResponse, **kwargs)
+        return self._send_and_receive(request, ActivateNodeResponse, **kwargs)
+
+    def DeactivateNode(  # pylint: disable=C0103
+        self, request: DeactivateNodeRequest, **kwargs: Any
+    ) -> DeactivateNodeResponse:
+        """."""
+        return self._send_and_receive(request, DeactivateNodeResponse, **kwargs)
+
+    def UnregisterNode(  # pylint: disable=C0103
+        self, request: UnregisterNodeFleetRequest, **kwargs: Any
+    ) -> UnregisterNodeFleetResponse:
+        """."""
+        return self._send_and_receive(request, UnregisterNodeFleetResponse, **kwargs)
 
     def SendNodeHeartbeat(  # pylint: disable=C0103
         self, request: SendNodeHeartbeatRequest, **kwargs: Any

flwr/client/grpc_rere_client/{client_interceptor.py → node_auth_client_interceptor.py}

@@ -15,7 +15,8 @@
 """Flower client interceptor."""
 
 
-from typing import Any, Callable
+from collections.abc import Callable
+from typing import Any
 
 import grpc
 from cryptography.hazmat.primitives.asymmetric import ec
@@ -23,14 +24,11 @@ from google.protobuf.message import Message as GrpcMessage
 
 from flwr.common import now
 from flwr.common.constant import PUBLIC_KEY_HEADER, SIGNATURE_HEADER, TIMESTAMP_HEADER
-from flwr.common.secure_aggregation.crypto.symmetric_encryption import (
-    public_key_to_bytes,
-    sign_message,
-)
+from flwr.supercore.primitives.asymmetric import public_key_to_bytes, sign_message
 
 
-class AuthenticateClientInterceptor(grpc.UnaryUnaryClientInterceptor):  # type: ignore
-    """Client interceptor for client authentication."""
+class NodeAuthClientInterceptor(grpc.UnaryUnaryClientInterceptor):  # type: ignore
+    """Client interceptor for node authentication."""
 
     def __init__(
         self,

flwr/client/message_handler/message_handler.py

@@ -16,7 +16,7 @@
 
 
 from logging import WARN
-from typing import Optional, cast
+from typing import cast
 
 from flwr.client.client import (
     maybe_call_evaluate,
@@ -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[Message | None, int]:
     """Handle control part of the incoming message.
 
     Parameters

flwr/client/mod/secure_aggregation/secaggplus_mod.py

@@ -35,14 +35,9 @@ from flwr.common.constant import MessageType
 from flwr.common.logger import log
 from flwr.common.secure_aggregation.crypto.shamir import create_shares
 from flwr.common.secure_aggregation.crypto.symmetric_encryption import (
-    bytes_to_private_key,
-    bytes_to_public_key,
     decrypt,
     encrypt,
-    generate_key_pairs,
     generate_shared_key,
-    private_key_to_bytes,
-    public_key_to_bytes,
 )
 from flwr.common.secure_aggregation.ndarrays_arithmetic import (
     factor_combine,
@@ -64,6 +59,13 @@ from flwr.common.secure_aggregation.secaggplus_utils import (
     share_keys_plaintext_separate,
 )
 from flwr.common.typing import ConfigRecordValues
+from flwr.supercore.primitives.asymmetric import (
+    bytes_to_private_key,
+    bytes_to_public_key,
+    generate_key_pairs,
+    private_key_to_bytes,
+    public_key_to_bytes,
+)
 
 
 @dataclass
@@ -110,9 +112,9 @@ class SecAggPlusState:
                     updated_values = [
                         tuple(values[i : i + 2]) for i in range(0, len(values), 2)
                     ]
-                    new_v = dict(zip(keys, updated_values))
+                    new_v = dict(zip(keys, updated_values, strict=True))
                 else:
-                    new_v = dict(zip(keys, values))
+                    new_v = dict(zip(keys, values, strict=True))
             self.__setattr__(k, new_v)
 
     def to_dict(self) -> dict[str, ConfigRecordValues]:
@@ -424,7 +426,7 @@ def _collect_masked_vectors(
         raise ValueError("Not enough available neighbour clients.")
 
     # Decrypt ciphertexts, verify their sources, and store shares.
-    for src, ciphertext in zip(srcs, ciphertexts):
+    for src, ciphertext in zip(srcs, ciphertexts, strict=True):
         shared_key = state.ss2_dict[src]
         plaintext = decrypt(shared_key, ciphertext)
         actual_src, dst, rd_seed_share, sk1_share = share_keys_plaintext_separate(

flwr/client/numpy_client.py

@@ -16,7 +16,7 @@
 
 
 from abc import ABC
-from typing import Callable
+from collections.abc import Callable
 
 from flwr.client.client import Client
 from flwr.common import (