flwr-nightly 1.15.0.dev20250114__py3-none-any.whl → 1.15.0.dev20250123__py3-none-any.whl

flwr/cli/config_utils.py

@@ -15,53 +15,19 @@
 """Utility to validate the `pyproject.toml` file."""
 
 
-import zipfile
-from io import BytesIO
 from pathlib import Path
-from typing import IO, Any, Optional, Union, get_args
+from typing import Any, Optional, Union
 
 import tomli
 import typer
 
-from flwr.common import object_ref
-from flwr.common.typing import UserConfigValue
-
-
-def get_fab_config(fab_file: Union[Path, bytes]) -> dict[str, Any]:
-    """Extract the config from a FAB file or path.
-
-    Parameters
-    ----------
-    fab_file : Union[Path, bytes]
-        The Flower App Bundle file to validate and extract the metadata from.
-        It can either be a path to the file or the file itself as bytes.
-
-    Returns
-    -------
-    Dict[str, Any]
-        The `config` of the given Flower App Bundle.
-    """
-    fab_file_archive: Union[Path, IO[bytes]]
-    if isinstance(fab_file, bytes):
-        fab_file_archive = BytesIO(fab_file)
-    elif isinstance(fab_file, Path):
-        fab_file_archive = fab_file
-    else:
-        raise ValueError("fab_file must be either a Path or bytes")
-
-    with zipfile.ZipFile(fab_file_archive, "r") as zipf:
-        with zipf.open("pyproject.toml") as file:
-            toml_content = file.read().decode("utf-8")
-
-        conf = load_from_string(toml_content)
-        if conf is None:
-            raise ValueError("Invalid TOML content in pyproject.toml")
-
-        is_valid, errors, _ = validate(conf, check_module=False)
-        if not is_valid:
-            raise ValueError(errors)
-
-        return conf
+from flwr.common.config import (
+    fuse_dicts,
+    get_fab_config,
+    get_metadata_from_config,
+    parse_config_args,
+    validate_config,
+)
 
 
 def get_fab_metadata(fab_file: Union[Path, bytes]) -> tuple[str, str]:
