flwr-nightly 1.13.0.dev20241111__tar.gz → 1.13.0.dev20241117__tar.gz

{flwr_nightly-1.13.0.dev20241111 → flwr_nightly-1.13.0.dev20241117}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: flwr-nightly
-Version: 1.13.0.dev20241111
-Summary: Flower: A Friendly Federated Learning Framework
+Version: 1.13.0.dev20241117
+Summary: Flower: A Friendly Federated AI Framework
 Home-page: https://flower.ai
 License: Apache-2.0
 Keywords: Artificial Intelligence,Federated AI,Federated Analytics,Federated Evaluation,Federated Learning,Flower,Machine Learning
@@ -34,6 +34,7 @@ Provides-Extra: rest
 Provides-Extra: simulation
 Requires-Dist: cryptography (>=42.0.4,<43.0.0)
 Requires-Dist: grpcio (>=1.60.0,<2.0.0,!=1.64.2,<=1.64.3)
+Requires-Dist: hatchling (>=1.25.0,<2.0.0)
 Requires-Dist: iterators (>=0.0.2,<0.0.3)
 Requires-Dist: numpy (>=1.26.0,<3.0.0)
 Requires-Dist: pathspec (>=0.12.1,<0.13.0)
@@ -41,6 +42,7 @@ Requires-Dist: protobuf (>=4.25.2,<5.0.0)
 Requires-Dist: pycryptodome (>=3.18.0,<4.0.0)
 Requires-Dist: ray (==2.10.0) ; (python_version >= "3.9" and python_version < "3.12") and (extra == "simulation")
 Requires-Dist: requests (>=2.31.0,<3.0.0) ; extra == "rest"
+Requires-Dist: rich (>=13.5.0,<14.0.0)
 Requires-Dist: starlette (>=0.31.0,<0.32.0) ; extra == "rest"
 Requires-Dist: tomli (>=2.0.1,<3.0.0)
 Requires-Dist: tomli-w (>=1.0.0,<2.0.0)
@@ -50,7 +52,7 @@ Project-URL: Documentation, https://flower.ai
 Project-URL: Repository, https://github.com/adap/flower
 Description-Content-Type: text/markdown
 
-# Flower: A Friendly Federated Learning Framework
+# Flower: A Friendly Federated AI Framework
 
 <p align="center">
   <a href="https://flower.ai/">
