flwr-nightly 1.19.0.dev20250526__py3-none-any.whl → 1.19.0.dev20250528__py3-none-any.whl

flwr/cli/log.py

@@ -35,7 +35,7 @@ from flwr.common.logger import log as logger
 from flwr.proto.exec_pb2 import StreamLogsRequest  # pylint: disable=E0611
 from flwr.proto.exec_pb2_grpc import ExecStub
 
-from .utils import init_channel, try_obtain_cli_auth_plugin, unauthenticated_exc_handler
+from .utils import flwr_cli_grpc_exc_handler, init_channel, try_obtain_cli_auth_plugin
 
 
 class AllLogsRetrieved(BaseException):
@@ -95,7 +95,7 @@ def stream_logs(
     latest_timestamp = 0.0
     res = None
     try:
-        with unauthenticated_exc_handler():
+        with flwr_cli_grpc_exc_handler():
             for res in stub.StreamLogs(req, timeout=duration):
                 print(res.log_output, end="")
         raise AllLogsRetrieved()
@@ -116,7 +116,7 @@ def print_logs(run_id: int, channel: grpc.Channel, timeout: int) -> None:
     req = StreamLogsRequest(run_id=run_id, after_timestamp=0.0)
 
     try:
-        with unauthenticated_exc_handler():
+        with flwr_cli_grpc_exc_handler():
             # Enforce timeout for graceful exit
             for res in stub.StreamLogs(req, timeout=timeout):
                 print(res.log_output)

flwr/cli/login/login.py

@@ -35,11 +35,7 @@ from flwr.proto.exec_pb2 import (  # pylint: disable=E0611
 )
 from flwr.proto.exec_pb2_grpc import ExecStub
 
-from ..utils import (
-    init_channel,
-    try_obtain_cli_auth_plugin,
-    unauthenticated_exc_handler,
-)
+from ..utils import flwr_cli_grpc_exc_handler, init_channel, try_obtain_cli_auth_plugin
 
 
 def login(  # pylint: disable=R0914
@@ -96,7 +92,7 @@ def login(  # pylint: disable=R0914
     stub = ExecStub(channel)
 
     login_request = GetLoginDetailsRequest()
-    with unauthenticated_exc_handler():
+    with flwr_cli_grpc_exc_handler():
         login_response: GetLoginDetailsResponse = stub.GetLoginDetails(login_request)
 
     # Get the auth plugin
@@ -120,7 +116,7 @@ def login(  # pylint: disable=R0914
         expires_in=login_response.expires_in,
         interval=login_response.interval,
     )
-    with unauthenticated_exc_handler():
+    with flwr_cli_grpc_exc_handler():
         credentials = auth_plugin.login(details, stub)
 
     # Store the tokens

flwr/cli/ls.py

@@ -44,7 +44,7 @@ from flwr.proto.exec_pb2 import (  # pylint: disable=E0611
 )
 from flwr.proto.exec_pb2_grpc import ExecStub
 
-from .utils import init_channel, try_obtain_cli_auth_plugin, unauthenticated_exc_handler
+from .utils import flwr_cli_grpc_exc_handler, init_channel, try_obtain_cli_auth_plugin
 
 _RunListType = tuple[int, str, str, str, str, str, str, str, str]
 
@@ -305,7 +305,7 @@ def _list_runs(
     output_format: str = CliOutputFormat.DEFAULT,
 ) -> None:
     """List all runs."""
-    with unauthenticated_exc_handler():
+    with flwr_cli_grpc_exc_handler():
         res: ListRunsResponse = stub.ListRuns(ListRunsRequest())
     run_dict = {run_id: run_from_proto(proto) for run_id, proto in res.run_dict.items()}
 
@@ -322,7 +322,7 @@ def _display_one_run(
     output_format: str = CliOutputFormat.DEFAULT,
 ) -> None:
     """Display information about a specific run."""
-    with unauthenticated_exc_handler():
+    with flwr_cli_grpc_exc_handler():
         res: ListRunsResponse = stub.ListRuns(ListRunsRequest(run_id=run_id))
     if not res.run_dict:
         raise ValueError(f"Run ID {run_id} not found")

flwr/cli/run/run.py

@@ -45,11 +45,7 @@ from flwr.proto.exec_pb2 import StartRunRequest  # pylint: disable=E0611
 from flwr.proto.exec_pb2_grpc import ExecStub
 
 from ..log import start_stream
-from ..utils import (
-    init_channel,
-    try_obtain_cli_auth_plugin,
-    unauthenticated_exc_handler,
-)
+from ..utils import flwr_cli_grpc_exc_handler, init_channel, try_obtain_cli_auth_plugin
 
 CONN_REFRESH_PERIOD = 60  # Connection refresh period for log streaming (seconds)
 
@@ -172,7 +168,7 @@ def _run_with_exec_api(
         override_config=user_config_to_proto(parse_config_args(config_overrides)),
         federation_options=config_record_to_proto(c_record),
     )
-    with unauthenticated_exc_handler():
+    with flwr_cli_grpc_exc_handler():
         res = stub.StartRun(req)
 
     if res.HasField("run_id"):

flwr/cli/stop.py

@@ -35,7 +35,7 @@ from flwr.common.logger import print_json_error, redirect_output, restore_output
 from flwr.proto.exec_pb2 import StopRunRequest, StopRunResponse  # pylint: disable=E0611
 from flwr.proto.exec_pb2_grpc import ExecStub
 
-from .utils import init_channel, try_obtain_cli_auth_plugin, unauthenticated_exc_handler
+from .utils import flwr_cli_grpc_exc_handler, init_channel, try_obtain_cli_auth_plugin
 
 
 def stop(  # pylint: disable=R0914
@@ -122,7 +122,7 @@ def stop(  # pylint: disable=R0914
 
 def _stop_run(stub: ExecStub, run_id: int, output_format: str) -> None:
     """Stop a run."""
-    with unauthenticated_exc_handler():
+    with flwr_cli_grpc_exc_handler():
         response: StopRunResponse = stub.StopRun(request=StopRunRequest(run_id=run_id))
     if response.success:
         typer.secho(f"✅ Run {run_id} successfully stopped.", fg=typer.colors.GREEN)

flwr/cli/utils.py

@@ -288,11 +288,12 @@ def init_channel(
 
 
 @contextmanager
-def unauthenticated_exc_handler() -> Iterator[None]:
-    """Context manager to handle gRPC UNAUTHENTICATED errors.
+def flwr_cli_grpc_exc_handler() -> Iterator[None]:
+    """Context manager to handle specific gRPC errors.
 
-    It catches grpc.RpcError exceptions with UNAUTHENTICATED status, informs the user,
-    and exits the application. All other exceptions will be allowed to escape.
+    It catches grpc.RpcError exceptions with UNAUTHENTICATED and UNIMPLEMENTED statuses,
+    informs the user, and exits the application. All other exceptions will be allowed to
+    escape.
     """
     try:
         yield

flwr/client/grpc_rere_client/connection.py

@@ -279,6 +279,8 @@ def grpc_request_response(  # pylint: disable=R0913,R0914,R0915,R0917
             log(ERROR, "No current message")
             return
 
+        # Set message_id
+        message.metadata.__dict__["_message_id"] = message.object_id
         # Validate out message
         if not validate_out_message(message, metadata):
             log(ERROR, "Invalid out message")

flwr/client/message_handler/message_handler.py

@@ -164,7 +164,7 @@ def validate_out_message(out_message: Message, in_message_metadata: Metadata) ->
     in_meta = in_message_metadata
     if (  # pylint: disable-next=too-many-boolean-expressions
         out_meta.run_id == in_meta.run_id
-        and out_meta.message_id == ""  # This will be generated by the server
+        and out_meta.message_id == out_message.object_id  # Should match the object id
         and out_meta.src_node_id == in_meta.dst_node_id
         and out_meta.dst_node_id == in_meta.src_node_id
         and out_meta.reply_to_message_id == in_meta.message_id

flwr/common/auth_plugin/__init__.py

@@ -17,8 +17,10 @@
 
 from .auth_plugin import CliAuthPlugin as CliAuthPlugin
 from .auth_plugin import ExecAuthPlugin as ExecAuthPlugin
+from .auth_plugin import ExecAuthzPlugin as ExecAuthzPlugin
 
 __all__ = [
     "CliAuthPlugin",
     "ExecAuthPlugin",
+    "ExecAuthzPlugin",
 ]

flwr/common/auth_plugin/auth_plugin.py

@@ -64,6 +64,24 @@ class ExecAuthPlugin(ABC):
         """Refresh authentication tokens in the provided metadata."""
 
 
+class ExecAuthzPlugin(ABC):  # pylint: disable=too-few-public-methods
+    """Abstract Flower Authorization Plugin class for ExecServicer.
+
+    Parameters
+    ----------
+    user_authz_config_path : Path
+        Path to the YAML file containing the authorization configuration.
+    """
+
+    @abstractmethod
+    def __init__(self, user_authz_config_path: Path, verify_tls_cert: bool):
+        """Abstract constructor."""
+
+    @abstractmethod
+    def verify_user_authorization(self, user_info: UserInfo) -> bool:
+        """Verify user authorization request."""
+
+
 class CliAuthPlugin(ABC):
     """Abstract Flower Auth Plugin class for CLI.
 

flwr/common/constant.py

@@ -115,6 +115,9 @@ AUTH_TYPE_YAML_KEY = "auth_type"  # For key name in YAML file
 ACCESS_TOKEN_KEY = "flwr-oidc-access-token"
 REFRESH_TOKEN_KEY = "flwr-oidc-refresh-token"
 
+# Constants for user authorization
+AUTHZ_TYPE_YAML_KEY = "authz_type"  # For key name in YAML file
+
 # Constants for node authentication
 PUBLIC_KEY_HEADER = "flwr-public-key-bin"  # Must end with "-bin" for binary data
 SIGNATURE_HEADER = "flwr-signature-bin"  # Must end with "-bin" for binary data

flwr/common/inflatable.py

@@ -18,7 +18,7 @@
 from __future__ import annotations
 
 import hashlib
-from typing import TypeVar
+from typing import TypeVar, cast
 
 from .constant import HEAD_BODY_DIVIDER, HEAD_VALUE_DIVIDER
 
@@ -55,13 +55,24 @@ class InflatableObject:
     @property
     def object_id(self) -> str:
         """Get object_id."""
-        return get_object_id(self.deflate())
+        if self.is_dirty or "_object_id" not in self.__dict__:
+            self.__dict__["_object_id"] = get_object_id(self.deflate())
+        return cast(str, self.__dict__["_object_id"])
 
     @property
     def children(self) -> dict[str, InflatableObject] | None:
         """Get all child objects as a dictionary or None if there are no children."""
         return None
 
+    @property
+    def is_dirty(self) -> bool:
+        """Check if the object is dirty after the last deflation.
+
+        An object is considered dirty if its content has changed since the last its
+        object ID was computed.
+        """
+        return True
+
 
 T = TypeVar("T", bound=InflatableObject)
 
@@ -178,3 +189,23 @@ def get_object_head_values_from_object_content(
     obj_type, children_str, body_len = head.split(HEAD_VALUE_DIVIDER)
     children_ids = children_str.split(",") if children_str else []
     return obj_type, children_ids, int(body_len)
+
+
+def _get_descendants_object_ids_recursively(obj: InflatableObject) -> set[str]:
+
+    descendants: set[str] = set()
+    if children := obj.children:
+        for child in children.values():
+            descendants |= _get_descendants_object_ids_recursively(child)
+
+    descendants.add(obj.object_id)
+
+    return descendants
+
+
+def get_desdendant_object_ids(obj: InflatableObject) -> set[str]:
+    """Get a set of object IDs of all descendants."""
+    descendants = _get_descendants_object_ids_recursively(obj)
+    # Exclude Object ID of parent object
+    descendants.discard(obj.object_id)
+    return descendants

flwr/common/message.py

@@ -23,6 +23,7 @@ from typing import Any, cast, overload
 from flwr.common.date import now
 from flwr.common.logger import warn_deprecated_feature
 from flwr.proto.message_pb2 import Message as ProtoMessage  # pylint: disable=E0611
+from flwr.proto.message_pb2 import Metadata as ProtoMetadata  # pylint: disable=E0611
 
 from ..app.error import Error
 from ..app.metadata import Metadata
@@ -351,9 +352,12 @@ class Message(InflatableObject):
 
     def deflate(self) -> bytes:
         """Deflate message."""
+        # Exclude message_id from serialization
+        proto_metadata: ProtoMetadata = metadata_to_proto(self.metadata)
+        proto_metadata.message_id = ""
         # Store message metadata and error in object body
         obj_body = ProtoMessage(
-            metadata=metadata_to_proto(self.metadata),
+            metadata=proto_metadata,
             content=None,
             error=error_to_proto(self.error) if self.has_error() else None,
         ).SerializeToString(deterministic=True)

flwr/common/record/array.py

@@ -107,10 +107,21 @@ class Array(InflatableObject):
     """
 
     dtype: str
-    shape: list[int]
     stype: str
     data: bytes
 
+    @property
+    def shape(self) -> list[int]:
+        """Get the shape of the array."""
+        self.is_dirty = True  # Mark as dirty when shape is accessed
+        return cast(list[int], self.__dict__["_shape"])
+
+    @shape.setter
+    def shape(self, value: list[int]) -> None:
+        """Set the shape of the array."""
+        self.is_dirty = True  # Mark as dirty when shape is set
+        self.__dict__["_shape"] = value
+
     @overload
     def __init__(  # noqa: E704
         self, dtype: str, shape: list[int], stype: str, data: bytes
@@ -295,3 +306,29 @@ class Array(InflatableObject):
             stype=proto_array.stype,
             data=proto_array.data,
         )
+
+    @property
+    def object_id(self) -> str:
+        """Get object ID."""
+        ret = super().object_id
+        self.is_dirty = False  # Reset dirty flag
+        return ret
+
+    @property
+    def is_dirty(self) -> bool:
+        """Check if the object is dirty after the last deflation."""
+        if "_is_dirty" not in self.__dict__:
+            self.__dict__["_is_dirty"] = True
+        return cast(bool, self.__dict__["_is_dirty"])
+
+    @is_dirty.setter
+    def is_dirty(self, value: bool) -> None:
+        """Set the dirty flag."""
+        self.__dict__["_is_dirty"] = value
+
+    def __setattr__(self, name: str, value: Any) -> None:
+        """Set attribute with special handling for dirty state."""
+        if name in ("dtype", "stype", "data"):
+            # Mark as dirty if any of the main attributes are set
+            self.is_dirty = True
+        super().__setattr__(name, value)

flwr/common/record/arrayrecord.py

@@ -429,6 +429,40 @@ class ArrayRecord(TypedDict[str, Array], InflatableObject):
             )
         )
 
+    @property
+    def object_id(self) -> str:
+        """Get object ID."""
+        ret = super().object_id
+        self.is_dirty = False  # Reset dirty flag
+        return ret
+
+    @property
+    def is_dirty(self) -> bool:
+        """Check if the object is dirty after the last deflation."""
+        if "_is_dirty" not in self.__dict__:
+            self.__dict__["_is_dirty"] = True
+
+        if not self.__dict__["_is_dirty"]:
+            if any(v.is_dirty for v in self.values()):
+                # If any Array is dirty, mark the record as dirty
+                self.__dict__["_is_dirty"] = True
+        return cast(bool, self.__dict__["_is_dirty"])
+
+    @is_dirty.setter
+    def is_dirty(self, value: bool) -> None:
+        """Set the dirty flag."""
+        self.__dict__["_is_dirty"] = value
+
+    def __setitem__(self, key: str, value: Array) -> None:
+        """Set item and mark the record as dirty."""
+        self.is_dirty = True  # Mark as dirty when setting an item
+        super().__setitem__(key, value)
+
+    def __delitem__(self, key: str) -> None:
+        """Delete item and mark the record as dirty."""
+        self.is_dirty = True  # Mark as dirty when deleting an item
+        super().__delitem__(key)
+
 
 class ParametersRecord(ArrayRecord):
     """Deprecated class ``ParametersRecord``, use ``ArrayRecord`` instead.

flwr/common/serde.py

@@ -378,7 +378,12 @@ def scalar_from_proto(scalar_msg: Scalar) -> typing.Scalar:
 
 def array_to_proto(array: Array) -> ProtoArray:
     """Serialize Array to ProtoBuf."""
-    return ProtoArray(**vars(array))
+    return ProtoArray(
+        dtype=array.dtype,
+        shape=array.shape,
+        stype=array.stype,
+        data=array.data,
+    )
 
 
 def array_from_proto(array_proto: ProtoArray) -> Array:

flwr/compat/client/app.py

@@ -15,18 +15,12 @@
 """Flower client app."""
 
 
-import multiprocessing
-import os
-import sys
-import threading
 import time
 from contextlib import AbstractContextManager
 from logging import ERROR, INFO, WARN
-from os import urandom
 from pathlib import Path
-from typing import Callable, Optional, Union, cast
+from typing import Callable, Optional, Union
 
-import grpc
 from cryptography.hazmat.primitives.asymmetric import ec
 from grpc import RpcError
 
@@ -35,11 +29,6 @@ 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.clientapp.app import flwr_clientapp
-from flwr.client.clientapp.clientappio_servicer import (
-    ClientAppInputs,
-    ClientAppIoServicer,
-)
 from flwr.client.grpc_adapter_client.connection import grpc_adapter
 from flwr.client.grpc_rere_client.connection import grpc_request_response
 from flwr.client.message_handler.message_handler import handle_control_message
@@ -49,13 +38,7 @@ from flwr.client.typing import ClientFnExt
 from flwr.common import GRPC_MAX_MESSAGE_LENGTH, Context, EventType, Message, event
 from flwr.common.address import parse_address
 from flwr.common.constant import (
-    CLIENT_OCTET,
-    CLIENTAPPIO_API_DEFAULT_SERVER_ADDRESS,
-    ISOLATION_MODE_PROCESS,
-    ISOLATION_MODE_SUBPROCESS,
     MAX_RETRY_DELAY,
-    RUN_ID_NUM_BYTES,
-    SERVER_OCTET,
     TRANSPORT_TYPE_GRPC_ADAPTER,
     TRANSPORT_TYPE_GRPC_BIDI,
     TRANSPORT_TYPE_GRPC_RERE,
@@ -64,12 +47,10 @@ from flwr.common.constant import (
     ErrorCode,
 )
 from flwr.common.exit import ExitCode, flwr_exit
-from flwr.common.grpc import generic_create_grpc_server
 from flwr.common.logger import log, warn_deprecated_feature
 from flwr.common.retry_invoker import RetryInvoker, RetryState, exponential
 from flwr.common.typing import Fab, Run, RunNotRunningException, UserConfig
 from flwr.compat.client.grpc_client.connection import grpc_connection
-from flwr.proto.clientappio_pb2_grpc import add_ClientAppIoServicer_to_server
 from flwr.supernode.nodestate import NodeStateFactory
 
 
@@ -238,8 +219,6 @@ def start_client_internal(
     max_retries: Optional[int] = None,
     max_wait_time: Optional[float] = None,
     flwr_path: Optional[Path] = None,
-    isolation: Optional[str] = None,
-    clientappio_api_address: Optional[str] = CLIENTAPPIO_API_DEFAULT_SERVER_ADDRESS,
 ) -> None:
     """Start a Flower client node which connects to a Flower server.
 
@@ -292,17 +271,6 @@ 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
-        `clientappio_api_address`. If `process`, the `ClientApp` runs in a separate
-        isolated process and communicates using gRPC at the address
-        `clientappio_api_address`.
-    clientappio_api_address : Optional[str]
-        (default: `CLIENTAPPIO_API_DEFAULT_SERVER_ADDRESS`)
-        The SuperNode gRPC server address.
     """
     if insecure is None:
         insecure = root_certificates is None
@@ -328,18 +296,6 @@ def start_client_internal(
 
         load_client_app_fn = _load_client_app
 
-    if isolation:
-        if clientappio_api_address is None:
-            raise ValueError(
-                f"`clientappio_api_address` required when `isolation` is "
-                f"{ISOLATION_MODE_SUBPROCESS} or {ISOLATION_MODE_PROCESS}",
-            )
-        _clientappio_grpc_server, clientappio_servicer = run_clientappio_api_grpc(
-            address=clientappio_api_address,
-            certificates=None,
-        )
-    clientappio_api_address = cast(str, clientappio_api_address)
-
     # At this point, only `load_client_app_fn` should be used
     # Both `client` and `client_fn` must not be used directly
 
@@ -390,7 +346,6 @@ def start_client_internal(
     run_info_store: Optional[DeprecatedRunInfoStore] = None
     state_factory = NodeStateFactory()
     state = state_factory.state()
-    mp_spawn_context = multiprocessing.get_context("spawn")
 
     runs: dict[int, Run] = {}
 
@@ -475,9 +430,8 @@ def start_client_internal(
                     run: Run = runs[run_id]
                     if get_fab is not None and run.fab_hash:
                         fab = get_fab(run.fab_hash, run_id)
-                        if not isolation:
-                            # If `ClientApp` runs in the same process, install the FAB
-                            install_from_fab(fab.content, flwr_path, True)
+                        # 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
@@ -504,73 +458,13 @@ def start_client_internal(
 
                     # Handle app loading and task message
                     try:
-                        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.from_bytes(urandom(RUN_ID_NUM_BYTES), "little")
-
-                            # 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:
-                                _octet, _colon, _port = (
-                                    clientappio_api_address.rpartition(":")
-                                )
-                                io_address = (
-                                    f"{CLIENT_OCTET}:{_port}"
-                                    if _octet == SERVER_OCTET
-                                    else clientappio_api_address
-                                )
-                                # Start ClientApp subprocess
-                                command = [
-                                    "flwr-clientapp",
-                                    "--clientappio-api-address",
-                                    io_address,
-                                    "--token",
-                                    str(token),
-                                ]
-                                command.append("--insecure")
-
-                                proc = mp_spawn_context.Process(
-                                    target=_run_flwr_clientapp,
-                                    args=(command, os.getpid()),
-                                    daemon=True,
-                                )
-                                proc.start()
-                                proc.join()
-                            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, run.fab_hash
-                            )
+                        # Load ClientApp instance
+                        client_app: ClientApp = load_client_app_fn(
+                            fab_id, fab_version, run.fab_hash
+                        )
 
-                            # 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
@@ -801,39 +695,3 @@ def _init_connection(transport: Optional[str], server_address: str) -> tuple[
         )
 
     return connection, address, error_type
-
-
-def _run_flwr_clientapp(args: list[str], main_pid: int) -> None:
-    # Monitor the main process in case of SIGKILL
-    def main_process_monitor() -> None:
-        while True:
-            time.sleep(1)
-            if os.getppid() != main_pid:
-                os.kill(os.getpid(), 9)
-
-    threading.Thread(target=main_process_monitor, daemon=True).start()
-
-    # Run the command
-    sys.argv = args
-    flwr_clientapp()
-
-
-def run_clientappio_api_grpc(
-    address: str,
-    certificates: Optional[tuple[bytes, bytes, bytes]],
-) -> 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,
-        certificates=certificates,
-    )
-    log(INFO, "Starting Flower ClientAppIo gRPC server on %s", address)
-    clientappio_grpc_server.start()
-    return clientappio_grpc_server, clientappio_servicer