@@ -78,12 +44,7 @@ def get_fab_metadata(fab_file: Union[Path, bytes]) -> tuple[str, str]:
     Tuple[str, str]
         The `fab_id` and `fab_version` of the given Flower App Bundle.
     """
-    conf = get_fab_config(fab_file)
-
-    return (
-        f"{conf['tool']['flwr']['app']['publisher']}/{conf['project']['name']}",
-        conf["project"]["version"],
-    )
+    return get_metadata_from_config(get_fab_config(fab_file))
 
 
 def load_and_validate(
@@ -120,7 +81,7 @@ def load_and_validate(
         ]
         return (None, errors, [])
 
-    is_valid, errors, warnings = validate(config, check_module, path.parent)
+    is_valid, errors, warnings = validate_config(config, check_module, path.parent)
 
     if not is_valid:
         return (None, errors, warnings)
@@ -133,102 +94,11 @@ def load(toml_path: Path) -> Optional[dict[str, Any]]:
     if not toml_path.is_file():
         return None
 
-    with toml_path.open(encoding="utf-8") as toml_file:
-        return load_from_string(toml_file.read())
-
-
-def _validate_run_config(config_dict: dict[str, Any], errors: list[str]) -> None:
-    for key, value in config_dict.items():
-        if isinstance(value, dict):
-            _validate_run_config(config_dict[key], errors)
-        elif not isinstance(value, get_args(UserConfigValue)):
-            raise ValueError(
-                f"The value for key {key} needs to be of type `int`, `float`, "
-                "`bool, `str`, or  a `dict` of those.",
-            )
-
-
-# pylint: disable=too-many-branches
-def validate_fields(config: dict[str, Any]) -> tuple[bool, list[str], list[str]]:
-    """Validate pyproject.toml fields."""
-    errors = []
-    warnings = []
-
-    if "project" not in config:
-        errors.append("Missing [project] section")
-    else:
-        if "name" not in config["project"]:
-            errors.append('Property "name" missing in [project]')
-        if "version" not in config["project"]:
-            errors.append('Property "version" missing in [project]')
-        if "description" not in config["project"]:
-            warnings.append('Recommended property "description" missing in [project]')
-        if "license" not in config["project"]:
-            warnings.append('Recommended property "license" missing in [project]')
-        if "authors" not in config["project"]:
-            warnings.append('Recommended property "authors" missing in [project]')
-
-    if (
-        "tool" not in config
-        or "flwr" not in config["tool"]
-        or "app" not in config["tool"]["flwr"]
-    ):
-        errors.append("Missing [tool.flwr.app] section")
-    else:
-        if "publisher" not in config["tool"]["flwr"]["app"]:
-            errors.append('Property "publisher" missing in [tool.flwr.app]')
-        if "config" in config["tool"]["flwr"]["app"]:
-            _validate_run_config(config["tool"]["flwr"]["app"]["config"], errors)
-        if "components" not in config["tool"]["flwr"]["app"]:
-            errors.append("Missing [tool.flwr.app.components] section")
-        else:
-            if "serverapp" not in config["tool"]["flwr"]["app"]["components"]:
-                errors.append(
-                    'Property "serverapp" missing in [tool.flwr.app.components]'
-                )
-            if "clientapp" not in config["tool"]["flwr"]["app"]["components"]:
-                errors.append(
-                    'Property "clientapp" missing in [tool.flwr.app.components]'
-                )
-
-    return len(errors) == 0, errors, warnings
-
-
-def validate(
-    config: dict[str, Any],
-    check_module: bool = True,
-    project_dir: Optional[Union[str, Path]] = None,
-) -> tuple[bool, list[str], list[str]]:
-    """Validate pyproject.toml."""
-    is_valid, errors, warnings = validate_fields(config)
-
-    if not is_valid:
-        return False, errors, warnings
-
-    # Validate serverapp
-    serverapp_ref = config["tool"]["flwr"]["app"]["components"]["serverapp"]
-    is_valid, reason = object_ref.validate(serverapp_ref, check_module, project_dir)
-
-    if not is_valid and isinstance(reason, str):
-        return False, [reason], []
-
-    # Validate clientapp
-    clientapp_ref = config["tool"]["flwr"]["app"]["components"]["clientapp"]
-    is_valid, reason = object_ref.validate(clientapp_ref, check_module, project_dir)
-
-    if not is_valid and isinstance(reason, str):
-        return False, [reason], []
-
-    return True, [], []
-
-
-def load_from_string(toml_content: str) -> Optional[dict[str, Any]]:
-    """Load TOML content from a string and return as dict."""
-    try:
-        data = tomli.loads(toml_content)
-        return data
-    except tomli.TOMLDecodeError:
-        return None
+    with toml_path.open("rb") as toml_file:
+        try:
+            return tomli.load(toml_file)
+        except tomli.TOMLDecodeError:
+            return None
 
 
 def process_loaded_project_config(
@@ -263,7 +133,9 @@ def process_loaded_project_config(
 
 
 def validate_federation_in_project_config(
-    federation: Optional[str], config: dict[str, Any]
+    federation: Optional[str],
+    config: dict[str, Any],
+    overrides: Optional[list[str]] = None,
 ) -> tuple[str, dict[str, Any]]:
     """Validate the federation name in the Flower project configuration."""
     federation = federation or config["tool"]["flwr"]["federations"].get("default")
@@ -293,6 +165,11 @@ def validate_federation_in_project_config(
         )
         raise typer.Exit(code=1)
 
+    # Override the federation configuration if provided
+    if overrides:
+        overrides_dict = parse_config_args(overrides, flatten=False)
+        federation_config = fuse_dicts(federation_config, overrides_dict)
+
     return federation, federation_config
 
 

flwr/cli/constant.py

@@ -0,0 +1,27 @@
+# Copyright 2025 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.
+# ==============================================================================
+"""Constants for CLI commands."""
+
+
+# The help message for `--federation-config` option
+FEDERATION_CONFIG_HELP_MESSAGE = (
+    "Override federation configuration values in the format:\n\n"
+    "`--federation-config 'key1=value1 key2=value2' --federation-config "
+    "'key3=value3'`\n\nValues can be of any type supported in TOML, such as "
+    "bool, int, float, or string. Ensure that the keys (`key1`, `key2`, `key3` "
+    "in this example) exist in the federation configuration under the "
+    "`[tool.flwr.federations.<YOUR_FEDERATION>]` table of the `pyproject.toml` "
+    "for proper overriding."
+)

flwr/cli/install.py

@@ -154,7 +154,7 @@ def validate_and_install(
         )
         raise typer.Exit(code=1)
 
-    version, fab_id = get_metadata_from_config(config)
+    fab_id, version = get_metadata_from_config(config)
     publisher, project_name = fab_id.split("/")
     config_metadata = (publisher, project_name, version, fab_hash)
 

flwr/cli/log.py

@@ -29,6 +29,7 @@ from flwr.cli.config_utils import (
     process_loaded_project_config,
     validate_federation_in_project_config,
 )
+from flwr.cli.constant import FEDERATION_CONFIG_HELP_MESSAGE
 from flwr.common.constant import CONN_RECONNECT_INTERVAL, CONN_REFRESH_PERIOD
 from flwr.common.logger import log as logger
 from flwr.proto.exec_pb2 import StreamLogsRequest  # pylint: disable=E0611
@@ -57,6 +58,8 @@ def start_stream(
             logger(ERROR, "Invalid run_id `%s`, exiting", run_id)
         if e.code() == grpc.StatusCode.CANCELLED:
             pass
+        else:
+            raise e
     finally:
         channel.close()
 
@@ -123,6 +126,7 @@ def print_logs(run_id: int, channel: grpc.Channel, timeout: int) -> None:
                     break
                 if e.code() == grpc.StatusCode.CANCELLED:
                     break
+                raise e
     except KeyboardInterrupt:
         logger(DEBUG, "Stream interrupted by user")
     finally:
@@ -143,6 +147,13 @@ def log(
         Optional[str],
         typer.Argument(help="Name of the federation to run the app on"),
     ] = None,
+    federation_config_overrides: Annotated[
+        Optional[list[str]],
+        typer.Option(
+            "--federation-config",
+            help=FEDERATION_CONFIG_HELP_MESSAGE,
+        ),
+    ] = None,
     stream: Annotated[
         bool,
         typer.Option(
@@ -158,11 +169,15 @@ def log(
     config, errors, warnings = load_and_validate(path=pyproject_path)
     config = process_loaded_project_config(config, errors, warnings)
     federation, federation_config = validate_federation_in_project_config(
-        federation, config
+        federation, config, federation_config_overrides
     )
     exit_if_no_address(federation_config, "log")
 
-    _log_with_exec_api(app, federation, federation_config, run_id, stream)
+    try:
+        _log_with_exec_api(app, federation, federation_config, run_id, stream)
+    except Exception as err:  # pylint: disable=broad-except
+        typer.secho(str(err), fg=typer.colors.RED, bold=True)
+        raise typer.Exit(code=1) from None
 
 
 def _log_with_exec_api(

flwr/cli/login/login.py

@@ -26,6 +26,7 @@ from flwr.cli.config_utils import (
     process_loaded_project_config,
     validate_federation_in_project_config,
 )
+from flwr.cli.constant import FEDERATION_CONFIG_HELP_MESSAGE
 from flwr.common.typing import UserAuthLoginDetails
 from flwr.proto.exec_pb2 import (  # pylint: disable=E0611
     GetLoginDetailsRequest,
@@ -45,6 +46,13 @@ def login(  # pylint: disable=R0914
         Optional[str],
         typer.Argument(help="Name of the federation to login into."),
     ] = None,
+    federation_config_overrides: Annotated[
+        Optional[list[str]],
+        typer.Option(
+            "--federation-config",
+            help=FEDERATION_CONFIG_HELP_MESSAGE,
+        ),
+    ] = None,
 ) -> None:
     """Login to Flower SuperLink."""
     typer.secho("Loading project configuration... ", fg=typer.colors.BLUE)
@@ -54,7 +62,7 @@ def login(  # pylint: disable=R0914
 
     config = process_loaded_project_config(config, errors, warnings)
     federation, federation_config = validate_federation_in_project_config(
-        federation, config
+        federation, config, federation_config_overrides
     )
     exit_if_no_address(federation_config, "login")
     channel = init_channel(app, federation_config, None)

flwr/cli/ls.py

@@ -32,6 +32,7 @@ from flwr.cli.config_utils import (
     process_loaded_project_config,
     validate_federation_in_project_config,
 )
+from flwr.cli.constant import FEDERATION_CONFIG_HELP_MESSAGE
 from flwr.common.constant import FAB_CONFIG_FILE, CliOutputFormat, SubStatus
 from flwr.common.date import format_timedelta, isoformat8601_utc
 from flwr.common.logger import print_json_error, redirect_output, restore_output
@@ -48,7 +49,7 @@ from .utils import init_channel, try_obtain_cli_auth_plugin, unauthenticated_exc
 _RunListType = tuple[int, str, str, str, str, str, str, str, str]
 
 
-def ls(  # pylint: disable=too-many-locals, too-many-branches
+def ls(  # pylint: disable=too-many-locals, too-many-branches, R0913, R0917
     app: Annotated[
         Path,
         typer.Argument(help="Path of the Flower project"),
@@ -57,6 +58,13 @@ def ls(  # pylint: disable=too-many-locals, too-many-branches
         Optional[str],
         typer.Argument(help="Name of the federation"),
     ] = None,
+    federation_config_overrides: Annotated[
+        Optional[list[str]],
+        typer.Option(
+            "--federation-config",
+            help=FEDERATION_CONFIG_HELP_MESSAGE,
+        ),
+    ] = None,
     runs: Annotated[
         bool,
         typer.Option(
@@ -106,7 +114,7 @@ def ls(  # pylint: disable=too-many-locals, too-many-branches
         config, errors, warnings = load_and_validate(path=pyproject_path)
         config = process_loaded_project_config(config, errors, warnings)
         federation, federation_config = validate_federation_in_project_config(
-            federation, config
+            federation, config, federation_config_overrides
         )
         exit_if_no_address(federation_config, "ls")
 

flwr/cli/run/run.py

@@ -31,6 +31,7 @@ from flwr.cli.config_utils import (
     process_loaded_project_config,
     validate_federation_in_project_config,
 )
+from flwr.cli.constant import FEDERATION_CONFIG_HELP_MESSAGE
 from flwr.common.config import (
     flatten_dict,
     parse_config_args,
@@ -57,7 +58,7 @@ from ..utils import (
 CONN_REFRESH_PERIOD = 60  # Connection refresh period for log streaming (seconds)
 
 
-# pylint: disable-next=too-many-locals
+# pylint: disable-next=too-many-locals, R0913, R0917
 def run(
     app: Annotated[
         Path,
@@ -67,16 +68,23 @@ def run(
         Optional[str],
         typer.Argument(help="Name of the federation to run the app on."),
     ] = None,
-    config_overrides: Annotated[
+    run_config_overrides: Annotated[
         Optional[list[str]],
         typer.Option(
             "--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"
-            "Note that `key1`, `key2`, and `key3` in this example need to exist "
-            "inside the `pyproject.toml` in order to be properly overriden.",
+            help="Override run configuration values in the format:\n\n"
+            "`--run-config 'key1=value1 key2=value2' --run-config 'key3=value3'`\n\n"
+            "Values can be of any type supported in TOML, such as bool, int, "
+            "float, or string. Ensure that the keys (`key1`, `key2`, `key3` "
+            "in this example) exist in `pyproject.toml` for proper overriding.",
+        ),
+    ] = None,
+    federation_config_overrides: Annotated[
+        Optional[list[str]],
+        typer.Option(
+            "--federation-config",
+            help=FEDERATION_CONFIG_HELP_MESSAGE,
         ),
     ] = None,
     stream: Annotated[
@@ -108,7 +116,7 @@ def run(
         config, errors, warnings = load_and_validate(path=pyproject_path)
         config = process_loaded_project_config(config, errors, warnings)
         federation, federation_config = validate_federation_in_project_config(
-            federation, config
+            federation, config, federation_config_overrides
         )
 
         if "address" in federation_config:
@@ -116,12 +124,14 @@ def run(
                 app,
                 federation,
                 federation_config,
-                config_overrides,
+                run_config_overrides,
                 stream,
                 output_format,
             )
         else:
-            _run_without_exec_api(app, federation_config, config_overrides, federation)
+            _run_without_exec_api(
+                app, federation_config, run_config_overrides, federation
+            )
     except (typer.Exit, Exception) as err:  # pylint: disable=broad-except
         if suppress_output:
             restore_output()

flwr/cli/stop.py

@@ -29,6 +29,7 @@ from flwr.cli.config_utils import (
     process_loaded_project_config,
     validate_federation_in_project_config,
 )
+from flwr.cli.constant import FEDERATION_CONFIG_HELP_MESSAGE
 from flwr.common.constant import FAB_CONFIG_FILE, CliOutputFormat
 from flwr.common.logger import print_json_error, redirect_output, restore_output
 from flwr.proto.exec_pb2 import StopRunRequest, StopRunResponse  # pylint: disable=E0611
@@ -50,6 +51,13 @@ def stop(  # pylint: disable=R0914
         Optional[str],
         typer.Argument(help="Name of the federation"),
     ] = None,
+    federation_config_overrides: Annotated[
+        Optional[list[str]],
+        typer.Option(
+            "--federation-config",
+            help=FEDERATION_CONFIG_HELP_MESSAGE,
+        ),
+    ] = None,
     output_format: Annotated[
         str,
         typer.Option(
@@ -73,7 +81,7 @@ def stop(  # pylint: disable=R0914
         config, errors, warnings = load_and_validate(path=pyproject_path)
         config = process_loaded_project_config(config, errors, warnings)
         federation, federation_config = validate_federation_in_project_config(
-            federation, config
+            federation, config, federation_config_overrides
         )
         exit_if_no_address(federation_config, "stop")
 

flwr/client/app.py

@@ -16,11 +16,11 @@
 
 
 import multiprocessing
-import signal
+import os
 import sys
+import threading
 import time
 from contextlib import AbstractContextManager
-from dataclasses import dataclass
 from logging import ERROR, INFO, WARN
 from os import urandom
 from pathlib import Path
@@ -45,7 +45,6 @@ from flwr.common.constant import (
     ISOLATION_MODE_PROCESS,
     ISOLATION_MODE_SUBPROCESS,
     MAX_RETRY_DELAY,
-    MISSING_EXTRA_REST,
     RUN_ID_NUM_BYTES,
     SERVER_OCTET,
     TRANSPORT_TYPE_GRPC_ADAPTER,
@@ -55,6 +54,7 @@ from flwr.common.constant import (
     TRANSPORT_TYPES,
     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.message import Error
@@ -346,10 +346,7 @@ def start_client_internal(
         transport, server_address
     )
 
-    app_state_tracker = _AppStateTracker()
-
     def _on_sucess(retry_state: RetryState) -> None:
-        app_state_tracker.is_connected = True
         if retry_state.tries > 1:
             log(
                 INFO,
@@ -359,7 +356,6 @@ def start_client_internal(
             )
 
     def _on_backoff(retry_state: RetryState) -> None:
-        app_state_tracker.is_connected = False
         if retry_state.tries == 1:
             log(WARN, "Connection attempt failed, retrying...")
         else:
@@ -396,7 +392,7 @@ def start_client_internal(
 
     runs: dict[int, Run] = {}
 
-    while not app_state_tracker.interrupt:
+    while True:
         sleep_duration: int = 0
         with connection(
             address,
@@ -435,9 +431,8 @@ def start_client_internal(
                         node_config=node_config,
                     )
 
-            app_state_tracker.register_signal_handler()
             # pylint: disable=too-many-nested-blocks
-            while not app_state_tracker.interrupt:
+            while True:
                 try:
                     # Receive
                     message = receive()
@@ -553,7 +548,7 @@ def start_client_internal(
 
                                 proc = mp_spawn_context.Process(
                                     target=_run_flwr_clientapp,
-                                    args=(command,),
+                                    args=(command, os.getpid()),
                                     daemon=True,
                                 )
                                 proc.start()
@@ -595,10 +590,7 @@ def start_client_internal(
                             e_code = ErrorCode.LOAD_CLIENT_APP_EXCEPTION
                             exc_entity = "SuperNode"
 
-                        if not app_state_tracker.interrupt:
-                            log(
-                                ERROR, "%s raised an exception", exc_entity, exc_info=ex
-                            )
+                        log(ERROR, "%s raised an exception", exc_entity, exc_info=ex)
 
                         # Create error message
                         reply_message = message.create_error_reply(
@@ -624,19 +616,14 @@ def start_client_internal(
                         run_id,
                     )
                     log(INFO, "")
-
-                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:
+            if delete_node is not None:
                 delete_node()  # pylint: disable=not-callable
 
         if sleep_duration == 0:
             log(INFO, "Disconnect and shut down")
-            del app_state_tracker
             break
 
         # Sleep and reconnect afterwards
@@ -776,7 +763,10 @@ def _init_connection(transport: Optional[str], server_address: str) -> tuple[
     # Parse IP address
     parsed_address = parse_address(server_address)
     if not parsed_address:
-        sys.exit(f"Server address ({server_address}) cannot be parsed.")
+        flwr_exit(
+            ExitCode.COMMON_ADDRESS_INVALID,
+            f"SuperLink address ({server_address}) cannot be parsed.",
+        )
     host, port, is_v6 = parsed_address
     address = f"[{host}]:{port}" if is_v6 else f"{host}:{port}"
 
@@ -791,12 +781,9 @@ def _init_connection(transport: Optional[str], server_address: str) -> tuple[
 
             from .rest_client.connection import http_request_response
         except ModuleNotFoundError:
-            sys.exit(MISSING_EXTRA_REST)
+            flwr_exit(ExitCode.COMMON_MISSING_EXTRA_REST)
         if server_address[:4] != "http":
-            sys.exit(
-                "When using the REST API, please provide `https://` or "
-                "`http://` before the server address (e.g. `http://127.0.0.1:8080`)"
-            )
+            flwr_exit(ExitCode.SUPERNODE_REST_ADDRESS_INVALID)
         connection, error_type = http_request_response, RequestsConnectionError
     elif transport == TRANSPORT_TYPE_GRPC_RERE:
         connection, error_type = grpc_request_response, RpcError
@@ -812,24 +799,17 @@ def _init_connection(transport: Optional[str], server_address: str) -> tuple[
     return connection, address, error_type
 
 
-@dataclass
-class _AppStateTracker:
-    interrupt: bool = False
-    is_connected: bool = False
-
-    def register_signal_handler(self) -> None:
-        """Register handlers for exit signals."""
-
-        def signal_handler(sig, frame):  # type: ignore
-            # pylint: disable=unused-argument
-            self.interrupt = True
-            raise StopIteration from None
-
-        signal.signal(signal.SIGINT, signal_handler)
-        signal.signal(signal.SIGTERM, signal_handler)
+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()
 
-def _run_flwr_clientapp(args: list[str]) -> None:
+    # Run the command
     sys.argv = args
     flwr_clientapp()
 

flwr/client/clientapp/app.py

@@ -16,7 +16,6 @@
 
 
 import argparse
-import sys
 import time
 from logging import DEBUG, ERROR, INFO
 from typing import Optional
@@ -29,6 +28,7 @@ from flwr.common import Context, Message
 from flwr.common.args import add_args_flwr_app_common
 from flwr.common.config import get_flwr_dir
 from flwr.common.constant import CLIENTAPPIO_API_DEFAULT_CLIENT_ADDRESS, ErrorCode
+from flwr.common.exit import ExitCode, flwr_exit
 from flwr.common.grpc import create_channel
 from flwr.common.logger import log
 from flwr.common.message import Error
@@ -61,12 +61,10 @@ def flwr_clientapp() -> None:
     """Run process-isolated Flower ClientApp."""
     args = _parse_args_run_flwr_clientapp().parse_args()
     if not args.insecure:
-        log(
-            ERROR,
-            "flwr-clientapp does not support TLS yet. "
-            "Please use the '--insecure' flag.",
+        flwr_exit(
+            ExitCode.COMMON_TLS_NOT_SUPPORTED,
+            "flwr-clientapp does not support TLS yet.",
         )
-        sys.exit(1)
 
     log(INFO, "Starting Flower ClientApp")
     log(