flwr-nightly 1.20.0.dev20250718__tar.gz → 1.20.0.dev20250720__tar.gz

{flwr_nightly-1.20.0.dev20250718 → flwr_nightly-1.20.0.dev20250720}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: flwr-nightly
-Version: 1.20.0.dev20250718
+Version: 1.20.0.dev20250720
 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.20.0.dev20250718 → flwr_nightly-1.20.0.dev20250720}/py/flwr/cli/build.py

@@ -184,7 +184,7 @@ def build_fab(app: Path) -> tuple[bytes, str, dict[str, Any]]:
             # Read the file content manually
             file_contents = file_path.read_bytes()
 
-            archive_path = str(file_path.relative_to(app))
+            archive_path = str(file_path.relative_to(app)).replace("\\", "/")
             write_to_zip(fab_file, archive_path, file_contents)
 
             # Calculate file info

{flwr_nightly-1.20.0.dev20250718 → flwr_nightly-1.20.0.dev20250720}/py/flwr/client/grpc_adapter_client/connection.py

@@ -49,6 +49,9 @@ def grpc_adapter(  # pylint: disable=R0913,too-many-positional-arguments
         Callable[[], None],
         Callable[[int], Run],
         Callable[[str, int], Fab],
+        Callable[[int, str], bytes],
+        Callable[[int, str, bytes], None],
+        Callable[[int, str], None],
     ]
 ]:
     """Primitives for request/response-based interaction with a server via GrpcAdapter.
@@ -83,6 +86,9 @@ def grpc_adapter(  # pylint: disable=R0913,too-many-positional-arguments
     delete_node : Optional[Callable]
     get_run : Optional[Callable]
     get_fab : Optional[Callable]
+    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.")

{flwr_nightly-1.20.0.dev20250718 → flwr_nightly-1.20.0.dev20250720}/py/flwr/client/grpc_rere_client/connection.py

@@ -35,6 +35,7 @@ from flwr.common.inflatable import (
     no_object_id_recompute,
 )
 from flwr.common.inflatable_protobuf_utils import (
+    make_confirm_message_received_fn_protobuf,
     make_pull_object_fn_protobuf,
     make_push_object_fn_protobuf,
 )
@@ -94,6 +95,9 @@ def grpc_request_response(  # pylint: disable=R0913,R0914,R0915,R0917
         Callable[[], None],
         Callable[[int], Run],
         Callable[[str, int], Fab],
+        Callable[[int, str], bytes],
+        Callable[[int, str, bytes], None],
+        Callable[[int, str], None],
     ]
 ]:
     """Primitives for request/response-based interaction with a server.
