flwr-nightly 1.11.0.dev20240811__py3-none-any.whl → 1.11.0.dev20240821__py3-none-any.whl

flwr/client/clientapp/clientappio_servicer.py

@@ -0,0 +1,244 @@
+# 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.
+# ==============================================================================
+"""ClientAppIo API servicer."""
+
+
+from dataclasses import dataclass
+from logging import DEBUG, ERROR
+from typing import Optional, cast
+
+import grpc
+
+from flwr.common import Context, Message, typing
+from flwr.common.logger import log
+from flwr.common.serde import (
+    clientappstatus_to_proto,
+    context_from_proto,
+    context_to_proto,
+    fab_to_proto,
+    message_from_proto,
+    message_to_proto,
+    run_to_proto,
+)
+from flwr.common.typing import Fab, Run
+
+# pylint: disable=E0611
+from flwr.proto import clientappio_pb2_grpc
+from flwr.proto.clientappio_pb2 import (  # pylint: disable=E0401
+    GetTokenRequest,
+    GetTokenResponse,
+    PullClientAppInputsRequest,
+    PullClientAppInputsResponse,
+    PushClientAppOutputsRequest,
+    PushClientAppOutputsResponse,
+)
+
+
+@dataclass
+class ClientAppInputs:
+    """Specify the inputs to the ClientApp."""
+
+    message: Message
+    context: Context
+    run: Run
+    fab: Optional[Fab]
+    token: int
+
+
+@dataclass
+class ClientAppOutputs:
+    """Specify the outputs from the ClientApp."""
+
+    message: Message
+    context: Context
+
+
+# pylint: disable=C0103,W0613,W0201
+class ClientAppIoServicer(clientappio_pb2_grpc.ClientAppIoServicer):
+    """ClientAppIo API servicer."""
+
+    def __init__(self) -> None:
+        self.clientapp_input: Optional[ClientAppInputs] = None
+        self.clientapp_output: Optional[ClientAppOutputs] = None
+        self.token_returned: bool = False
+        self.inputs_returned: bool = False
+
+    def GetToken(
+        self, request: GetTokenRequest, context: grpc.ServicerContext
+    ) -> GetTokenResponse:
+        """Get token."""
+        log(DEBUG, "ClientAppIo.GetToken")
+
+        # Fail if no ClientAppInputs are available
+        if self.clientapp_input is None:
+            context.abort(
+                grpc.StatusCode.FAILED_PRECONDITION,
+                "No inputs available.",
+            )
+        clientapp_input = cast(ClientAppInputs, self.clientapp_input)
+
+        # Fail if token was already returned in a previous call
+        if self.token_returned:
+            context.abort(
+                grpc.StatusCode.FAILED_PRECONDITION,
+                "Token already returned. A token can be returned only once.",
+            )
+
+        # If
+        # - ClientAppInputs is set, and
+        # - token hasn't been returned before,
+        # return token
+        self.token_returned = True
+        return GetTokenResponse(token=clientapp_input.token)
+
+    def PullClientAppInputs(
+        self, request: PullClientAppInputsRequest, context: grpc.ServicerContext
+    ) -> PullClientAppInputsResponse:
+        """Pull Message, Context, and Run."""
+        log(DEBUG, "ClientAppIo.PullClientAppInputs")
+
+        # Fail if no ClientAppInputs are available
+        if self.clientapp_input is None:
+            context.abort(
+                grpc.StatusCode.FAILED_PRECONDITION,
+                "No inputs available.",
+            )
+        clientapp_input = cast(ClientAppInputs, self.clientapp_input)
+
+        # Fail if token wasn't returned in a previous call
+        if not self.token_returned:
+            context.abort(
+                grpc.StatusCode.FAILED_PRECONDITION,
+                "Token hasn't been returned."
+                "Token must be returned before can be returned only once.",
+            )
+
+        # Fail if token isn't matching
+        if request.token != clientapp_input.token:
+            context.abort(
+                grpc.StatusCode.INVALID_ARGUMENT,
+                "Mismatch between ClientApp and SuperNode token",
+            )
+
+        # Success
+        self.inputs_returned = True
+        return PullClientAppInputsResponse(
+            message=message_to_proto(clientapp_input.message),
+            context=context_to_proto(clientapp_input.context),
+            run=run_to_proto(clientapp_input.run),
+            fab=fab_to_proto(clientapp_input.fab) if clientapp_input.fab else None,
+        )
+
+    def PushClientAppOutputs(
+        self, request: PushClientAppOutputsRequest, context: grpc.ServicerContext
+    ) -> PushClientAppOutputsResponse:
+        """Push Message and Context."""
+        log(DEBUG, "ClientAppIo.PushClientAppOutputs")
+
+        # Fail if no ClientAppInputs are available
+        if not self.clientapp_input:
+            context.abort(
+                grpc.StatusCode.FAILED_PRECONDITION,
+                "No inputs available.",
+            )
+        clientapp_input = cast(ClientAppInputs, self.clientapp_input)
+
+        # Fail if token wasn't returned in a previous call
+        if not self.token_returned:
+            context.abort(
+                grpc.StatusCode.FAILED_PRECONDITION,
+                "Token hasn't been returned."
+                "Token must be returned before can be returned only once.",
+            )
+
+        # Fail if inputs weren't delivered in a previous call
+        if not self.inputs_returned:
+            context.abort(
+                grpc.StatusCode.FAILED_PRECONDITION,
+                "Inputs haven't been delivered."
+                "Inputs must be delivered before can be returned only once.",
+            )
+
+        # Fail if token isn't matching
+        if request.token != clientapp_input.token:
+            context.abort(
+                grpc.StatusCode.INVALID_ARGUMENT,
+                "Mismatch between ClientApp and SuperNode token",
+            )
+
+        # Preconditions met
+        try:
+            # Update Message and Context
+            self.clientapp_output = ClientAppOutputs(
+                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")
+        except Exception as e:  # pylint: disable=broad-exception-caught
+            log(ERROR, "ClientApp failed to push message to SuperNode, %s", e)
+            code = typing.ClientAppOutputCode.UNKNOWN_ERROR
+            status = typing.ClientAppOutputStatus(code=code, message="Unkonwn error")
+
+        # Return status to ClientApp process
+        proto_status = clientappstatus_to_proto(status=status)
+        return PushClientAppOutputsResponse(status=proto_status)
+
+    def set_inputs(
+        self, clientapp_input: ClientAppInputs, token_returned: bool
+    ) -> None:
+        """Set ClientApp inputs.
+
+        Parameters
+        ----------
+        clientapp_input : ClientAppInputs
+            The inputs to the ClientApp.
+        token_returned : bool
+            A boolean indicating if the token has been returned.
+            Set to `True` when passing the token to `flwr-clientap`
+            and `False` otherwise.
+        """
+        if (
+            self.clientapp_input is not None
+            or self.clientapp_output is not None
+            or self.token_returned
+        ):
+            raise ValueError(
+                "ClientAppInputs and ClientAppOutputs must not be set before "
+                "calling `set_inputs`."
+            )
+        log(DEBUG, "ClientAppInputs set (token: %s)", clientapp_input.token)
+        self.clientapp_input = clientapp_input
+        self.token_returned = token_returned
+
+    def has_outputs(self) -> bool:
+        """Check if ClientAppOutputs are available."""
+        return self.clientapp_output is not None
+
+    def get_outputs(self) -> ClientAppOutputs:
+        """Get ClientApp outputs."""
+        if self.clientapp_output is None:
+            raise ValueError("ClientAppOutputs not set before calling `get_outputs`.")
+
+        # Set outputs to a local variable and clear state
+        output: ClientAppOutputs = self.clientapp_output
+        self.clientapp_input = None
+        self.clientapp_output = None
+        self.token_returned = False
+        self.inputs_returned = False
+
+        return output

flwr/client/clientapp/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/grpc_adapter_client/connection.py

@@ -27,7 +27,7 @@ from flwr.common import GRPC_MAX_MESSAGE_LENGTH
 from flwr.common.logger import log
 from flwr.common.message import Message
 from flwr.common.retry_invoker import RetryInvoker
-from flwr.common.typing import Run
+from flwr.common.typing import Fab, Run
 
 
 @contextmanager
@@ -47,6 +47,7 @@ def grpc_adapter(  # pylint: disable=R0913
         Optional[Callable[[], Optional[int]]],
         Optional[Callable[[], None]],
         Optional[Callable[[int], Run]],
+        Optional[Callable[[str], Fab]],
     ]
 ]:
     """Primitives for request/response-based interaction with a server via GrpcAdapter.
@@ -80,6 +81,7 @@ def grpc_adapter(  # pylint: disable=R0913
     create_node : Optional[Callable]
     delete_node : Optional[Callable]
     get_run : Optional[Callable]
+    get_fab : Optional[Callable]
     """
     if authentication_keys is not None:
         log(ERROR, "Client authentication is not supported for this transport type.")

