flwr-nightly 1.19.0.dev20250609__tar.gz → 1.19.0.dev20250610__tar.gz

{flwr_nightly-1.19.0.dev20250609 → flwr_nightly-1.19.0.dev20250610}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: flwr-nightly
-Version: 1.19.0.dev20250609
+Version: 1.19.0.dev20250610
 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.19.0.dev20250609 → flwr_nightly-1.19.0.dev20250610}/py/flwr/client/grpc_rere_client/connection.py

@@ -32,9 +32,11 @@ from flwr.common.grpc import create_channel, on_channel_state_change
 from flwr.common.heartbeat import HeartbeatSender
 from flwr.common.inflatable import get_all_nested_objects
 from flwr.common.inflatable_grpc_utils import (
-    inflate_object_from_contents,
     make_pull_object_fn_grpc,
     make_push_object_fn_grpc,
+)
+from flwr.common.inflatable_utils import (
+    inflate_object_from_contents,
     pull_objects,
     push_objects,
 )

flwr_nightly-1.19.0.dev20250610/py/flwr/common/inflatable_grpc_utils.py

@@ -0,0 +1,99 @@
+# 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.
+# ==============================================================================
+"""InflatableObject utils."""
+
+
+from typing import Callable
+
+from flwr.proto.message_pb2 import (  # pylint: disable=E0611
+    PullObjectRequest,
+    PullObjectResponse,
+    PushObjectRequest,
+    PushObjectResponse,
+)
+from flwr.proto.node_pb2 import Node  # pylint: disable=E0611
+
+from .inflatable_utils import ObjectIdNotPreregisteredError, ObjectUnavailableError
+
+
+def make_pull_object_fn_grpc(
+    pull_object_grpc: Callable[[PullObjectRequest], PullObjectResponse],
+    node: Node,
+    run_id: int,
+) -> Callable[[str], bytes]:
+    """Create a pull object function that uses gRPC to pull objects.
+
+    Parameters
+    ----------
+    pull_object_grpc : Callable[[PullObjectRequest], PullObjectResponse]
+        The gRPC function to pull objects, e.g., `FleetStub.PullObject`.
+    node : Node
+        The node making the request.
+    run_id : int
+        The run ID for the current operation.
+
+    Returns
+    -------
+    Callable[[str], bytes]
+        A function that takes an object ID and returns the object content as bytes.
+        The function raises `ObjectIdNotPreregisteredError` if the object ID is not
+        pre-registered, or `ObjectUnavailableError` if the object is not yet available.
+    """
+
+    def pull_object_fn(object_id: str) -> bytes:
+        request = PullObjectRequest(node=node, run_id=run_id, object_id=object_id)
+        response: PullObjectResponse = pull_object_grpc(request)
+        if not response.object_found:
+            raise ObjectIdNotPreregisteredError(object_id)
+        if not response.object_available:
+            raise ObjectUnavailableError(object_id)
+        return response.object_content
+
+    return pull_object_fn
+
+
+def make_push_object_fn_grpc(
+    push_object_grpc: Callable[[PushObjectRequest], PushObjectResponse],
+    node: Node,
+    run_id: int,
+) -> Callable[[str, bytes], None]:
+    """Create a push object function that uses gRPC to push objects.
+
+    Parameters
+    ----------
+    push_object_grpc : Callable[[PushObjectRequest], PushObjectResponse]
+        The gRPC function to push objects, e.g., `FleetStub.PushObject`.
+    node : Node
+        The node making the request.
+    run_id : int
+        The run ID for the current operation.
+
+    Returns
+    -------
+    Callable[[str, bytes], None]
+        A function that takes an object ID and its content as bytes, and pushes it
+        to the servicer. The function raises `ObjectIdNotPreregisteredError` if
+        the object ID is not pre-registered.
+    """
+
+    def push_object_fn(object_id: str, object_content: bytes) -> None:
+        request = PushObjectRequest(
+            node=node, run_id=run_id, object_id=object_id, object_content=object_content
+        )
+        response: PushObjectResponse = push_object_grpc(request)
+        if not response.stored:
+            raise ObjectIdNotPreregisteredError(object_id)
+
+    return push_object_fn