@@ -136,6 +140,9 @@ def grpc_request_response(  # pylint: disable=R0913,R0914,R0915,R0917
     create_node : Optional[Callable]
     delete_node : Optional[Callable]
     get_run : Optional[Callable]
+    pull_object : Callable[[str], bytes]
+    push_object : Callable[[str, bytes], None]
+    confirm_message_received : Callable[[str], None]
     """
     if isinstance(root_certificates, str):
         root_certificates = Path(root_certificates).read_bytes()
@@ -354,9 +361,58 @@ def grpc_request_response(  # pylint: disable=R0913,R0914,R0915,R0917
 
         return Fab(get_fab_response.fab.hash_str, get_fab_response.fab.content)
 
+    def pull_object(run_id: int, object_id: str) -> bytes:
+        """Pull the object from the SuperLink."""
+        # Check Node
+        if node is None:
+            raise RuntimeError("Node instance missing")
+
+        fn = make_pull_object_fn_protobuf(
+            pull_object_protobuf=stub.PullObject,
+            node=node,
+            run_id=run_id,
+        )
+        return fn(object_id)
+
+    def push_object(run_id: int, object_id: str, contents: bytes) -> None:
+        """Push the object to the SuperLink."""
+        # Check Node
+        if node is None:
+            raise RuntimeError("Node instance missing")
+
+        fn = make_push_object_fn_protobuf(
+            push_object_protobuf=stub.PushObject,
+            node=node,
+            run_id=run_id,
+        )
+        fn(object_id, contents)
+
+    def confirm_message_received(run_id: int, object_id: str) -> None:
+        """Confirm that the message has been received."""
+        # Check Node
+        if node is None:
+            raise RuntimeError("Node instance missing")
+
+        fn = make_confirm_message_received_fn_protobuf(
+            confirm_message_received_protobuf=stub.ConfirmMessageReceived,
+            node=node,
+            run_id=run_id,
+        )
+        fn(object_id)
+
     try:
         # Yield methods
-        yield (receive, send, create_node, delete_node, get_run, get_fab)
+        yield (
+            receive,
+            send,
+            create_node,
+            delete_node,
+            get_run,
+            get_fab,
+            pull_object,
+            push_object,
+            confirm_message_received,
+        )
     except Exception as exc:  # pylint: disable=broad-except
         log(ERROR, exc)
     # Cleanup

{flwr_nightly-1.20.0.dev20250718 → flwr_nightly-1.20.0.dev20250720}/py/flwr/client/rest_client/connection.py

@@ -35,6 +35,7 @@ from flwr.common.inflatable import (
     no_object_id_recompute,
 )
 from flwr.common.inflatable_protobuf_utils import (
+    make_confirm_message_received_fn_protobuf,
     make_pull_object_fn_protobuf,
     make_push_object_fn_protobuf,
 )
@@ -114,6 +115,9 @@ def http_request_response(  # pylint: disable=R0913,R0914,R0915,R0917
         Callable[[], None],
         Callable[[int], Run],
         Callable[[str, int], Fab],
+        Callable[[int, str], bytes],
+        Callable[[int, str, bytes], None],
+        Callable[[int, str], None],
     ]
 ]:
     """Primitives for request/response-based interaction with a server.
@@ -149,6 +153,9 @@ def http_request_response(  # pylint: disable=R0913,R0914,R0915,R0917
     create_node : Optional[Callable]
     delete_node : Optional[Callable]
     get_run : Optional[Callable]
+    pull_object : Callable[[str], bytes]
+    push_object : Callable[[str, bytes], None]
+    confirm_message_received : Callable[[str], None]
     """
     log(
         WARN,
@@ -230,6 +237,38 @@ def http_request_response(  # pylint: disable=R0913,R0914,R0915,R0917
         grpc_res.ParseFromString(res.content)
         return grpc_res
 
+    def _pull_object_protobuf(request: PullObjectRequest) -> PullObjectResponse:
+        res = _request(
+            req=request,
+            res_type=PullObjectResponse,
+            api_path=PATH_PULL_OBJECT,
+        )
+        if res is None:
+            raise ValueError(f"{PullObjectResponse.__name__} is None.")
+        return res
+
+    def _push_object_protobuf(request: PushObjectRequest) -> PushObjectResponse:
+        res = _request(
+            req=request,
+            res_type=PushObjectResponse,
+            api_path=PATH_PUSH_OBJECT,
+        )
+        if res is None:
+            raise ValueError(f"{PushObjectResponse.__name__} is None.")
+        return res
+
+    def _confirm_message_received_protobuf(
+        request: ConfirmMessageReceivedRequest,
+    ) -> ConfirmMessageReceivedResponse:
+        res = _request(
+            req=request,
+            res_type=ConfirmMessageReceivedResponse,
+            api_path=PATH_CONFIRM_MESSAGE_RECEIVED,
+        )
+        if res is None:
+            raise ValueError(f"{ConfirmMessageReceivedResponse.__name__} is None.")
+        return res
+
     def send_node_heartbeat() -> bool:
         # Get Node
         if node is None:
@@ -326,20 +365,12 @@ def http_request_response(  # pylint: disable=R0913,R0914,R0915,R0917
             msg_id = message_proto.metadata.message_id
             run_id = message_proto.metadata.run_id
 
-            def fn(request: PullObjectRequest) -> PullObjectResponse:
-                res = _request(
-                    req=request, res_type=PullObjectResponse, api_path=PATH_PULL_OBJECT
-                )
-                if res is None:
-                    raise ValueError("PushObjectResponse is None.")
-                return res
-
             try:
                 object_tree = res.message_object_trees[0]
                 all_object_contents = pull_objects(
                     [tree.object_id for tree in iterate_object_tree(object_tree)],
                     pull_object_fn=make_pull_object_fn_protobuf(
-                        pull_object_protobuf=fn,
+                        pull_object_protobuf=_pull_object_protobuf,
                         node=node,
                         run_id=run_id,
                     ),
@@ -403,21 +434,11 @@ def http_request_response(  # pylint: disable=R0913,R0914,R0915,R0917
             if res and res.objects_to_push:
                 objs_to_push = set(res.objects_to_push[message.object_id].object_ids)
 
-                def fn(request: PushObjectRequest) -> PushObjectResponse:
-                    res = _request(
-                        req=request,
-                        res_type=PushObjectResponse,
-                        api_path=PATH_PUSH_OBJECT,
-                    )
-                    if res is None:
-                        raise ValueError("PushObjectResponse is None.")
-                    return res
-
                 try:
                     push_objects(
                         all_objects,
                         push_object_fn=make_push_object_fn_protobuf(
-                            push_object_protobuf=fn,
+                            push_object_protobuf=_push_object_protobuf,
                             node=node,
                             run_id=message_proto.metadata.run_id,
                         ),
@@ -457,9 +478,58 @@ def http_request_response(  # pylint: disable=R0913,R0914,R0915,R0917
             res.fab.content,
         )
 
+    def pull_object(run_id: int, object_id: str) -> bytes:
+        """Pull the object from the SuperLink."""
+        # Check Node
+        if node is None:
+            raise RuntimeError("Node instance missing")
+
+        fn = make_pull_object_fn_protobuf(
+            pull_object_protobuf=_pull_object_protobuf,
+            node=node,
+            run_id=run_id,
+        )
+        return fn(object_id)
+
+    def push_object(run_id: int, object_id: str, contents: bytes) -> None:
+        """Push the object to the SuperLink."""
+        # Check Node
+        if node is None:
+            raise RuntimeError("Node instance missing")
+
+        fn = make_push_object_fn_protobuf(
+            push_object_protobuf=_push_object_protobuf,
+            node=node,
+            run_id=run_id,
+        )
+        fn(object_id, contents)
+
+    def confirm_message_received(run_id: int, object_id: str) -> None:
+        """Confirm that the message has been received."""
+        # Check Node
+        if node is None:
+            raise RuntimeError("Node instance missing")
+
+        fn = make_confirm_message_received_fn_protobuf(
+            confirm_message_received_protobuf=_confirm_message_received_protobuf,
+            node=node,
+            run_id=run_id,
+        )
+        fn(object_id)
+
     try:
         # Yield methods
-        yield (receive, send, create_node, delete_node, get_run, get_fab)
+        yield (
+            receive,
+            send,
+            create_node,
+            delete_node,
+            get_run,
+            get_fab,
+            pull_object,
+            push_object,
+            confirm_message_received,
+        )
     except Exception as exc:  # pylint: disable=broad-except
         log(ERROR, exc)
     # Cleanup

{flwr_nightly-1.20.0.dev20250718 → flwr_nightly-1.20.0.dev20250720}/py/flwr/common/inflatable_utils.py

@@ -19,6 +19,7 @@ import os
 import random
 import threading
 import time
+from collections.abc import Iterable, Iterator
 from typing import Callable, Optional, TypeVar
 
 from flwr.proto.message_pb2 import ObjectTree  # pylint: disable=E0611
@@ -110,24 +111,61 @@ def push_objects(
     max_concurrent_pushes : int (default: MAX_CONCURRENT_PUSHES)
         The maximum number of concurrent pushes to perform.
     """
-    if object_ids_to_push is not None:
-        # Filter objects to push only those with IDs in the set
-        objects = {k: v for k, v in objects.items() if k in object_ids_to_push}
-
     lock = threading.Lock()
 
-    def push(obj_id: str) -> None:
+    def iter_dict_items() -> Iterator[tuple[str, bytes]]:
+        """Iterate over the dictionary items."""
+        for obj_id in list(objects.keys()):
+            # Skip the object if no need to push it
+            if object_ids_to_push is not None and obj_id not in object_ids_to_push:
+                continue
+
+            # Deflate the object content
+            object_content = objects[obj_id].deflate()
+            if not keep_objects:
+                with lock:
+                    del objects[obj_id]
+
+            yield obj_id, object_content
+
+    push_object_contents_from_iterable(
+        iter_dict_items(),
+        push_object_fn,
+        max_concurrent_pushes=max_concurrent_pushes,
+    )
+
+
+def push_object_contents_from_iterable(
+    object_contents: Iterable[tuple[str, bytes]],
+    push_object_fn: Callable[[str, bytes], None],
+    *,
+    max_concurrent_pushes: int = MAX_CONCURRENT_PUSHES,
+) -> None:
+    """Push multiple object contents to the servicer.
+
+    Parameters
+    ----------
+    object_contents : Iterable[tuple[str, bytes]]
+        An iterable of `(object_id, object_content)` pairs.
+        `object_id` is the object ID, and `object_content` is the object content.
+    push_object_fn : Callable[[str, bytes], None]
+        A function that takes an object ID and its content as bytes, and pushes
+        it to the servicer. This function should raise `ObjectIdNotPreregisteredError`
+        if the object ID is not pre-registered.
+    max_concurrent_pushes : int (default: MAX_CONCURRENT_PUSHES)
+        The maximum number of concurrent pushes to perform.
+    """
+
+    def push(args: tuple[str, bytes]) -> None:
         """Push a single object."""
-        object_content = objects[obj_id].deflate()
-        if not keep_objects:
-            with lock:
-                del objects[obj_id]
-        push_object_fn(obj_id, object_content)
+        obj_id, obj_content = args
+        # Push the object using the provided function
+        push_object_fn(obj_id, obj_content)
 
-    # Push all objects concurrently
+    # Push all object contents concurrently
     num_workers = get_num_workers(max_concurrent_pushes)
     with concurrent.futures.ThreadPoolExecutor(max_workers=num_workers) as executor:
-        list(executor.map(push, list(objects.keys())))
+        list(executor.map(push, object_contents))
 
 
 def pull_objects(  # pylint: disable=too-many-arguments,too-many-locals

{flwr_nightly-1.20.0.dev20250718 → flwr_nightly-1.20.0.dev20250720}/py/flwr/server/superlink/fleet/message_handler/message_handler.py

@@ -61,8 +61,7 @@ from flwr.server.superlink.linkstate import LinkState
 from flwr.server.superlink.utils import check_abort
 from flwr.supercore.ffs import Ffs
 from flwr.supercore.object_store import NoObjectInStoreError, ObjectStore
-
-from ...utils import store_mapping_and_register_objects
+from flwr.supercore.object_store.utils import store_mapping_and_register_objects
 
 
 def create_node(

{flwr_nightly-1.20.0.dev20250718 → flwr_nightly-1.20.0.dev20250720}/py/flwr/server/superlink/serverappio/serverappio_servicer.py

@@ -87,8 +87,7 @@ from flwr.server.superlink.utils import abort_if
 from flwr.server.utils.validator import validate_message
 from flwr.supercore.ffs import Ffs, FfsFactory
 from flwr.supercore.object_store import NoObjectInStoreError, ObjectStoreFactory
-
-from ..utils import store_mapping_and_register_objects
+from flwr.supercore.object_store.utils import store_mapping_and_register_objects
 
 
 class ServerAppIoServicer(serverappio_pb2_grpc.ServerAppIoServicer):

flwr_nightly-1.20.0.dev20250720/py/flwr/supercore/object_store/utils.py

@@ -0,0 +1,48 @@
+# 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.
+# ==============================================================================
+"""Utils for ObjectStore."""
+
+
+from typing import Union
+
+from flwr.proto.appio_pb2 import PushAppMessagesRequest  # pylint: disable=E0611
+from flwr.proto.fleet_pb2 import PushMessagesRequest  # pylint: disable=E0611
+from flwr.proto.message_pb2 import ObjectIDs  # pylint: disable=E0611
+
+from . import ObjectStore
+
+
+def store_mapping_and_register_objects(
+    store: ObjectStore, request: Union[PushAppMessagesRequest, PushMessagesRequest]
+) -> dict[str, ObjectIDs]:
+    """Store Message object to descendants mapping and preregister objects."""
+    if not request.messages_list:
+        return {}
+
+    objects_to_push: dict[str, ObjectIDs] = {}
+
+    # Get run_id from the first message in the list
+    # All messages of a request should in the same run
+    run_id = request.messages_list[0].metadata.run_id
+
+    for object_tree in request.message_object_trees:
+        # Preregister
+        object_ids_just_registered = store.preregister(run_id, object_tree)
+        # Keep track of objects that need to be pushed
+        objects_to_push[object_tree.object_id] = ObjectIDs(
+            object_ids=object_ids_just_registered
+        )
+
+    return objects_to_push

{flwr_nightly-1.20.0.dev20250718 → flwr_nightly-1.20.0.dev20250720}/py/flwr/supernode/runtime/run_clientapp.py

@@ -32,13 +32,23 @@ from flwr.common import Context, Message
 from flwr.common.config import get_flwr_dir
 from flwr.common.constant import ErrorCode
 from flwr.common.grpc import create_channel, on_channel_state_change
+from flwr.common.inflatable import (
+    get_all_nested_objects,
+    get_object_tree,
+    no_object_id_recompute,
+)
+from flwr.common.inflatable_protobuf_utils import (
+    make_confirm_message_received_fn_protobuf,
+    make_pull_object_fn_protobuf,
+    make_push_object_fn_protobuf,
+)
+from flwr.common.inflatable_utils import pull_and_inflate_object_from_tree, push_objects
 from flwr.common.logger import log
 from flwr.common.retry_invoker import _make_simple_grpc_retry_invoker, _wrap_stub
 from flwr.common.serde import (
     context_from_proto,
     context_to_proto,
     fab_from_proto,
-    message_from_proto,
     message_to_proto,
     run_from_proto,
 )
@@ -61,6 +71,7 @@ from flwr.proto.clientappio_pb2 import (
     RequestTokenResponse,
 )
 from flwr.proto.clientappio_pb2_grpc import ClientAppIoStub
+from flwr.proto.node_pb2 import Node  # pylint: disable=E0611
 from flwr.supercore.utils import mask_string
 
 
@@ -204,12 +215,6 @@ def pull_clientappinputs(
     masked_token = mask_string(token)
     log(INFO, "[flwr-clientapp] Pull `ClientAppInputs` for token %s", masked_token)
     try:
-        # Pull Message
-        pull_msg_res: PullAppMessagesResponse = stub.PullMessage(
-            PullAppMessagesRequest(token=token)
-        )
-        message = message_from_proto(pull_msg_res.messages_list[0])
-
         # Pull Context, Run and (optional) FAB
         res: PullAppInputsResponse = stub.PullClientAppInputs(
             PullAppInputsRequest(token=token)
@@ -217,6 +222,26 @@ def pull_clientappinputs(
         context = context_from_proto(res.context)
         run = run_from_proto(res.run)
         fab = fab_from_proto(res.fab) if res.fab else None
+
+        # Pull and inflate the message
+        pull_msg_res: PullAppMessagesResponse = stub.PullMessage(
+            PullAppMessagesRequest(token=token)
+        )
+        run_id = context.run_id
+        node = Node(node_id=context.node_id)
+        object_tree = pull_msg_res.message_object_trees[0]
+        message = pull_and_inflate_object_from_tree(
+            object_tree,
+            make_pull_object_fn_protobuf(stub.PullObject, node, run_id),
+            make_confirm_message_received_fn_protobuf(
+                stub.ConfirmMessageReceived, node, run_id
+            ),
+            return_type=Message,
+        )
+
+        # Set the message ID
+        # The deflated message doesn't contain the message_id (its own object_id)
+        message.metadata.__dict__["_message_id"] = object_tree.object_id
         return message, context, run, fab
     except grpc.RpcError as e:
         log(ERROR, "[PullClientAppInputs] gRPC error occurred: %s", str(e))
@@ -236,10 +261,38 @@ def push_clientappoutputs(
 
     try:
 
-        # Push Message
-        _ = stub.PushMessage(
-            PushAppMessagesRequest(token=token, messages_list=[proto_message])
-        )
+        with no_object_id_recompute():
+            # Get object tree and all objects to push
+            object_tree = get_object_tree(message)
+
+            # Push Message
+            # This is temporary. The message should not contain its content
+            push_msg_res = stub.PushMessage(
+                PushAppMessagesRequest(
+                    token=token,
+                    messages_list=[proto_message],
+                    message_object_trees=[object_tree],
+                )
+            )
+            del proto_message
+
+            # Retrieve the object IDs to push
+            object_ids_to_push = set(
+                push_msg_res.objects_to_push[object_tree.object_id].object_ids
+            )
+
+            # Push all objects
+            all_objects = get_all_nested_objects(message)
+            del message
+            push_objects(
+                all_objects,
+                make_push_object_fn_protobuf(
+                    stub.PushObject,
+                    Node(node_id=context.node_id),
+                    run_id=context.run_id,
+                ),
+                object_ids_to_push=object_ids_to_push,
+            )
 
         # Push Context
         res: PushAppOutputsResponse = stub.PushClientAppOutputs(

{flwr_nightly-1.20.0.dev20250718 → flwr_nightly-1.20.0.dev20250720}/py/flwr/supernode/servicer/clientappio/clientappio_servicer.py

@@ -63,6 +63,7 @@ from flwr.proto.message_pb2 import (
 # pylint: disable=E0601
 from flwr.supercore.ffs import FfsFactory
 from flwr.supercore.object_store import NoObjectInStoreError, ObjectStoreFactory
+from flwr.supercore.object_store.utils import store_mapping_and_register_objects
 from flwr.supernode.nodestate import NodeStateFactory
 
 
@@ -178,8 +179,9 @@ class ClientAppIoServicer(clientappio_pb2_grpc.ClientAppIoServicer):
         self, request: PullAppMessagesRequest, context: grpc.ServicerContext
     ) -> PullAppMessagesResponse:
         """Pull one Message."""
-        # Initialize state and ffs connection
+        # Initialize state and store connection
         state = self.state_factory.state()
+        store = self.objectstore_factory.store()
 
         # Validate the token
         run_id = state.get_run_id_by_token(request.token)
@@ -193,14 +195,21 @@ class ClientAppIoServicer(clientappio_pb2_grpc.ClientAppIoServicer):
         # Retrieve message for this run
         message = state.get_messages(run_ids=[run_id], is_reply=False)[0]
 
-        return PullAppMessagesResponse(messages_list=[message_to_proto(message)])
+        # Retrieve the object tree for the message
+        object_tree = store.get_object_tree(message.metadata.message_id)
+
+        return PullAppMessagesResponse(
+            messages_list=[message_to_proto(message)],
+            message_object_trees=[object_tree],
+        )
 
     def PushMessage(
         self, request: PushAppMessagesRequest, context: grpc.ServicerContext
     ) -> PushAppMessagesResponse:
         """Push one Message."""
-        # Initialize state connection
+        # Initialize state and store connection
         state = self.state_factory.state()
+        store = self.objectstore_factory.store()
 
         # Validate the token
         run_id = state.get_run_id_by_token(request.token)
@@ -214,7 +223,10 @@ class ClientAppIoServicer(clientappio_pb2_grpc.ClientAppIoServicer):
         # Save the message to the state
         state.store_message(message_from_proto(request.messages_list[0]))
 
-        return PushAppMessagesResponse()
+        # Store Message object to descendants mapping and preregister objects
+        objects_to_push = store_mapping_and_register_objects(store, request=request)
+
+        return PushAppMessagesResponse(objects_to_push=objects_to_push)
 
     def PushObject(
         self, request: PushObjectRequest, context: grpc.ServicerContext