flwr/client/grpc_client/connection.py

@@ -38,7 +38,7 @@ from flwr.common.constant import MessageType, MessageTypeLegacy
 from flwr.common.grpc import create_channel
 from flwr.common.logger import log
 from flwr.common.retry_invoker import RetryInvoker
-from flwr.common.typing import Run
+from flwr.common.typing import Fab, Run
 from flwr.proto.transport_pb2 import (  # pylint: disable=E0611
     ClientMessage,
     Reason,
@@ -75,6 +75,7 @@ def grpc_connection(  # pylint: disable=R0913, R0915
         Optional[Callable[[], Optional[int]]],
         Optional[Callable[[], None]],
         Optional[Callable[[int], Run]],
+        Optional[Callable[[str], Fab]],
     ]
 ]:
     """Establish a gRPC connection to a gRPC server.
@@ -235,7 +236,7 @@ def grpc_connection(  # pylint: disable=R0913, R0915
 
     try:
         # Yield methods
-        yield (receive, send, None, None, None)
+        yield (receive, send, None, None, None, None)
     finally:
         # Make sure to have a final
         channel.close()

flwr/client/grpc_rere_client/connection.py

@@ -45,7 +45,8 @@ from flwr.common.serde import (
     message_to_taskres,
     user_config_from_proto,
 )
-from flwr.common.typing import Run
+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,
@@ -86,6 +87,7 @@ def grpc_request_response(  # pylint: disable=R0913, R0914, R0915
         Optional[Callable[[], Optional[int]]],
         Optional[Callable[[], None]],
         Optional[Callable[[int], Run]],
+        Optional[Callable[[str], Fab]],
     ]
 ]:
     """Primitives for request/response-based interaction with a server.
