flwr-nightly 1.11.0.dev20240811__tar.gz → 1.11.0.dev20240821__tar.gz

{flwr_nightly-1.11.0.dev20240811 → flwr_nightly-1.11.0.dev20240821}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: flwr-nightly
-Version: 1.11.0.dev20240811
+Version: 1.11.0.dev20240821
 Summary: Flower: A Friendly Federated Learning Framework
 Home-page: https://flower.ai
 License: Apache-2.0
@@ -212,7 +212,7 @@ Other [examples](https://github.com/adap/flower/tree/main/examples):
 Flower is built by a wonderful community of researchers and engineers. [Join Slack](https://flower.ai/join-slack) to meet them, [contributions](#contributing-to-flower) are welcome.
 
 <a href="https://github.com/adap/flower/graphs/contributors">
-  <img src="https://contrib.rocks/image?repo=adap/flower" />
+  <img src="https://contrib.rocks/image?repo=adap/flower&columns=10" />
 </a>
 
 ## Citation

{flwr_nightly-1.11.0.dev20240811 → flwr_nightly-1.11.0.dev20240821}/README.md

@@ -160,7 +160,7 @@ Other [examples](https://github.com/adap/flower/tree/main/examples):
 Flower is built by a wonderful community of researchers and engineers. [Join Slack](https://flower.ai/join-slack) to meet them, [contributions](#contributing-to-flower) are welcome.
 
 <a href="https://github.com/adap/flower/graphs/contributors">
-  <img src="https://contrib.rocks/image?repo=adap/flower" />
+  <img src="https://contrib.rocks/image?repo=adap/flower&columns=10" />
 </a>
 
 ## Citation

{flwr_nightly-1.11.0.dev20240811 → flwr_nightly-1.11.0.dev20240821}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "flwr-nightly"
-version = "1.11.0.dev20240811"
+version = "1.11.0.dev20240821"
 description = "Flower: A Friendly Federated Learning Framework"
 license = "Apache-2.0"
 authors = ["The Flower Authors <hello@flower.ai>"]
@@ -59,6 +59,7 @@ flower-supernode = "flwr.client:run_supernode"
 flower-client-app = "flwr.client:run_client_app"
 flower-server-app = "flwr.server:run_server_app"
 flower-simulation = "flwr.simulation.run_simulation:run_simulation_from_cli"
+flwr-clientapp = "flwr.client.clientapp:flwr_clientapp"
 
 [tool.poetry.dependencies]
 python = "^3.8"

{flwr_nightly-1.11.0.dev20240811 → flwr_nightly-1.11.0.dev20240821}/src/py/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_nightly-1.11.0.dev20240811 → flwr_nightly-1.11.0.dev20240821}/src/py/flwr/cli/install.py

@@ -173,7 +173,9 @@ def validate_and_install(
         / project_name
         / version
     )
-    if install_dir.exists() and not skip_prompt:
+    if install_dir.exists():
+        if skip_prompt:
+            return install_dir
         if not typer.confirm(
             typer.style(
                 f"\n💬 {project_name} version {version} is already installed, "

{flwr_nightly-1.11.0.dev20240811 → flwr_nightly-1.11.0.dev20240821}/src/py/flwr/cli/run/run.py

@@ -14,6 +14,7 @@
 # ==============================================================================
 """Flower command line interface `run` command."""
 
+import hashlib
 import subprocess
 import sys
 from logging import DEBUG
@@ -28,11 +29,17 @@ from flwr.cli.config_utils import load_and_validate
 from flwr.common.config import flatten_dict, parse_config_args
 from flwr.common.grpc import GRPC_MAX_MESSAGE_LENGTH, create_channel
 from flwr.common.logger import log
-from flwr.common.serde import user_config_to_proto
+from flwr.common.serde import fab_to_proto, user_config_to_proto
+from flwr.common.typing import Fab
 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[
@@ -49,7 +56,8 @@ def run(
             "--run-config",
             "-c",
             help="Override configuration key-value pairs, should be of the format:\n\n"
-            "`--run-config key1=value1,key2=value2 --run-config key3=value3`\n\n"
+            '`--run-config \'key1="value1" key2="value2"\' '
+            "--run-config 'key3=\"value3\"'`\n\n"
             "Note that `key1`, `key2`, and `key3` in this example need to exist "
             "inside the `pyproject.toml` in order to be properly overriden.",
         ),
@@ -120,10 +128,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()
@@ -163,12 +167,12 @@ def _run_with_superexec(
     stub = ExecStub(channel)
 
     fab_path = Path(build(app))
+    content = fab_path.read_bytes()
+    fab = Fab(hashlib.sha256(content).hexdigest(), content)
 
     req = StartRunRequest(
-        fab_file=fab_path.read_bytes(),
-        override_config=user_config_to_proto(
-            parse_config_args(config_overrides, separator=",")
-        ),
+        fab=fab_to_proto(fab),
+        override_config=user_config_to_proto(parse_config_args(config_overrides)),
         federation_config=user_config_to_proto(
             flatten_dict(federation_config.get("options"))
         ),
@@ -209,7 +213,7 @@ def _run_without_superexec(
     ]
 
     if config_overrides:
-        command.extend(["--run-config", f"{','.join(config_overrides)}"])
+        command.extend(["--run-config", f"{' '.join(config_overrides)}"])
 
     # Run the simulation
     subprocess.run(

{flwr_nightly-1.11.0.dev20240811 → flwr_nightly-1.11.0.dev20240821}/src/py/flwr/client/app.py

@@ -15,16 +15,20 @@
 """Flower client app."""
 
 import signal
+import subprocess
 import sys
 import time
 from dataclasses import dataclass
 from logging import ERROR, INFO, WARN
 from pathlib import Path
-from typing import Callable, ContextManager, Dict, Optional, Tuple, Type, Union
+from typing import Callable, ContextManager, Dict, Optional, Tuple, Type, Union, cast
 
+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,
@@ -42,8 +47,12 @@ from flwr.common.constant import (
 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 Run, UserConfig
+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 .clientapp.clientappio_servicer import ClientAppInputs, ClientAppIoServicer
 from .grpc_adapter_client.connection import grpc_adapter
 from .grpc_client.connection import grpc_connection
 from .grpc_rere_client.connection import grpc_request_response
@@ -51,6 +60,11 @@ from .message_handler.message_handler import handle_control_message
 from .node_state import NodeState
 from .numpy_client import NumPyClient
 
+ADDRESS_CLIENTAPPIO_API_GRPC_RERE = "0.0.0.0:9094"
+
+ISOLATION_MODE_SUBPROCESS = "subprocess"
+ISOLATION_MODE_PROCESS = "process"
+
 
 def _check_actionable_client(
     client: Optional[Client], client_fn: Optional[ClientFnExt]
@@ -158,7 +172,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 +193,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 +210,8 @@ def _start_client_internal(
     max_retries: Optional[int] = None,
     max_wait_time: Optional[float] = None,
     flwr_path: Optional[Path] = None,
+    isolation: Optional[str] = None,
+    supernode_address: Optional[str] = ADDRESS_CLIENTAPPIO_API_GRPC_RERE,
 ) -> None:
     """Start a Flower client node which connects to a Flower server.
 
@@ -243,6 +259,15 @@ 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.
+    isolation : Optional[str] (default: None)
+        Isolation mode for `ClientApp`. Possible values are `subprocess` and
+        `process`. Defaults to `None`, which runs the `ClientApp` in the same process
+        as the SuperNode. If `subprocess`, the `ClientApp` runs in a subprocess started
+        by the SueprNode and communicates using gRPC at the address
+        `supernode_address`. If `process`, the `ClientApp` runs in a separate 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 +293,17 @@ def _start_client_internal(
 
         load_client_app_fn = _load_client_app
 
+    if isolation:
+        if supernode_address is None:
+            raise ValueError(
+                f"`supernode_address` required when `isolation` is "
+                f"{ISOLATION_MODE_SUBPROCESS} or {ISOLATION_MODE_PROCESS}",
+            )
+        _clientappio_grpc_server, clientappio_servicer = run_clientappio_api_grpc(
+            address=supernode_address
+        )
+    supernode_address = cast(str, 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 +369,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:
@@ -362,6 +398,7 @@ def _start_client_internal(
                     )
 
             app_state_tracker.register_signal_handler()
+            # pylint: disable=too-many-nested-blocks
             while not app_state_tracker.interrupt:
                 try:
                     # Receive
@@ -398,16 +435,31 @@ def _start_client_internal(
                             runs[run_id] = get_run(run_id)
                         # If get_run is None, i.e., in grpc-bidi mode
                         else:
-                            runs[run_id] = Run(run_id, "", "", {})
+                            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)
+                        if not isolation:
+                            # If `ClientApp` runs in the same process, install the FAB
+                            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,
+                        fab=fab,
                     )
 
                     # Retrieve context for this run
                     context = node_state.retrieve_context(run_id=run_id)
-
                     # Create an error reply message that will never be used to prevent
                     # the used-before-assignment linting error
                     reply_message = message.create_error_reply(
@@ -416,14 +468,62 @@ 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 isolation:
+                            # Two isolation modes:
+                            # 1. `subprocess`: SuperNode is starting the ClientApp
+                            #    process as a subprocess.
+                            # 2. `process`: ClientApp process gets started separately
+                            #    (via `flwr-clientapp`), for example, in a separate
+                            #    Docker container.
+
+                            # Generate SuperNode token
+                            token: int = generate_rand_int_from_bytes(RUN_ID_NUM_BYTES)
+
+                            # Mode 1: SuperNode starts ClientApp as subprocess
+                            start_subprocess = isolation == ISOLATION_MODE_SUBPROCESS
+
+                            # Share Message and Context with servicer
+                            clientappio_servicer.set_inputs(
+                                clientapp_input=ClientAppInputs(
+                                    message=message,
+                                    context=context,
+                                    run=run,
+                                    fab=fab,
+                                    token=token,
+                                ),
+                                token_returned=start_subprocess,
+                            )
+
+                            if start_subprocess:
+                                # Start ClientApp subprocess
+                                command = [
+                                    "flwr-clientapp",
+                                    "--supernode",
+                                    supernode_address,
+                                    "--token",
+                                    str(token),
+                                ]
+                                subprocess.run(
+                                    command,
+                                    stdout=None,
+                                    stderr=None,
+                                    check=True,
+                                )
+                            else:
+                                # Wait for output to become available
+                                while not clientappio_servicer.has_outputs():
+                                    time.sleep(0.1)
+
+                            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)
+                            # Execute ClientApp
+                            reply_message = client_app(message=message, context=context)
                     except Exception as ex:  # pylint: disable=broad-exception-caught
 
                         # Legacy grpc-bidi
@@ -469,6 +569,7 @@ def _start_client_internal(
                 except StopIteration:
                     sleep_duration = 0
                     break
+            # pylint: enable=too-many-nested-blocks
 
             # Unregister node
             if delete_node is not None and app_state_tracker.is_connected:
@@ -606,6 +707,7 @@ def _init_connection(transport: Optional[str], server_address: str) -> Tuple[
                 Optional[Callable[[], Optional[int]]],
                 Optional[Callable[[], None]],
                 Optional[Callable[[int], Run]],
+                Optional[Callable[[str], Fab]],
             ]
         ],
     ],
@@ -666,3 +768,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_nightly-1.11.0.dev20240821/src/py/flwr/client/clientapp/__init__.py

@@ -0,0 +1,22 @@
+# 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 AppIO service."""
+
+
+from .app import flwr_clientapp as flwr_clientapp
+
+__all__ = [
+    "flwr_clientapp",
+]

flwr_nightly-1.11.0.dev20240821/src/py/flwr/client/clientapp/app.py

@@ -0,0 +1,233 @@
+# 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."""
+
+import argparse
+import time
+from logging import DEBUG, ERROR, INFO
+from typing import Optional, Tuple
+
+import grpc
+
+from flwr.cli.install import install_from_fab
+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,
+    fab_from_proto,
+    message_from_proto,
+    message_to_proto,
+    run_from_proto,
+)
+from flwr.common.typing import Fab, Run
+
+# pylint: disable=E0611
+from flwr.proto.clientappio_pb2 import (
+    GetTokenRequest,
+    GetTokenResponse,
+    PullClientAppInputsRequest,
+    PullClientAppInputsResponse,
+    PushClientAppOutputsRequest,
+    PushClientAppOutputsResponse,
+)
+from flwr.proto.clientappio_pb2_grpc import ClientAppIoStub
+
+from .utils import get_load_client_app_fn
+
+
+def flwr_clientapp() -> None:
+    """Run process-isolated Flower ClientApp."""
+    log(INFO, "Starting Flower ClientApp")
+
+    parser = argparse.ArgumentParser(
+        description="Run a Flower ClientApp",
+    )
+    parser.add_argument(
+        "--supernode",
+        type=str,
+        help="Address of SuperNode ClientAppIo gRPC servicer",
+    )
+    parser.add_argument(
+        "--token",
+        type=int,
+        required=False,
+        help="Unique token generated by SuperNode for each ClientApp execution",
+    )
+    args = parser.parse_args()
+
+    log(
+        DEBUG,
+        "Staring isolated `ClientApp` connected to SuperNode ClientAppIo at %s "
+        "with token %s",
+        args.supernode,
+        args.token,
+    )
+    run_clientapp(supernode=args.supernode, token=args.token)
+
+
+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: Optional[int] = None,
+) -> None:
+    """Run Flower ClientApp process.
+
+    Parameters
+    ----------
+    supernode : str
+        Address of SuperNode
+    token : Optional[int] (default: None)
+        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)
+
+        only_once = token is not None
+        while True:
+            # If token is not set, loop until token is received from SuperNode
+            while token is None:
+                token = get_token(stub)
+                time.sleep(1)
+
+            # Pull Message, Context, Run and (optional) FAB from SuperNode
+            message, context, run, fab = pull_message(stub=stub, token=token)
+
+            # Install FAB, if provided
+            if fab:
+                log(DEBUG, "Flower ClientApp starts FAB installation.")
+                install_from_fab(fab.content, flwr_dir=None, skip_prompt=True)
+
+            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
+            )
+
+            # Reset token to `None` to prevent flwr-clientapp from trying to pull the
+            # same inputs again
+            token = None
+
+            # Stop the loop if `flwr-clientapp` is expected to process only a single
+            # message
+            if only_once:
+                break
+
+    except KeyboardInterrupt:
+        log(INFO, "Closing connection")
+    except grpc.RpcError as e:
+        log(ERROR, "GRPC error occurred: %s", str(e))
+    finally:
+        channel.close()
+
+
+def get_token(stub: grpc.Channel) -> Optional[int]:
+    """Get a token from SuperNode."""
+    log(DEBUG, "Flower ClientApp process requests token")
+    try:
+        res: GetTokenResponse = stub.GetToken(GetTokenRequest())
+        log(DEBUG, "[GetToken] Received token: %s", res.token)
+        return res.token
+    except grpc.RpcError as e:
+        if e.code() == grpc.StatusCode.FAILED_PRECONDITION:  # pylint: disable=no-member
+            log(DEBUG, "[GetToken] No token available yet")
+        else:
+            log(ERROR, "[GetToken] gRPC error occurred: %s", str(e))
+        return None
+
+
+def pull_message(
+    stub: grpc.Channel, token: int
+) -> Tuple[Message, Context, Run, Optional[Fab]]:
+    """Pull message from SuperNode to ClientApp."""
+    log(INFO, "Pulling ClientAppInputs for token %s", token)
+    try:
+        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)
+        fab = fab_from_proto(res.fab) if res.fab else None
+        return message, context, run, fab
+    except grpc.RpcError as e:
+        log(ERROR, "[PullClientAppInputs] gRPC error occurred: %s", str(e))
+        raise e
+
+
+def push_message(
+    stub: grpc.Channel, token: int, message: Message, context: Context
+) -> PushClientAppOutputsResponse:
+    """Push message to SuperNode from ClientApp."""
+    log(INFO, "Pushing ClientAppOutputs for token %s", token)
+    proto_message = message_to_proto(message)
+    proto_context = context_to_proto(context)
+
+    try:
+        res: PushClientAppOutputsResponse = stub.PushClientAppOutputs(
+            PushClientAppOutputsRequest(
+                token=token, message=proto_message, context=proto_context
+            )
+        )
+        return res
+    except grpc.RpcError as e:
+        log(ERROR, "[PushClientAppOutputs] gRPC error occurred: %s", str(e))
+        raise e