@@ -73,7 +75,7 @@ Description-Content-Type: text/markdown
 [![Docker Hub](https://img.shields.io/badge/Docker%20Hub-flwr-blue)](https://hub.docker.com/u/flwr)
 [![Slack](https://img.shields.io/badge/Chat-Slack-red)](https://flower.ai/join-slack)
 
-Flower (`flwr`) is a framework for building federated learning systems. The
+Flower (`flwr`) is a framework for building federated AI systems. The
 design of Flower is based on a few guiding principles:
 
 - **Customizable**: Federated learning systems vary wildly from one use case to

{flwr_nightly-1.13.0.dev20241111 → flwr_nightly-1.13.0.dev20241117}/README.md

@@ -1,4 +1,4 @@
-# Flower: A Friendly Federated Learning Framework
+# Flower: A Friendly Federated AI Framework
 
 <p align="center">
   <a href="https://flower.ai/">
@@ -21,7 +21,7 @@
 [![Docker Hub](https://img.shields.io/badge/Docker%20Hub-flwr-blue)](https://hub.docker.com/u/flwr)
 [![Slack](https://img.shields.io/badge/Chat-Slack-red)](https://flower.ai/join-slack)
 
-Flower (`flwr`) is a framework for building federated learning systems. The
+Flower (`flwr`) is a framework for building federated AI systems. The
 design of Flower is based on a few guiding principles:
 
 - **Customizable**: Federated learning systems vary wildly from one use case to

{flwr_nightly-1.13.0.dev20241111 → flwr_nightly-1.13.0.dev20241117}/pyproject.toml

@@ -4,8 +4,8 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "flwr-nightly"
-version = "1.13.0.dev20241111"
-description = "Flower: A Friendly Federated Learning Framework"
+version = "1.13.0.dev20241117"
+description = "Flower: A Friendly Federated AI Framework"
 license = "Apache-2.0"
 authors = ["The Flower Authors <hello@flower.ai>"]
 readme = "README.md"
@@ -77,6 +77,8 @@ typer = "^0.12.5"
 tomli = "^2.0.1"
 tomli-w = "^1.0.0"
 pathspec = "^0.12.1"
+hatchling = "^1.25.0"
+rich = "^13.5.0"
 # Optional dependencies (Simulation Engine)
 ray = { version = "==2.10.0", optional = true, python = ">=3.9,<3.12" }
 # Optional dependencies (REST transport layer)

{flwr_nightly-1.13.0.dev20241111 → flwr_nightly-1.13.0.dev20241117}/src/py/flwr/cli/app.py

@@ -20,6 +20,7 @@ from typer.main import get_command
 from .build import build
 from .install import install
 from .log import log
+from .ls import ls
 from .new import new
 from .run import run
 
@@ -37,6 +38,7 @@ app.command()(run)
 app.command()(build)
 app.command()(install)
 app.command()(log)
+app.command()(ls)
 
 typer_click_object = get_command(app)
 

{flwr_nightly-1.13.0.dev20241111 → flwr_nightly-1.13.0.dev20241117}/src/py/flwr/cli/build.py

@@ -19,14 +19,18 @@ import os
 import shutil
 import tempfile
 import zipfile
+from logging import DEBUG, ERROR
 from pathlib import Path
 from typing import Annotated, Any, Optional, Union
 
 import pathspec
 import tomli_w
 import typer
+from hatchling.builders.wheel import WheelBuilder
+from hatchling.metadata.core import ProjectMetadata
 
 from flwr.common.constant import FAB_ALLOWED_EXTENSIONS, FAB_DATE, FAB_HASH_TRUNCATION
+from flwr.common.logger import log
 
 from .config_utils import load_and_validate
 from .utils import is_valid_project_name
@@ -51,6 +55,27 @@ def get_fab_filename(conf: dict[str, Any], fab_hash: str) -> str:
     return f"{publisher}.{name}.{version}.{fab_hash_truncated}.fab"
 
 
+def _build_app_wheel(app: Path) -> Path:
+    """Build app as a wheel and return its path."""
+    # Path to your project directory
+    app_dir = str(app.resolve())
+    try:
+
+        # Initialize the WheelBuilder
+        builder = WheelBuilder(
+            app_dir, metadata=ProjectMetadata(root=app_dir, plugin_manager=None)
+        )
+
+        # Build
+        whl_path = Path(next(builder.build(directory=app_dir)))
+        log(DEBUG, "Wheel succesfully built: %s", str(whl_path))
+    except Exception as ex:
+        log(ERROR, "Exception encountered when building wheel.", exc_info=ex)
+        raise typer.Exit(code=1) from ex
+
+    return whl_path
+
+
 # pylint: disable=too-many-locals, too-many-statements
 def build(
     app: Annotated[
@@ -106,6 +131,12 @@ def build(
             bold=True,
         )
 
+    # Build wheel
+    whl_path = _build_app_wheel(app)
+
+    # Add path to .whl to `[tool.flwr.app]`
+    conf["tool"]["flwr"]["app"]["whl"] = str(whl_path.name)
+
     # Load .gitignore rules if present
     ignore_spec = _load_gitignore(app)
 
@@ -137,6 +168,9 @@ def build(
                 and f.name != "pyproject.toml"  # Exclude the original pyproject.toml
             ]
 
+            # Include FAB .whl
+            all_files.append(whl_path)
+
             for file_path in all_files:
                 # Read the file content manually
                 with open(file_path, "rb") as f:
@@ -153,6 +187,9 @@ def build(
             # Add CONTENT and CONTENT.jwt to the zip file
             write_to_zip(fab_file, ".info/CONTENT", list_file_content)
 
+    # Erase FAB .whl in app directory
+    whl_path.unlink()
+
     # Get hash of FAB file
     content = Path(temp_filename).read_bytes()
     fab_hash = hashlib.sha256(content).hexdigest()

{flwr_nightly-1.13.0.dev20241111 → flwr_nightly-1.13.0.dev20241117}/src/py/flwr/cli/install.py

@@ -188,23 +188,25 @@ def validate_and_install(
         else:
             shutil.copy2(item, install_dir / item.name)
 
+    whl_file = config["tool"]["flwr"]["app"]["whl"]
+    install_whl = install_dir / whl_file
     try:
         subprocess.run(
-            ["pip", "install", "-e", install_dir, "--no-deps"],
+            ["pip", "install", "--no-deps", install_whl],
             capture_output=True,
             text=True,
             check=True,
         )
     except subprocess.CalledProcessError as e:
         typer.secho(
-            f"❌ Failed to `pip install` package(s) from {install_dir}:\n{e.stderr}",
+            f"❌ Failed to install {project_name}:\n{e.stderr}",
             fg=typer.colors.RED,
             bold=True,
         )
         raise typer.Exit(code=1) from e
 
     typer.secho(
-        f"🎊 Successfully installed {project_name} to {install_dir}.",
+        f"🎊 Successfully installed {project_name}.",
         fg=typer.colors.GREEN,
         bold=True,
     )

flwr_nightly-1.13.0.dev20241117/src/py/flwr/cli/ls.py

@@ -0,0 +1,228 @@
+# 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 command line interface `ls` command."""
+
+
+from datetime import datetime, timedelta
+from logging import DEBUG
+from pathlib import Path
+from typing import Annotated, Any, Optional
+
+import grpc
+import typer
+from rich.console import Console
+from rich.table import Table
+from rich.text import Text
+
+from flwr.cli.config_utils import (
+    load_and_validate,
+    validate_certificate_in_federation_config,
+    validate_federation_in_project_config,
+    validate_project_config,
+)
+from flwr.common.constant import FAB_CONFIG_FILE, SubStatus
+from flwr.common.date import format_timedelta, isoformat8601_utc
+from flwr.common.grpc import GRPC_MAX_MESSAGE_LENGTH, create_channel
+from flwr.common.logger import log
+from flwr.common.serde import run_from_proto
+from flwr.common.typing import Run
+from flwr.proto.exec_pb2 import (  # pylint: disable=E0611
+    ListRunsRequest,
+    ListRunsResponse,
+)
+from flwr.proto.exec_pb2_grpc import ExecStub
+
+
+def ls(
+    app: Annotated[
+        Path,
+        typer.Argument(help="Path of the Flower project"),
+    ] = Path("."),
+    federation: Annotated[
+        Optional[str],
+        typer.Argument(help="Name of the federation"),
+    ] = None,
+    runs: Annotated[
+        bool,
+        typer.Option(
+            "--runs",
+            help="List all runs",
+        ),
+    ] = False,
+    run_id: Annotated[
+        Optional[int],
+        typer.Option(
+            "--run-id",
+            help="Specific run ID to display",
+        ),
+    ] = None,
+) -> None:
+    """List runs."""
+    # Load and validate federation config
+    typer.secho("Loading project configuration... ", fg=typer.colors.BLUE)
+
+    pyproject_path = app / FAB_CONFIG_FILE if app else None
+    config, errors, warnings = load_and_validate(path=pyproject_path)
+    config = validate_project_config(config, errors, warnings)
+    federation, federation_config = validate_federation_in_project_config(
+        federation, config
+    )
+
+    if "address" not in federation_config:
+        typer.secho(
+            "❌ `flwr log` currently works with Exec API. Ensure that the correct"
+            "Exec API address is provided in the `pyproject.toml`.",
+            fg=typer.colors.RED,
+            bold=True,
+        )
+        raise typer.Exit(code=1)
+
+    try:
+        if runs and run_id is not None:
+            raise ValueError(
+                "The options '--runs' and '--run-id' are mutually exclusive."
+            )
+
+        channel = _init_channel(app, federation_config)
+        stub = ExecStub(channel)
+
+        # Display information about a specific run ID
+        if run_id is not None:
+            typer.echo(f"🔍 Displaying information for run ID {run_id}...")
+            _display_one_run(stub, run_id)
+        # By default, list all runs
+        else:
+            typer.echo("📄 Listing all runs...")
+            _list_runs(stub)
+
+    except ValueError as err:
+        typer.secho(
+            f"❌ {err}",
+            fg=typer.colors.RED,
+            bold=True,
+        )
+        raise typer.Exit(code=1) from err
+    finally:
+        channel.close()
+
+
+def on_channel_state_change(channel_connectivity: str) -> None:
+    """Log channel connectivity."""
+    log(DEBUG, channel_connectivity)
+
+
+def _init_channel(app: Path, federation_config: dict[str, Any]) -> grpc.Channel:
+    """Initialize gRPC channel to the Exec API."""
+    insecure, root_certificates_bytes = validate_certificate_in_federation_config(
+        app, federation_config
+    )
+    channel = create_channel(
+        server_address=federation_config["address"],
+        insecure=insecure,
+        root_certificates=root_certificates_bytes,
+        max_message_length=GRPC_MAX_MESSAGE_LENGTH,
+        interceptors=None,
+    )
+    channel.subscribe(on_channel_state_change)
+    return channel
+
+
+def _format_run_table(run_dict: dict[int, Run], now_isoformat: str) -> Table:
+    """Format run status as a rich Table."""
+    table = Table(header_style="bold cyan", show_lines=True)
+
+    def _format_datetime(dt: Optional[datetime]) -> str:
+        return isoformat8601_utc(dt).replace("T", " ") if dt else "N/A"
+
+    # Add columns
+    table.add_column(
+        Text("Run ID", justify="center"), style="bright_white", overflow="fold"
+    )
+    table.add_column(Text("FAB", justify="center"), style="dim white")
+    table.add_column(Text("Status", justify="center"))
+    table.add_column(Text("Elapsed", justify="center"), style="blue")
+    table.add_column(Text("Created At", justify="center"), style="dim white")
+    table.add_column(Text("Running At", justify="center"), style="dim white")
+    table.add_column(Text("Finished At", justify="center"), style="dim white")
+
+    # Add rows
+    for run in sorted(
+        run_dict.values(), key=lambda x: datetime.fromisoformat(x.pending_at)
+    ):
+        # Combine status and sub-status into a single string
+        if run.status.sub_status == "":
+            status_text = run.status.status
+        else:
+            status_text = f"{run.status.status}:{run.status.sub_status}"
+
+        # Style the status based on its value
+        sub_status = run.status.sub_status
+        if sub_status == SubStatus.COMPLETED:
+            status_style = "green"
+        elif sub_status == SubStatus.FAILED:
+            status_style = "red"
+        else:
+            status_style = "yellow"
+
+        # Convert isoformat to datetime
+        pending_at = datetime.fromisoformat(run.pending_at) if run.pending_at else None
+        running_at = datetime.fromisoformat(run.running_at) if run.running_at else None
+        finished_at = (
+            datetime.fromisoformat(run.finished_at) if run.finished_at else None
+        )
+
+        # Calculate elapsed time
+        elapsed_time = timedelta()
+        if running_at:
+            if finished_at:
+                end_time = finished_at
+            else:
+                end_time = datetime.fromisoformat(now_isoformat)
+            elapsed_time = end_time - running_at
+
+        table.add_row(
+            f"[bold]{run.run_id}[/bold]",
+            f"{run.fab_id} (v{run.fab_version})",
+            f"[{status_style}]{status_text}[/{status_style}]",
+            format_timedelta(elapsed_time),
+            _format_datetime(pending_at),
+            _format_datetime(running_at),
+            _format_datetime(finished_at),
+        )
+    return table
+
+
+def _list_runs(
+    stub: ExecStub,
+) -> None:
+    """List all runs."""
+    res: ListRunsResponse = stub.ListRuns(ListRunsRequest())
+    run_dict = {run_id: run_from_proto(proto) for run_id, proto in res.run_dict.items()}
+
+    Console().print(_format_run_table(run_dict, res.now))
+
+
+def _display_one_run(
+    stub: ExecStub,
+    run_id: int,
+) -> None:
+    """Display information about a specific run."""
+    res: ListRunsResponse = stub.ListRuns(ListRunsRequest(run_id=run_id))
+    if not res.run_dict:
+        raise ValueError(f"Run ID {run_id} not found")
+
+    run_dict = {run_id: run_from_proto(proto) for run_id, proto in res.run_dict.items()}
+
+    Console().print(_format_run_table(run_dict, res.now))

{flwr_nightly-1.13.0.dev20241111 → flwr_nightly-1.13.0.dev20241117}/src/py/flwr/client/app.py

@@ -37,11 +37,13 @@ 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 (
-    CLIENTAPPIO_API_DEFAULT_ADDRESS,
+    CLIENT_OCTET,
+    CLIENTAPPIO_API_DEFAULT_SERVER_ADDRESS,
     ISOLATION_MODE_PROCESS,
     ISOLATION_MODE_SUBPROCESS,
     MISSING_EXTRA_REST,
     RUN_ID_NUM_BYTES,
+    SERVER_OCTET,
     TRANSPORT_TYPE_GRPC_ADAPTER,
     TRANSPORT_TYPE_GRPC_BIDI,
     TRANSPORT_TYPE_GRPC_RERE,
@@ -102,6 +104,11 @@ def start_client(
 ) -> None:
     """Start a Flower client node which connects to a Flower server.
 
+    Warning
+    -------
+    This function is deprecated since 1.13.0. Use :code:`flower-supernode` command
+    instead to start a SuperNode.
+
     Parameters
     ----------
     server_address : str
@@ -176,6 +183,17 @@ def start_client(
     >>>     root_certificates=Path("/crts/root.pem").read_bytes(),
     >>> )
     """
+    msg = (
+        "flwr.client.start_client() is deprecated."
+        "\n\tInstead, use the `flower-supernode` CLI command to start a SuperNode "
+        "as shown below:"
+        "\n\n\t\t$ flower-supernode --insecure --superlink='<IP>:<PORT>'"
+        "\n\n\tTo view all available options, run:"
+        "\n\n\t\t$ flower-supernode --help"
+        "\n\n\tUsing `start_client()` is deprecated."
+    )
+    warn_deprecated_feature(name=msg)
+
     event(EventType.START_CLIENT_ENTER)
     start_client_internal(
         server_address=server_address,
@@ -216,7 +234,9 @@ def start_client_internal(
     max_wait_time: Optional[float] = None,
     flwr_path: Optional[Path] = None,
     isolation: Optional[str] = None,
-    supernode_address: Optional[str] = CLIENTAPPIO_API_DEFAULT_ADDRESS,
+    clientappio_api_address: Optional[str] = CLIENTAPPIO_API_DEFAULT_SERVER_ADDRESS,
+    certificates: Optional[tuple[bytes, bytes, bytes]] = None,
+    ssl_ca_certfile: Optional[str] = None,
 ) -> None:
     """Start a Flower client node which connects to a Flower server.
 
@@ -274,10 +294,16 @@ def start_client_internal(
         `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: `CLIENTAPPIO_API_DEFAULT_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.
+    certificates : Optional[Tuple[bytes, bytes, bytes]] (default: None)
+        Tuple containing the CA certificate, server certificate, and server private key.
+    ssl_ca_certfile : Optional[str] (default: None)
+        The path to the CA certificate file used by `flwr-clientapp` in subprocess mode.
     """
     if insecure is None:
         insecure = root_certificates is None
@@ -304,15 +330,16 @@ def start_client_internal(
         load_client_app_fn = _load_client_app
 
     if isolation:
-        if supernode_address is None:
+        if clientappio_api_address is None:
             raise ValueError(
-                f"`supernode_address` required when `isolation` is "
+                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=supernode_address
+            address=clientappio_api_address,
+            certificates=certificates,
         )
-    supernode_address = cast(str, supernode_address)
+    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
@@ -448,7 +475,7 @@ 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.create_empty(run_id=run_id)
 
                     run: Run = runs[run_id]
                     if get_fab is not None and run.fab_hash:
@@ -508,14 +535,28 @@ def start_client_internal(
                             )
 
                             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",
-                                    "--supernode",
-                                    supernode_address,
+                                    "--clientappio-api-address",
+                                    io_address,
                                     "--token",
                                     str(token),
                                 ]
+                                if ssl_ca_certfile:
+                                    command.append("--root-certificates")
+                                    command.append(ssl_ca_certfile)
+                                else:
+                                    command.append("--insecure")
+
                                 subprocess.run(
                                     command,
                                     stdout=None,
@@ -783,7 +824,10 @@ class _AppStateTracker:
         signal.signal(signal.SIGTERM, signal_handler)
 
 
-def run_clientappio_api_grpc(address: str) -> tuple[grpc.Server, ClientAppIoServicer]:
+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
@@ -794,6 +838,7 @@ def run_clientappio_api_grpc(address: str) -> tuple[grpc.Server, ClientAppIoServ
         ),
         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()

{flwr_nightly-1.13.0.dev20241111 → flwr_nightly-1.13.0.dev20241117}/src/py/flwr/client/clientapp/app.py

@@ -24,9 +24,9 @@ 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.args import add_args_flwr_app_common
+from flwr.common.args import add_args_flwr_app_common, try_obtain_root_certificates
 from flwr.common.config import get_flwr_dir
-from flwr.common.constant import ErrorCode
+from flwr.common.constant import CLIENTAPPIO_API_DEFAULT_CLIENT_ADDRESS, ErrorCode
 from flwr.common.grpc import create_channel
 from flwr.common.logger import log
 from flwr.common.message import Error
@@ -56,37 +56,24 @@ from .utils import get_load_client_app_fn
 
 def flwr_clientapp() -> None:
     """Run process-isolated Flower ClientApp."""
-    parser = argparse.ArgumentParser(
-        description="Run a Flower ClientApp",
-    )
-    parser.add_argument(
-        "--supernode",
-        type=str,
-        help="Address of SuperNode's ClientAppIo API",
-    )
-    parser.add_argument(
-        "--token",
-        type=int,
-        required=False,
-        help="Unique token generated by SuperNode for each ClientApp execution",
-    )
-    add_args_flwr_app_common(parser=parser)
-    args = parser.parse_args()
+    args = _parse_args_run_flwr_clientapp().parse_args()
 
     log(INFO, "Starting Flower ClientApp")
+    certificates = try_obtain_root_certificates(args, args.clientappio_api_address)
 
     log(
         DEBUG,
         "Starting isolated `ClientApp` connected to SuperNode's ClientAppIo API at %s "
         "with token %s",
-        args.supernode,
+        args.clientappio_api_address,
         args.token,
     )
     run_clientapp(
-        supernode=args.supernode,
+        clientappio_api_address=args.clientappio_api_address,
         run_once=(args.token is not None),
         token=args.token,
         flwr_dir=args.flwr_dir,
+        certificates=certificates,
     )
 
 
@@ -96,15 +83,17 @@ def on_channel_state_change(channel_connectivity: str) -> None:
 
 
 def run_clientapp(  # pylint: disable=R0914
-    supernode: str,
+    clientappio_api_address: str,
     run_once: bool,
     token: Optional[int] = None,
     flwr_dir: Optional[str] = None,
+    certificates: Optional[bytes] = None,
 ) -> None:
     """Run Flower ClientApp process."""
     channel = create_channel(
-        server_address=supernode,
-        insecure=True,
+        server_address=clientappio_api_address,
+        insecure=(certificates is None),
+        root_certificates=certificates,
     )
     channel.subscribe(on_channel_state_change)
 
@@ -237,3 +226,25 @@ def push_message(
     except grpc.RpcError as e:
         log(ERROR, "[PushClientAppOutputs] gRPC error occurred: %s", str(e))
         raise e
+
+
+def _parse_args_run_flwr_clientapp() -> argparse.ArgumentParser:
+    """Parse flwr-clientapp command line arguments."""
+    parser = argparse.ArgumentParser(
+        description="Run a Flower ClientApp",
+    )
+    parser.add_argument(
+        "--clientappio-api-address",
+        default=CLIENTAPPIO_API_DEFAULT_CLIENT_ADDRESS,
+        type=str,
+        help="Address of SuperNode's ClientAppIo API (IPv4, IPv6, or a domain name)."
+        f"By default, it is set to {CLIENTAPPIO_API_DEFAULT_CLIENT_ADDRESS}.",
+    )
+    parser.add_argument(
+        "--token",
+        type=int,
+        required=False,
+        help="Unique token generated by SuperNode for each ClientApp execution",
+    )
+    add_args_flwr_app_common(parser=parser)
+    return parser