flwr-nightly 1.11.0.dev20240815__py3-none-any.whl → 1.11.0.dev20240816__py3-none-any.whl

flwr/cli/config_utils.py

@@ -74,13 +74,13 @@ def get_fab_metadata(fab_file: Union[Path, bytes]) -> Tuple[str, str]:
     Returns
     -------
     Tuple[str, str]
-        The `fab_version` and `fab_id` of the given Flower App Bundle.
+        The `fab_id` and `fab_version` of the given Flower App Bundle.
     """
     conf = get_fab_config(fab_file)
 
     return (
-        conf["project"]["version"],
         f"{conf['tool']['flwr']['app']['publisher']}/{conf['project']['name']}",
+        conf["project"]["version"],
     )
 
 

flwr/cli/run/run.py

@@ -35,6 +35,11 @@ from flwr.proto.exec_pb2 import StartRunRequest  # pylint: disable=E0611
 from flwr.proto.exec_pb2_grpc import ExecStub
 
 
+def on_channel_state_change(channel_connectivity: str) -> None:
+    """Log channel connectivity."""
+    log(DEBUG, channel_connectivity)
+
+
 # pylint: disable-next=too-many-locals
 def run(
     app: Annotated[
@@ -122,10 +127,6 @@ def _run_with_superexec(
     config_overrides: Optional[List[str]],
 ) -> None:
 
-    def on_channel_state_change(channel_connectivity: str) -> None:
-        """Log channel connectivity."""
-        log(DEBUG, channel_connectivity)
-
     insecure_str = federation_config.get("insecure")
     if root_certificates := federation_config.get("root-certificates"):
         root_certificates_bytes = Path(root_certificates).read_bytes()

flwr/client/app.py

@@ -15,6 +15,7 @@
 """Flower client app."""
 
 import signal
+import subprocess
 import sys
 import time
 from dataclasses import dataclass
@@ -22,9 +23,12 @@ from logging import ERROR, INFO, WARN
 from pathlib import Path
 from typing import Callable, ContextManager, Dict, Optional, Tuple, Type, Union
 
+import grpc
 from cryptography.hazmat.primitives.asymmetric import ec
 from grpc import RpcError
 
+from flwr.cli.config_utils import get_fab_metadata
+from flwr.cli.install import install_from_fab
 from flwr.client.client import Client
 from flwr.client.client_app import ClientApp, LoadClientAppError
 from flwr.client.typing import ClientFnExt
@@ -32,6 +36,7 @@ from flwr.common import GRPC_MAX_MESSAGE_LENGTH, Context, EventType, Message, ev
 from flwr.common.address import parse_address
 from flwr.common.constant import (
     MISSING_EXTRA_REST,
+    RUN_ID_NUM_BYTES,
     TRANSPORT_TYPE_GRPC_ADAPTER,
     TRANSPORT_TYPE_GRPC_BIDI,
     TRANSPORT_TYPE_GRPC_RERE,
@@ -43,6 +48,9 @@ from flwr.common.logger import log, warn_deprecated_feature
 from flwr.common.message import Error
 from flwr.common.retry_invoker import RetryInvoker, RetryState, exponential
 from flwr.common.typing import Fab, Run, UserConfig
+from flwr.proto.clientappio_pb2_grpc import add_ClientAppIoServicer_to_server
+from flwr.server.superlink.fleet.grpc_bidi.grpc_server import generic_create_grpc_server
+from flwr.server.superlink.state.utils import generate_rand_int_from_bytes
 
 from .grpc_adapter_client.connection import grpc_adapter
 from .grpc_client.connection import grpc_connection
@@ -50,6 +58,9 @@ from .grpc_rere_client.connection import grpc_request_response
 from .message_handler.message_handler import handle_control_message
 from .node_state import NodeState
 from .numpy_client import NumPyClient
+from .process.clientappio_servicer import ClientAppIoInputs, ClientAppIoServicer
+
+ADDRESS_CLIENTAPPIO_API_GRPC_RERE = "0.0.0.0:9094"
 
 
 def _check_actionable_client(
@@ -158,7 +169,7 @@ def start_client(
     >>> )
     """
     event(EventType.START_CLIENT_ENTER)