@@ -285,11 +287,22 @@ def grpc_request_response(  # pylint: disable=R0913, R0914, R0915
             run_id,
             get_run_response.run.fab_id,
             get_run_response.run.fab_version,
+            get_run_response.run.fab_hash,
             user_config_from_proto(get_run_response.run.override_config),
         )
 
+    def get_fab(fab_hash: str) -> Fab:
+        # Call FleetAPI
+        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
-        yield (receive, send, create_node, delete_node, get_run)
+        yield (receive, send, create_node, delete_node, get_run, get_fab)
     except Exception as exc:  # pylint: disable=broad-except
         log(ERROR, exc)

flwr/client/node_state.py

@@ -20,8 +20,12 @@ from pathlib import Path
 from typing import Dict, Optional
 
 from flwr.common import Context, RecordSet
-from flwr.common.config import get_fused_config, get_fused_config_from_dir
-from flwr.common.typing import Run, UserConfig
+from flwr.common.config import (
+    get_fused_config,
+    get_fused_config_from_dir,
+    get_fused_config_from_fab,
+)
+from flwr.common.typing import Fab, Run, UserConfig
 
 
 @dataclass()
@@ -44,12 +48,14 @@ class NodeState:
         self.node_config = node_config
         self.run_infos: Dict[int, RunInfo] = {}
 
+    # pylint: disable=too-many-arguments
     def register_context(
         self,
         run_id: int,
         run: Optional[Run] = None,
         flwr_path: Optional[Path] = None,
         app_dir: Optional[str] = None,
+        fab: Optional[Fab] = None,
     ) -> None:
         """Register new run context for this node."""
         if run_id not in self.run_infos:
@@ -65,8 +71,15 @@ class NodeState:
                 else:
                     raise ValueError("The specified `app_dir` must be a directory.")
             else:
-                # Load from .fab
-                initial_run_config = get_fused_config(run, flwr_path) if run else {}
+                if run:
+                    if fab:
+                        # Load pyproject.toml from FAB file and fuse
+                        initial_run_config = get_fused_config_from_fab(fab.content, run)
+                    else:
+                        # Load pyproject.toml from installed FAB and fuse
+                        initial_run_config = get_fused_config(run, flwr_path)
+                else:
+                    initial_run_config = {}
             self.run_infos[run_id] = RunInfo(
                 initial_run_config=initial_run_config,
                 context=Context(

flwr/client/rest_client/connection.py

@@ -45,7 +45,8 @@ from flwr.common.serde import (
     message_to_taskres,
     user_config_from_proto,
 )
-from flwr.common.typing import Run
+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)
 
@@ -97,6 +99,7 @@ def http_request_response(  # pylint: disable=,R0913, R0914, R0915
         Optional[Callable[[], Optional[int]]],
         Optional[Callable[[], None]],
         Optional[Callable[[int], Run]],
+        Optional[Callable[[str], Fab]],
     ]
 ]:
     """Primitives for request/response-based interaction with a server.
@@ -357,17 +360,32 @@ def http_request_response(  # pylint: disable=,R0913, R0914, R0915
         # Send the request
         res = _request(req, GetRunResponse, PATH_GET_RUN)
         if res is None:
-            return Run(run_id, "", "", {})
+            return Run(run_id, "", "", "", {})
 
         return Run(
             run_id,
             res.run.fab_id,
             res.run.fab_version,
+            res.run.fab_hash,
             user_config_from_proto(res.run.override_config),
         )
 
+    def get_fab(fab_hash: str) -> Fab:
+        # 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
-        yield (receive, send, create_node, delete_node, get_run)
+        yield (receive, send, create_node, delete_node, get_run, get_fab)
     except Exception as exc:  # pylint: disable=broad-except
         log(ERROR, exc)