flwr_nightly-1.19.0.dev20250609/py/flwr/common/inflatable_grpc_utils.py → flwr_nightly-1.19.0.dev20250610/py/flwr/common/inflatable_utils.py

@@ -12,8 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ==============================================================================
-"""InflatableObject utils."""
-
+"""InflatableObject utilities."""
 
 import concurrent.futures
 import random
@@ -21,15 +20,9 @@ import threading
 import time
 from typing import Callable, Optional
 
-from flwr.proto.message_pb2 import (  # pylint: disable=E0611
-    PullObjectRequest,
-    PullObjectResponse,
-    PushObjectRequest,
-    PushObjectResponse,
-)
-from flwr.proto.node_pb2 import Node  # pylint: disable=E0611
-
 from .constant import (
+    HEAD_BODY_DIVIDER,
+    HEAD_VALUE_DIVIDER,
     MAX_CONCURRENT_PULLS,
     MAX_CONCURRENT_PUSHES,
     PULL_BACKOFF_CAP,
@@ -37,7 +30,14 @@ from .constant import (
     PULL_MAX_TIME,
     PULL_MAX_TRIES_PER_OBJECT,
 )
-from .inflatable import InflatableObject, get_object_head_values_from_object_content
+from .inflatable import (
+    InflatableObject,
+    UnexpectedObjectContentError,
+    _get_object_head,
+    get_object_head_values_from_object_content,
+    get_object_id,
+    is_valid_sha256_hash,
+)
 from .message import Message
 from .record import Array, ArrayRecord, ConfigRecord, MetricRecord, RecordDict
 
@@ -67,77 +67,6 @@ class ObjectIdNotPreregisteredError(Exception):
         super().__init__(f"Object with ID '{object_id}' could not be found.")
 
 
-def make_pull_object_fn_grpc(
-    pull_object_grpc: Callable[[PullObjectRequest], PullObjectResponse],
-    node: Node,
-    run_id: int,
-) -> Callable[[str], bytes]:
-    """Create a pull object function that uses gRPC to pull objects.
-
-    Parameters
-    ----------
-    pull_object_grpc : Callable[[PullObjectRequest], PullObjectResponse]
-        The gRPC function to pull objects, e.g., `FleetStub.PullObject`.
-    node : Node
-        The node making the request.
-    run_id : int
-        The run ID for the current operation.
-
-    Returns
-    -------
-    Callable[[str], bytes]
-        A function that takes an object ID and returns the object content as bytes.
-        The function raises `ObjectIdNotPreregisteredError` if the object ID is not
-        pre-registered, or `ObjectUnavailableError` if the object is not yet available.
-    """
-
-    def pull_object_fn(object_id: str) -> bytes:
-        request = PullObjectRequest(node=node, run_id=run_id, object_id=object_id)
-        response: PullObjectResponse = pull_object_grpc(request)
-        if not response.object_found:
-            raise ObjectIdNotPreregisteredError(object_id)
-        if not response.object_available:
-            raise ObjectUnavailableError(object_id)
-        return response.object_content
-
-    return pull_object_fn
-
-
-def make_push_object_fn_grpc(
-    push_object_grpc: Callable[[PushObjectRequest], PushObjectResponse],
-    node: Node,
-    run_id: int,
-) -> Callable[[str, bytes], None]:
-    """Create a push object function that uses gRPC to push objects.
-
-    Parameters
-    ----------
-    push_object_grpc : Callable[[PushObjectRequest], PushObjectResponse]
-        The gRPC function to push objects, e.g., `FleetStub.PushObject`.
-    node : Node
-        The node making the request.
-    run_id : int
-        The run ID for the current operation.
-
-    Returns
-    -------
-    Callable[[str, bytes], None]
-        A function that takes an object ID and its content as bytes, and pushes it
-        to the servicer. The function raises `ObjectIdNotPreregisteredError` if
-        the object ID is not pre-registered.
-    """
-
-    def push_object_fn(object_id: str, object_content: bytes) -> None:
-        request = PushObjectRequest(
-            node=node, run_id=run_id, object_id=object_id, object_content=object_content
-        )
-        response: PushObjectResponse = push_object_grpc(request)
-        if not response.stored:
-            raise ObjectIdNotPreregisteredError(object_id)
-
-    return push_object_fn
-
-
 def push_objects(
     objects: dict[str, InflatableObject],
     push_object_fn: Callable[[str, bytes], None],
@@ -360,3 +289,53 @@ def inflate_object_from_contents(
     del object_content  # Free memory after inflation
     objects[object_id] = obj
     return obj
+
+
+def validate_object_content(content: bytes) -> None:
+    """Validate the deflated content of an InflatableObject."""
+    try:
+        # Check if there is a head-body divider
+        index = content.find(HEAD_BODY_DIVIDER)
+        if index == -1:
+            raise ValueError(
+                "Unexpected format for object content. Head and body "
+                "could not be split."
+            )
+
+        head = _get_object_head(content)
+
+        # check if the head has three parts:
+        # <object_type> <children_ids> <object_body_len>
+        head_decoded = head.decode(encoding="utf-8")
+        head_parts = head_decoded.split(HEAD_VALUE_DIVIDER)
+
+        if len(head_parts) != 3:
+            raise ValueError("Unexpected format for object head.")
+
+        obj_type, children_str, body_len = head_parts
+
+        # Check that children IDs are valid IDs
+        children = children_str.split(",")
+        for children_id in children:
+            if children_id and not is_valid_sha256_hash(children_id):
+                raise ValueError(
+                    f"Detected invalid object ID ({children_id}) in children."
+                )
+
+        # Check that object type is recognized
+        if obj_type not in inflatable_class_registry:
+            if obj_type != "CustomDataClass":  # to allow for the class in tests
+                raise ValueError(f"Object of type {obj_type} is not supported.")
+
+        # Check if the body length in the head matches that of the body
+        actual_body_len = len(content) - len(head) - len(HEAD_BODY_DIVIDER)
+        if actual_body_len != int(body_len):
+            raise ValueError(
+                f"Object content length expected {body_len} bytes but got "
+                f"{actual_body_len} bytes."
+            )
+
+    except ValueError as err:
+        raise UnexpectedObjectContentError(
+            object_id=get_object_id(content), reason=str(err)
+        ) from err

{flwr_nightly-1.19.0.dev20250609 → flwr_nightly-1.19.0.dev20250610}/py/flwr/server/grid/grpc_grid.py

@@ -30,9 +30,11 @@ from flwr.common.constant import (
 from flwr.common.grpc import create_channel, on_channel_state_change
 from flwr.common.inflatable import get_all_nested_objects
 from flwr.common.inflatable_grpc_utils import (
-    inflate_object_from_contents,
     make_pull_object_fn_grpc,
     make_push_object_fn_grpc,
+)
+from flwr.common.inflatable_utils import (
+    inflate_object_from_contents,
     pull_objects,
     push_objects,
 )

{flwr_nightly-1.19.0.dev20250609 → flwr_nightly-1.19.0.dev20250610}/py/flwr/server/superlink/fleet/grpc_rere/fleet_servicer.py

@@ -15,12 +15,11 @@
 """Fleet API gRPC request-response servicer."""
 
 
-from logging import DEBUG, ERROR, INFO
+from logging import DEBUG, INFO
 
 import grpc
 from google.protobuf.json_format import MessageToDict
 
-from flwr.common.constant import Status
 from flwr.common.inflatable import UnexpectedObjectContentError
 from flwr.common.logger import log
 from flwr.common.typing import InvalidRunStatusException
@@ -50,9 +49,8 @@ from flwr.proto.run_pb2 import GetRunRequest, GetRunResponse  # pylint: disable=
 from flwr.server.superlink.ffs.ffs_factory import FfsFactory
 from flwr.server.superlink.fleet.message_handler import message_handler
 from flwr.server.superlink.linkstate import LinkStateFactory
-from flwr.server.superlink.utils import abort_grpc_context, check_abort
+from flwr.server.superlink.utils import abort_grpc_context
 from flwr.supercore.object_store import ObjectStoreFactory
-from flwr.supercore.object_store.object_store import NoObjectInStoreError
 
 
 class FleetServicer(fleet_pb2_grpc.FleetServicer):
@@ -185,36 +183,20 @@ class FleetServicer(fleet_pb2_grpc.FleetServicer):
             request.object_id,
         )
 
-        state = self.state_factory.state()
-
-        # Abort if the run is not running
-        abort_msg = check_abort(
-            request.run_id,
-            [Status.PENDING, Status.STARTING, Status.FINISHED],
-            state,
-        )
-        if abort_msg:
-            abort_grpc_context(abort_msg, context)
-
-        if request.node.node_id not in state.get_nodes(run_id=request.run_id):
-            # Cancel insertion in ObjectStore
-            context.abort(grpc.StatusCode.FAILED_PRECONDITION, "Unexpected node ID.")
-
-        # Init store
-        store = self.objectstore_factory.store()
-
-        # Insert in store
-        stored = False
         try:
-            store.put(request.object_id, request.object_content)
-            stored = True
-        except (NoObjectInStoreError, ValueError) as e:
-            log(ERROR, str(e))
+            # Insert in Store
+            res = message_handler.push_object(
+                request=request,
+                state=self.state_factory.state(),
+                store=self.objectstore_factory.store(),
+            )
+        except InvalidRunStatusException as e:
+            abort_grpc_context(e.message, context)
         except UnexpectedObjectContentError as e:
             # Object content is not valid
             context.abort(grpc.StatusCode.FAILED_PRECONDITION, str(e))
 
-        return PushObjectResponse(stored=stored)
+        return res
 
     def PullObject(
         self, request: PullObjectRequest, context: grpc.ServicerContext
@@ -226,31 +208,14 @@ class FleetServicer(fleet_pb2_grpc.FleetServicer):
             request.object_id,
         )
 
-        state = self.state_factory.state()
-
-        # Abort if the run is not running
-        abort_msg = check_abort(
-            request.run_id,
-            [Status.PENDING, Status.STARTING, Status.FINISHED],
-            state,
-        )
-        if abort_msg:
-            abort_grpc_context(abort_msg, context)
-
-        if request.node.node_id not in state.get_nodes(run_id=request.run_id):
-            # Cancel insertion in ObjectStore
-            context.abort(grpc.StatusCode.FAILED_PRECONDITION, "Unexpected node ID.")
-
-        # Init store
-        store = self.objectstore_factory.store()
-
-        # Fetch from store
-        content = store.get(request.object_id)
-        if content is not None:
-            object_available = content != b""
-            return PullObjectResponse(
-                object_found=True,
-                object_available=object_available,
-                object_content=content,
+        try:
+            # Fetch from store
+            res = message_handler.pull_object(
+                request=request,
+                state=self.state_factory.state(),
+                store=self.objectstore_factory.store(),
             )
-        return PullObjectResponse(object_found=False, object_available=False)
+        except InvalidRunStatusException as e:
+            abort_grpc_context(e.message, context)
+
+        return res

{flwr_nightly-1.19.0.dev20250609 → flwr_nightly-1.19.0.dev20250610}/py/flwr/server/superlink/fleet/message_handler/message_handler.py

@@ -19,6 +19,7 @@ from typing import Optional
 
 from flwr.common import Message, log
 from flwr.common.constant import Status
+from flwr.common.inflatable import UnexpectedObjectContentError
 from flwr.common.serde import (
     fab_to_proto,
     message_from_proto,
@@ -42,7 +43,13 @@ from flwr.proto.heartbeat_pb2 import (  # pylint: disable=E0611
     SendNodeHeartbeatRequest,
     SendNodeHeartbeatResponse,
 )
-from flwr.proto.message_pb2 import ObjectIDs  # pylint: disable=E0611
+from flwr.proto.message_pb2 import (  # pylint: disable=E0611
+    ObjectIDs,
+    PullObjectRequest,
+    PullObjectResponse,
+    PushObjectRequest,
+    PushObjectResponse,
+)
 from flwr.proto.node_pb2 import Node  # pylint: disable=E0611
 from flwr.proto.run_pb2 import (  # pylint: disable=E0611
     GetRunRequest,
@@ -203,3 +210,52 @@ def get_fab(
         return GetFabResponse(fab=fab_to_proto(fab))
 
     raise ValueError(f"Found no FAB with hash: {request.hash_str}")
+
+
+def push_object(
+    request: PushObjectRequest, state: LinkState, store: ObjectStore
+) -> PushObjectResponse:
+    """Push Object."""
+    abort_msg = check_abort(
+        request.run_id,
+        [Status.PENDING, Status.STARTING, Status.FINISHED],
+        state,
+    )
+    if abort_msg:
+        raise InvalidRunStatusException(abort_msg)
+
+    stored = False
+    try:
+        store.put(request.object_id, request.object_content)
+        stored = True
+    except (NoObjectInStoreError, ValueError) as e:
+        log(ERROR, str(e))
+    except UnexpectedObjectContentError as e:
+        # Object content is not valid
+        log(ERROR, str(e))
+        raise
+    return PushObjectResponse(stored=stored)
+
+
+def pull_object(
+    request: PullObjectRequest, state: LinkState, store: ObjectStore
+) -> PullObjectResponse:
+    """Pull Object."""
+    abort_msg = check_abort(
+        request.run_id,
+        [Status.PENDING, Status.STARTING, Status.FINISHED],
+        state,
+    )
+    if abort_msg:
+        raise InvalidRunStatusException(abort_msg)
+
+    # Fetch from store
+    content = store.get(request.object_id)
+    if content is not None:
+        object_available = content != b""
+        return PullObjectResponse(
+            object_found=True,
+            object_available=object_available,
+            object_content=content,
+        )
+    return PullObjectResponse(object_found=False, object_available=False)

{flwr_nightly-1.19.0.dev20250609 → flwr_nightly-1.19.0.dev20250610}/py/flwr/supernode/start_client_internal.py

@@ -52,9 +52,9 @@ from flwr.common.logger import log
 from flwr.common.retry_invoker import RetryInvoker, RetryState, exponential
 from flwr.common.typing import Fab, Run, RunNotRunningException, UserConfig
 from flwr.proto.clientappio_pb2_grpc import add_ClientAppIoServicer_to_server
-from flwr.server.superlink.ffs import FfsFactory
-from flwr.supercore.object_store import ObjectStoreFactory
-from flwr.supernode.nodestate import NodeStateFactory
+from flwr.server.superlink.ffs import Ffs, FfsFactory
+from flwr.supercore.object_store import ObjectStore, ObjectStoreFactory
+from flwr.supernode.nodestate import NodeState, NodeStateFactory
 from flwr.supernode.servicer.clientappio import ClientAppInputs, ClientAppIoServicer
 
 DEFAULT_FFS_DIR = get_flwr_dir() / "supernode" / "ffs"
@@ -145,7 +145,7 @@ def start_client_internal(
     # Initialize NodeState, Ffs, and ObjectStore
     state = state_factory.state()
     ffs = ffs_factory.ffs()
-    _store = object_store_factory.store()
+    store = object_store_factory.store()
 
     with _init_connection(
         transport=transport,
@@ -166,63 +166,20 @@ def start_client_internal(
 
         # pylint: disable=too-many-nested-blocks
         while True:
-            # Pull message
-            if (message := receive()) is None:
-                time.sleep(3)
-                continue
-
-            # Log message reception
-            log(INFO, "")
-            if message.metadata.group_id:
-                log(
-                    INFO,
-                    "[RUN %s, ROUND %s]",
-                    message.metadata.run_id,
-                    message.metadata.group_id,
-                )
-            else:
-                log(INFO, "[RUN %s]", message.metadata.run_id)
-            log(
-                INFO,
-                "Received: %s message %s",
-                message.metadata.message_type,
-                message.metadata.message_id,
+            # The signature of the function will change after
+            # completing the transition to the `NodeState`-based SuperNode
+            run_id = _pull_and_store_message(
+                state=state,
+                ffs=ffs,
+                object_store=store,
+                node_config=node_config,
+                receive=receive,
+                get_run=get_run,
+                get_fab=get_fab,
             )
 
-            # Ensure the run and FAB are available
-            run_id = message.metadata.run_id
-            try:
-                # Check if the message is from an unknown run
-                if (run_info := state.get_run(run_id)) is None:
-                    # Pull run info from SuperLink
-                    run_info = get_run(run_id)
-                    state.store_run(run_info)
-
-                    # Pull and store the FAB
-                    fab = get_fab(run_info.fab_hash, run_id)
-                    ffs.put(fab.content, {})
-
-                    # Initialize the context
-                    run_cfg = get_fused_config_from_fab(fab.content, run_info)
-                    run_ctx = Context(
-                        run_id=run_id,
-                        node_id=state.get_node_id(),
-                        node_config=node_config,
-                        state=RecordDict(),
-                        run_config=run_cfg,
-                    )
-                    state.store_context(run_ctx)
-
-                # Store the message in the state
-                state.store_message(message)
-            except RunNotRunningException:
-                log(
-                    INFO,
-                    "Run ID %s is not in `RUNNING` status. Ignoring message %s.",
-                    run_id,
-                    message.metadata.message_id,
-                )
-                time.sleep(3)
+            if run_id is None:
+                time.sleep(3)  # Wait for 3s before asking again
                 continue
 
             try:
@@ -302,6 +259,91 @@ def start_client_internal(
                 log(INFO, "")
 
 
+def _pull_and_store_message(  # pylint: disable=too-many-positional-arguments
+    state: NodeState,
+    ffs: Ffs,
+    object_store: ObjectStore,  # pylint: disable=unused-argument
+    node_config: UserConfig,
+    receive: Callable[[], Optional[Message]],
+    get_run: Callable[[int], Run],
+    get_fab: Callable[[str, int], Fab],
+) -> Optional[int]:
+    """Pull a message from the SuperLink and store it in the state.
+
+    This function current returns None if no message is received,
+    or run_id if a message is received and processed successfully.
+    This behavior will change in the future to return None after
+    completing transition to the `NodeState`-based SuperNode.
+    """
+    message = None
+    try:
+        # Pull message
+        if (message := receive()) is None:
+            return None
+
+        # Log message reception
+        log(INFO, "")
+        if message.metadata.group_id:
+            log(
+                INFO,
+                "[RUN %s, ROUND %s]",
+                message.metadata.run_id,
+                message.metadata.group_id,
+            )
+        else:
+            log(INFO, "[RUN %s]", message.metadata.run_id)
+        log(
+            INFO,
+            "Received: %s message %s",
+            message.metadata.message_type,
+            message.metadata.message_id,
+        )
+
+        # Ensure the run and FAB are available
+        run_id = message.metadata.run_id
+
+        # Check if the message is from an unknown run
+        if (run_info := state.get_run(run_id)) is None:
+            # Pull run info from SuperLink
+            run_info = get_run(run_id)
+            state.store_run(run_info)
+
+            # Pull and store the FAB
+            fab = get_fab(run_info.fab_hash, run_id)
+            ffs.put(fab.content, {})
+
+            # Initialize the context
+            run_cfg = get_fused_config_from_fab(fab.content, run_info)
+            run_ctx = Context(
+                run_id=run_id,
+                node_id=state.get_node_id(),
+                node_config=node_config,
+                state=RecordDict(),
+                run_config=run_cfg,
+            )
+            state.store_context(run_ctx)
+
+        # Store the message in the state
+        state.store_message(message)
+    except RunNotRunningException:
+        if message is None:
+            log(
+                INFO,
+                "Run transitioned to a non-`RUNNING` status while receiving a message. "
+                "Ignoring the message.",
+            )
+        else:
+            log(
+                INFO,
+                "Run ID %s is not in `RUNNING` status. Ignoring message %s.",
+                run_id,
+                message.metadata.message_id,
+            )
+        return None
+
+    return run_id
+
+
 @contextmanager
 def _init_connection(  # pylint: disable=too-many-positional-arguments
     transport: str,