-    _start_client_internal(
+    start_client_internal(
         server_address=server_address,
         node_config={},
         load_client_app_fn=None,
@@ -179,7 +190,7 @@ def start_client(
 # pylint: disable=too-many-branches
 # pylint: disable=too-many-locals
 # pylint: disable=too-many-statements
-def _start_client_internal(
+def start_client_internal(
     *,
     server_address: str,
     node_config: UserConfig,
@@ -196,6 +207,8 @@ def _start_client_internal(
     max_retries: Optional[int] = None,
     max_wait_time: Optional[float] = None,
     flwr_path: Optional[Path] = None,
+    isolate: Optional[bool] = False,
+    supernode_address: Optional[str] = ADDRESS_CLIENTAPPIO_API_GRPC_RERE,
 ) -> None:
     """Start a Flower client node which connects to a Flower server.
 
@@ -243,6 +256,13 @@ def _start_client_internal(
         If set to None, there is no limit to the total time.
     flwr_path: Optional[Path] (default: None)
         The fully resolved path containing installed Flower Apps.
+    isolate : Optional[bool] (default: False)
+        Whether to run `ClientApp` in a separate process. By default, this value is
+        `False`, and the `ClientApp` runs in the same process as the SuperNode. If
+        `True`, the `ClientApp` runs in an isolated process and communicates using
+        gRPC at the address `supernode_address`.
+    supernode_address : Optional[str] (default: `ADDRESS_CLIENTAPPIO_API_GRPC_RERE`)
+        The SuperNode gRPC server address.
     """
     if insecure is None:
         insecure = root_certificates is None
@@ -268,6 +288,13 @@ def _start_client_internal(
 
         load_client_app_fn = _load_client_app
 
+    if isolate:
+        if supernode_address is None:
+            raise ValueError("`supernode_address` required when `isolate` is set")
+        _clientappio_grpc_server, clientappio_servicer = run_clientappio_api_grpc(
+            address=supernode_address
+        )
+
     # At this point, only `load_client_app_fn` should be used
     # Both `client` and `client_fn` must not be used directly
 
@@ -333,7 +360,7 @@ def _start_client_internal(
             root_certificates,
             authentication_keys,
         ) as conn:
-            receive, send, create_node, delete_node, get_run, _ = conn
+            receive, send, create_node, delete_node, get_run, get_fab = conn
 
             # Register node when connecting the first time
             if node_state is None:
@@ -400,9 +427,20 @@ def _start_client_internal(
                         else:
                             runs[run_id] = Run(run_id, "", "", "", {})
 
+                    run: Run = runs[run_id]
+                    if get_fab is not None and run.fab_hash:
+                        fab = get_fab(run.fab_hash)
+                        install_from_fab(fab.content, flwr_path, True)
+                        fab_id, fab_version = get_fab_metadata(fab.content)
+                    else:
+                        fab = None
+                        fab_id, fab_version = run.fab_id, run.fab_version
+
+                    run.fab_id, run.fab_version = fab_id, fab_version
+
                     # Register context for this run
                     node_state.register_context(
-                        run_id=run_id, run=runs[run_id], flwr_path=flwr_path
+                        run_id=run_id, run=run, flwr_path=flwr_path
                     )
 
                     # Retrieve context for this run
@@ -416,14 +454,44 @@ def _start_client_internal(
 
                     # Handle app loading and task message
                     try:
-                        # Load ClientApp instance
-                        run: Run = runs[run_id]
-                        client_app: ClientApp = load_client_app_fn(
-                            run.fab_id, run.fab_version
-                        )
+                        if isolate and supernode_address is not None:
+                            # Generate SuperNode token
+                            token: int = generate_rand_int_from_bytes(RUN_ID_NUM_BYTES)
+
+                            # Share Message and Context with servicer
+                            clientappio_servicer.set_inputs(
+                                ClientAppIoInputs(
+                                    message=message,
+                                    context=context,
+                                    run=run,
+                                    token=token,
+                                )
+                            )
 
-                        # Execute ClientApp
-                        reply_message = client_app(message=message, context=context)
+                            # Run `ClientApp` in subprocess
+                            command = [
+                                "flwr-clientapp",
+                                "--supernode",
+                                supernode_address,
+                                "--token",
+                                str(token),
+                            ]
+                            subprocess.run(
+                                command,
+                                stdout=None,
+                                stderr=None,
+                                check=True,
+                            )
+                            outputs = clientappio_servicer.get_outputs()
+                            reply_message, context = outputs.message, outputs.context
+                        else:
+                            # Load ClientApp instance
+                            client_app: ClientApp = load_client_app_fn(
+                                fab_id, fab_version
+                            )
+
+                            # Execute ClientApp
+                            reply_message = client_app(message=message, context=context)
                     except Exception as ex:  # pylint: disable=broad-exception-caught
 
                         # Legacy grpc-bidi
@@ -667,3 +735,20 @@ class _AppStateTracker:
 
         signal.signal(signal.SIGINT, signal_handler)
         signal.signal(signal.SIGTERM, signal_handler)
+
+
+def run_clientappio_api_grpc(address: str) -> Tuple[grpc.Server, ClientAppIoServicer]:
+    """Run ClientAppIo API gRPC server."""
+    clientappio_servicer: grpc.Server = ClientAppIoServicer()
+    clientappio_add_servicer_to_server_fn = add_ClientAppIoServicer_to_server
+    clientappio_grpc_server = generic_create_grpc_server(
+        servicer_and_add_fn=(
+            clientappio_servicer,
+            clientappio_add_servicer_to_server_fn,
+        ),
+        server_address=address,
+        max_message_length=GRPC_MAX_MESSAGE_LENGTH,
+    )
+    log(INFO, "Starting Flower ClientAppIo gRPC server on %s", address)
+    clientappio_grpc_server.start()
+    return clientappio_grpc_server, clientappio_servicer

flwr/client/grpc_rere_client/connection.py

@@ -46,6 +46,7 @@ from flwr.common.serde import (
     user_config_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,
@@ -292,7 +293,13 @@ def grpc_request_response(  # pylint: disable=R0913, R0914, R0915
 
     def get_fab(fab_hash: str) -> Fab:
         # Call FleetAPI
-        raise NotImplementedError
+        get_fab_request = GetFabRequest(hash_str=fab_hash)
+        get_fab_response: GetFabResponse = retry_invoker.invoke(
+            stub.GetFab,
+            request=get_fab_request,
+        )
+
+        return Fab(get_fab_response.fab.hash_str, get_fab_response.fab.content)
 
     try:
         # Yield methods

flwr/client/process/clientappio_servicer.py

@@ -94,10 +94,6 @@ class ClientAppIoServicer(clientappio_pb2_grpc.ClientAppIoServicer):
     ) -> PushClientAppOutputsResponse:
         """Push Message and Context."""
         log(DEBUG, "ClientAppIo.PushClientAppOutputs")
-        if self.clientapp_output is None:
-            raise ValueError(
-                "ClientAppIoOutputs not set before calling `PushClientAppOutputs`."
-            )
         if self.clientapp_input is None:
             raise ValueError(
                 "ClientAppIoInputs not set before calling `PushClientAppOutputs`."
@@ -109,8 +105,11 @@ class ClientAppIoServicer(clientappio_pb2_grpc.ClientAppIoServicer):
             )
         try:
             # Update Message and Context
-            self.clientapp_output.message = message_from_proto(request.message)
-            self.clientapp_output.context = context_from_proto(request.context)
+            self.clientapp_output = ClientAppIoOutputs(
+                message=message_from_proto(request.message),
+                context=context_from_proto(request.context),
+            )
+
             # Set status
             code = typing.ClientAppOutputCode.SUCCESS
             status = typing.ClientAppOutputStatus(code=code, message="Success")

flwr/client/process/process.py

@@ -0,0 +1,143 @@
+# 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 ClientApp process."""
+
+from logging import DEBUG, ERROR, INFO
+from typing import Tuple
+
+import grpc
+
+from flwr.client.client_app import ClientApp, LoadClientAppError
+from flwr.common import Context, Message
+from flwr.common.constant import ErrorCode
+from flwr.common.grpc import create_channel
+from flwr.common.logger import log
+from flwr.common.message import Error
+from flwr.common.serde import (
+    context_from_proto,
+    context_to_proto,
+    message_from_proto,
+    message_to_proto,
+    run_from_proto,
+)
+from flwr.common.typing import Run
+
+# pylint: disable=E0611
+from flwr.proto.clientappio_pb2 import (
+    PullClientAppInputsRequest,
+    PullClientAppInputsResponse,
+    PushClientAppOutputsRequest,
+    PushClientAppOutputsResponse,
+)
+from flwr.proto.clientappio_pb2_grpc import ClientAppIoStub
+
+from .utils import get_load_client_app_fn
+
+
+def on_channel_state_change(channel_connectivity: str) -> None:
+    """Log channel connectivity."""
+    log(DEBUG, channel_connectivity)
+
+
+def run_clientapp(  # pylint: disable=R0914
+    supernode: str,
+    token: int,
+) -> None:
+    """Run Flower ClientApp process.
+
+    Parameters
+    ----------
+    supernode : str
+        Address of SuperNode
+    token : int
+        Unique SuperNode token for ClientApp-SuperNode authentication
+    """
+    channel = create_channel(
+        server_address=supernode,
+        insecure=True,
+    )
+    channel.subscribe(on_channel_state_change)
+
+    try:
+        stub = ClientAppIoStub(channel)
+
+        # Pull Message, Context, and Run from SuperNode
+        message, context, run = pull_message(stub=stub, token=token)
+
+        load_client_app_fn = get_load_client_app_fn(
+            default_app_ref="",
+            app_path=None,
+            multi_app=True,
+            flwr_dir=None,
+        )
+
+        try:
+            # Load ClientApp
+            client_app: ClientApp = load_client_app_fn(run.fab_id, run.fab_version)
+
+            # Execute ClientApp
+            reply_message = client_app(message=message, context=context)
+        except Exception as ex:  # pylint: disable=broad-exception-caught
+            # Don't update/change NodeState
+
+            e_code = ErrorCode.CLIENT_APP_RAISED_EXCEPTION
+            # Ex fmt: "<class 'ZeroDivisionError'>:<'division by zero'>"
+            reason = str(type(ex)) + ":<'" + str(ex) + "'>"
+            exc_entity = "ClientApp"
+            if isinstance(ex, LoadClientAppError):
+                reason = "An exception was raised when attempting to load `ClientApp`"
+                e_code = ErrorCode.LOAD_CLIENT_APP_EXCEPTION
+
+            log(ERROR, "%s raised an exception", exc_entity, exc_info=ex)
+
+            # Create error message
+            reply_message = message.create_error_reply(
+                error=Error(code=e_code, reason=reason)
+            )
+
+        # Push Message and Context to SuperNode
+        _ = push_message(stub=stub, token=token, message=reply_message, context=context)
+
+    except KeyboardInterrupt:
+        log(INFO, "Closing connection")
+    except grpc.RpcError as e:
+        log(ERROR, "GRPC error occurred: %s", str(e))
+    finally:
+        channel.close()
+
+
+def pull_message(stub: grpc.Channel, token: int) -> Tuple[Message, Context, Run]:
+    """Pull message from SuperNode to ClientApp."""
+    res: PullClientAppInputsResponse = stub.PullClientAppInputs(
+        PullClientAppInputsRequest(token=token)
+    )
+    message = message_from_proto(res.message)
+    context = context_from_proto(res.context)
+    run = run_from_proto(res.run)
+    return message, context, run
+
+
+def push_message(
+    stub: grpc.Channel, token: int, message: Message, context: Context
+) -> PushClientAppOutputsResponse:
+    """Push message to SuperNode from ClientApp."""
+    proto_message = message_to_proto(message)
+    proto_context = context_to_proto(context)
+    res: PushClientAppOutputsResponse = stub.PushClientAppOutputs(
+        PushClientAppOutputsRequest(
+            token=token, message=proto_message, context=proto_context
+        )
+    )
+    return res

flwr/client/process/utils.py

@@ -0,0 +1,108 @@
+# 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 ClientApp loading utils."""
+
+from logging import DEBUG
+from pathlib import Path
+from typing import Callable, Optional
+
+from flwr.client.client_app import ClientApp, LoadClientAppError
+from flwr.common.config import (
+    get_flwr_dir,
+    get_metadata_from_config,
+    get_project_config,
+    get_project_dir,
+)
+from flwr.common.logger import log
+from flwr.common.object_ref import load_app, validate
+
+
+def get_load_client_app_fn(
+    default_app_ref: str,
+    app_path: Optional[str],
+    multi_app: bool,
+    flwr_dir: Optional[str] = None,
+) -> Callable[[str, str], ClientApp]:
+    """Get the load_client_app_fn function.
+
+    If `multi_app` is True, this function loads the specified ClientApp
+    based on `fab_id` and `fab_version`. If `fab_id` is empty, a default
+    ClientApp will be loaded.
+
+    If `multi_app` is False, it ignores `fab_id` and `fab_version` and
+    loads a default ClientApp.
+    """
+    if not multi_app:
+        log(
+            DEBUG,
+            "Flower SuperNode will load and validate ClientApp `%s`",
+            default_app_ref,
+        )
+
+        valid, error_msg = validate(default_app_ref, project_dir=app_path)
+        if not valid and error_msg:
+            raise LoadClientAppError(error_msg) from None
+
+    def _load(fab_id: str, fab_version: str) -> ClientApp:
+        runtime_app_dir = Path(app_path if app_path else "").absolute()
+        # If multi-app feature is disabled
+        if not multi_app:
+            # Set app reference
+            client_app_ref = default_app_ref
+        # If multi-app feature is enabled but app directory is provided
+        elif app_path is not None:
+            config = get_project_config(runtime_app_dir)
+            this_fab_version, this_fab_id = get_metadata_from_config(config)
+
+            if this_fab_version != fab_version or this_fab_id != fab_id:
+                raise LoadClientAppError(
+                    f"FAB ID or version mismatch: Expected FAB ID '{this_fab_id}' and "
+                    f"FAB version '{this_fab_version}', but received FAB ID '{fab_id}' "
+                    f"and FAB version '{fab_version}'.",
+                ) from None
+
+            # log(WARN, "FAB ID is not provided; the default ClientApp will be loaded.")
+
+            # Set app reference
+            client_app_ref = config["tool"]["flwr"]["app"]["components"]["clientapp"]
+        # If multi-app feature is enabled
+        else:
+            try:
+                runtime_app_dir = get_project_dir(
+                    fab_id, fab_version, get_flwr_dir(flwr_dir)
+                )
+                config = get_project_config(runtime_app_dir)
+            except Exception as e:
+                raise LoadClientAppError("Failed to load ClientApp") from e
+
+            # Set app reference
+            client_app_ref = config["tool"]["flwr"]["app"]["components"]["clientapp"]
+
+        # Load ClientApp
+        log(
+            DEBUG,
+            "Loading ClientApp `%s`",
+            client_app_ref,
+        )
+        client_app = load_app(client_app_ref, LoadClientAppError, runtime_app_dir)
+
+        if not isinstance(client_app, ClientApp):
+            raise LoadClientAppError(
+                f"Attribute {client_app_ref} is not of type {ClientApp}",
+            ) from None
+
+        return client_app
+
+    return _load

flwr/client/rest_client/connection.py

@@ -46,6 +46,7 @@ from flwr.common.serde import (
     user_config_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,
     CreateNodeResponse,
@@ -74,6 +75,7 @@ PATH_PULL_TASK_INS: str = "api/v0/fleet/pull-task-ins"
 PATH_PUSH_TASK_RES: str = "api/v0/fleet/push-task-res"
 PATH_PING: str = "api/v0/fleet/ping"
 PATH_GET_RUN: str = "/api/v0/fleet/get-run"
+PATH_GET_FAB: str = "/api/v0/fleet/get-fab"
 
 T = TypeVar("T", bound=GrpcMessage)
 
@@ -369,8 +371,18 @@ def http_request_response(  # pylint: disable=,R0913, R0914, R0915
         )
 
     def get_fab(fab_hash: str) -> Fab:
-        # Call FleetAPI
-        raise NotImplementedError
+        # Construct the request
+        req = GetFabRequest(hash_str=fab_hash)
+
+        # Send the request
+        res = _request(req, GetFabResponse, PATH_GET_FAB)
+        if res is None:
+            return Fab("", b"")
+
+        return Fab(
+            res.fab.hash_str,
+            res.fab.content,
+        )
 
     try:
         # Yield methods