flwr-nightly 1.8.0.dev20240314__py3-none-any.whl → 1.15.0.dev20250114__py3-none-any.whl

flwr/common/args.py

@@ -0,0 +1,153 @@
+# 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.
+# ==============================================================================
+"""Common Flower arguments."""
+
+
+import argparse
+import sys
+from logging import DEBUG, ERROR, WARN
+from os.path import isfile
+from pathlib import Path
+from typing import Optional
+
+from flwr.common.constant import (
+    TRANSPORT_TYPE_GRPC_ADAPTER,
+    TRANSPORT_TYPE_GRPC_RERE,
+    TRANSPORT_TYPE_REST,
+)
+from flwr.common.logger import log
+
+
+def add_args_flwr_app_common(parser: argparse.ArgumentParser) -> None:
+    """Add common Flower arguments for flwr-*app to the provided parser."""
+    parser.add_argument(
+        "--flwr-dir",
+        default=None,
+        help="""The path containing installed Flower Apps.
+        By default, this value is equal to:
+
+            - `$FLWR_HOME/` if `$FLWR_HOME` is defined
+            - `$XDG_DATA_HOME/.flwr/` if `$XDG_DATA_HOME` is defined
+            - `$HOME/.flwr/` in all other cases
+        """,
+    )
+    parser.add_argument(
+        "--insecure",
+        action="store_true",
+        help="Run the server without HTTPS, regardless of whether certificate "
+        "paths are provided. By default, the server runs with HTTPS enabled. "
+        "Use this flag only if you understand the risks.",
+    )
+
+
+def try_obtain_root_certificates(
+    args: argparse.Namespace,
+    grpc_server_address: str,
+) -> Optional[bytes]:
+    """Validate and return the root certificates."""
+    root_cert_path = args.root_certificates
+    if args.insecure:
+        if root_cert_path is not None:
+            sys.exit(
+                "Conflicting options: The '--insecure' flag disables HTTPS, "
+                "but '--root-certificates' was also specified. Please remove "
+                "the '--root-certificates' option when running in insecure mode, "
+                "or omit '--insecure' to use HTTPS."
+            )
+        log(
+            WARN,
+            "Option `--insecure` was set. Starting insecure HTTP channel to %s.",
+            grpc_server_address,
+        )
+        root_certificates = None
+    else:
+        # Load the certificates if provided, or load the system certificates
+        if root_cert_path is None:
+            log(
+                WARN,
+                "Both `--insecure` and `--root-certificates` were not set. "
+                "Using system certificates.",
+            )
+            root_certificates = None
+        elif not isfile(root_cert_path):
+            log(ERROR, "Path argument `--root-certificates` does not point to a file.")
+            sys.exit(1)
+        else:
+            root_certificates = Path(root_cert_path).read_bytes()
+        log(
+            DEBUG,
+            "Starting secure HTTPS channel to %s "
+            "with the following certificates: %s.",
+            grpc_server_address,
+            root_cert_path,
+        )
+    return root_certificates
+
+
+def try_obtain_server_certificates(
+    args: argparse.Namespace,
+    transport_type: str,
+) -> Optional[tuple[bytes, bytes, bytes]]:
+    """Validate and return the CA cert, server cert, and server private key."""
+    if args.insecure:
+        log(WARN, "Option `--insecure` was set. Starting insecure HTTP server.")
+        return None
+    # Check if certificates are provided
+    if transport_type in [TRANSPORT_TYPE_GRPC_RERE, TRANSPORT_TYPE_GRPC_ADAPTER]:
+        if args.ssl_certfile and args.ssl_keyfile and args.ssl_ca_certfile:
+            if not isfile(args.ssl_ca_certfile):
+                sys.exit("Path argument `--ssl-ca-certfile` does not point to a file.")
+            if not isfile(args.ssl_certfile):
+                sys.exit("Path argument `--ssl-certfile` does not point to a file.")
+            if not isfile(args.ssl_keyfile):
+                sys.exit("Path argument `--ssl-keyfile` does not point to a file.")
+            certificates = (
+                Path(args.ssl_ca_certfile).read_bytes(),  # CA certificate
+                Path(args.ssl_certfile).read_bytes(),  # server certificate
+                Path(args.ssl_keyfile).read_bytes(),  # server private key
+            )
+            return certificates
+        if args.ssl_certfile or args.ssl_keyfile or args.ssl_ca_certfile:
+            sys.exit(
+                "You need to provide valid file paths to `--ssl-certfile`, "
+                "`--ssl-keyfile`, and `—-ssl-ca-certfile` to create a secure "
+                "connection in Fleet API server (gRPC-rere)."
+            )
+    if transport_type == TRANSPORT_TYPE_REST:
+        if args.ssl_certfile and args.ssl_keyfile:
+            if not isfile(args.ssl_certfile):
+                sys.exit("Path argument `--ssl-certfile` does not point to a file.")
+            if not isfile(args.ssl_keyfile):
+                sys.exit("Path argument `--ssl-keyfile` does not point to a file.")
+            certificates = (
+                b"",
+                Path(args.ssl_certfile).read_bytes(),  # server certificate
+                Path(args.ssl_keyfile).read_bytes(),  # server private key
+            )
+            return certificates
+        if args.ssl_certfile or args.ssl_keyfile:
+            sys.exit(
+                "You need to provide valid file paths to `--ssl-certfile` "
+                "and `--ssl-keyfile` to create a secure connection "
+                "in Fleet API server (REST, experimental)."
+            )
+    log(
+        ERROR,
+        "Certificates are required unless running in insecure mode. "
+        "Please provide certificate paths to `--ssl-certfile`, "
+        "`--ssl-keyfile`, and `—-ssl-ca-certfile` or run the server "
+        "in insecure mode using '--insecure' if you understand the risks.",
+    )
+    sys.exit(1)

flwr/common/auth_plugin/__init__.py

@@ -0,0 +1,24 @@
+# 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.
+# ==============================================================================
+"""Auth plugin components."""
+
+
+from .auth_plugin import CliAuthPlugin as CliAuthPlugin
+from .auth_plugin import ExecAuthPlugin as ExecAuthPlugin
+
+__all__ = [
+    "CliAuthPlugin",
+    "ExecAuthPlugin",
+]

flwr/common/auth_plugin/auth_plugin.py

@@ -0,0 +1,121 @@
+# 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.
+# ==============================================================================
+"""Abstract classes for Flower User Auth Plugin."""
+
+
+from abc import ABC, abstractmethod
+from collections.abc import Sequence
+from pathlib import Path
+from typing import Optional, Union
+
+from flwr.proto.exec_pb2_grpc import ExecStub
+
+from ..typing import UserAuthCredentials, UserAuthLoginDetails
+
+
+class ExecAuthPlugin(ABC):
+    """Abstract Flower Auth Plugin class for ExecServicer.
+
+    Parameters
+    ----------
+    user_auth_config_path : Path
+        Path to the YAML file containing the authentication configuration.
+    """
+
+    @abstractmethod
+    def __init__(
+        self,
+        user_auth_config_path: Path,
+    ):
+        """Abstract constructor."""
+
+    @abstractmethod
+    def get_login_details(self) -> Optional[UserAuthLoginDetails]:
+        """Get the login details."""
+
+    @abstractmethod
+    def validate_tokens_in_metadata(
+        self, metadata: Sequence[tuple[str, Union[str, bytes]]]
+    ) -> bool:
+        """Validate authentication tokens in the provided metadata."""
+
+    @abstractmethod
+    def get_auth_tokens(self, device_code: str) -> Optional[UserAuthCredentials]:
+        """Get authentication tokens."""
+
+    @abstractmethod
+    def refresh_tokens(
+        self, metadata: Sequence[tuple[str, Union[str, bytes]]]
+    ) -> Optional[Sequence[tuple[str, Union[str, bytes]]]]:
+        """Refresh authentication tokens in the provided metadata."""
+
+
+class CliAuthPlugin(ABC):
+    """Abstract Flower Auth Plugin class for CLI.
+
+    Parameters
+    ----------
+    credentials_path : Path
+        Path to the user's authentication credentials file.
+    """
+
+    @staticmethod
+    @abstractmethod
+    def login(
+        login_details: UserAuthLoginDetails,
+        exec_stub: ExecStub,
+    ) -> UserAuthCredentials:
+        """Authenticate the user and retrieve authentication credentials.
+
+        Parameters
+        ----------
+        login_details : UserAuthLoginDetails
+            An object containing the user's login details.
+        exec_stub : ExecStub
+            A stub for executing RPC calls to the server.
+
+        Returns
+        -------
+        UserAuthCredentials
+            The authentication credentials obtained after login.
+        """
+
+    @abstractmethod
+    def __init__(self, credentials_path: Path):
+        """Abstract constructor."""
+
+    @abstractmethod
+    def store_tokens(self, credentials: UserAuthCredentials) -> None:
+        """Store authentication tokens to the `credentials_path`.
+
+        The credentials, including tokens, will be saved as a JSON file
+        at `credentials_path`.
+        """
+
+    @abstractmethod
+    def load_tokens(self) -> None:
+        """Load authentication tokens from the `credentials_path`."""
+
+    @abstractmethod
+    def write_tokens_to_metadata(
+        self, metadata: Sequence[tuple[str, Union[str, bytes]]]
+    ) -> Sequence[tuple[str, Union[str, bytes]]]:
+        """Write authentication tokens to the provided metadata."""
+
+    @abstractmethod
+    def read_tokens_from_metadata(
+        self, metadata: Sequence[tuple[str, Union[str, bytes]]]
+    ) -> Optional[UserAuthCredentials]:
+        """Read authentication tokens from the provided metadata."""

flwr/common/config.py

@@ -0,0 +1,243 @@
+# 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.
+# ==============================================================================
+"""Provide functions for managing global Flower config."""
+
+
+import os
+import re
+from pathlib import Path
+from typing import Any, Optional, Union, cast, get_args
+
+import tomli
+
+from flwr.cli.config_utils import get_fab_config, validate_fields
+from flwr.common import ConfigsRecord
+from flwr.common.constant import (
+    APP_DIR,
+    FAB_CONFIG_FILE,
+    FAB_HASH_TRUNCATION,
+    FLWR_DIR,
+    FLWR_HOME,
+)
+from flwr.common.typing import Run, UserConfig, UserConfigValue
+
+
+def get_flwr_dir(provided_path: Optional[str] = None) -> Path:
+    """Return the Flower home directory based on env variables."""
+    if provided_path is None or not Path(provided_path).is_dir():
+        return Path(
+            os.getenv(
+                FLWR_HOME,
+                Path(f"{os.getenv('XDG_DATA_HOME', os.getenv('HOME'))}") / FLWR_DIR,
+            )
+        )
+    return Path(provided_path).absolute()
+
+
+def get_project_dir(
+    fab_id: str,
+    fab_version: str,
+    fab_hash: str,
+    flwr_dir: Optional[Union[str, Path]] = None,
+) -> Path:
+    """Return the project directory based on the given fab_id and fab_version."""
+    # Check the fab_id
+    if fab_id.count("/") != 1:
+        raise ValueError(
+            f"Invalid FAB ID: {fab_id}",
+        )
+    publisher, project_name = fab_id.split("/")
+    if flwr_dir is None:
+        flwr_dir = get_flwr_dir()
+    return (
+        Path(flwr_dir)
+        / APP_DIR
+        / f"{publisher}.{project_name}.{fab_version}.{fab_hash[:FAB_HASH_TRUNCATION]}"
+    )
+
+
+def get_project_config(project_dir: Union[str, Path]) -> dict[str, Any]:
+    """Return pyproject.toml in the given project directory."""
+    # Load pyproject.toml file
+    toml_path = Path(project_dir) / FAB_CONFIG_FILE
+    if not toml_path.is_file():
+        raise FileNotFoundError(
+            f"Cannot find {FAB_CONFIG_FILE} in {project_dir}",
+        )
+    with toml_path.open(encoding="utf-8") as toml_file:
+        config = tomli.loads(toml_file.read())
+
+    # Validate pyproject.toml fields
+    is_valid, errors, _ = validate_fields(config)
+    if not is_valid:
+        error_msg = "\n".join([f"  - {error}" for error in errors])
+        raise ValueError(
+            f"Invalid {FAB_CONFIG_FILE}:\n{error_msg}",
+        )
+
+    return config
+
+
+def fuse_dicts(
+    main_dict: UserConfig,
+    override_dict: UserConfig,
+) -> UserConfig:
+    """Merge a config with the overrides.
+
+    Remove the nesting by adding the nested keys as prefixes separated by dots, and fuse
+    it with the override dict.
+    """
+    fused_dict = main_dict.copy()
+
+    for key, value in override_dict.items():
+        if key in main_dict:
+            fused_dict[key] = value
+
+    return fused_dict
+
+
+def get_fused_config_from_dir(
+    project_dir: Path, override_config: UserConfig
+) -> UserConfig:
+    """Merge the overrides from a given dict with the config from a Flower App."""
+    default_config = get_project_config(project_dir)["tool"]["flwr"]["app"].get(
+        "config", {}
+    )
+    flat_default_config = flatten_dict(default_config)
+
+    return fuse_dicts(flat_default_config, override_config)
+
+
+def get_fused_config_from_fab(fab_file: Union[Path, bytes], run: Run) -> UserConfig:
+    """Fuse default config in a `FAB` with overrides in a `Run`.
+
+    This enables obtaining a run-config without having to install the FAB. This
+    function mirrors `get_fused_config_from_dir`. This is useful when the execution
+    of the FAB is delegated to a different process.
+    """
+    default_config = get_fab_config(fab_file)["tool"]["flwr"]["app"].get("config", {})
+    flat_config_flat = flatten_dict(default_config)
+    return fuse_dicts(flat_config_flat, run.override_config)
+
+
+def get_fused_config(run: Run, flwr_dir: Optional[Path]) -> UserConfig:
+    """Merge the overrides from a `Run` with the config from a FAB.
+
+    Get the config using the fab_id and the fab_version, remove the nesting by adding
+    the nested keys as prefixes separated by dots, and fuse it with the override dict.
+    """
+    # Return empty dict if fab_id or fab_version is empty
+    if not run.fab_id or not run.fab_version:
+        return {}
+
+    project_dir = get_project_dir(run.fab_id, run.fab_version, run.fab_hash, flwr_dir)
+
+    # Return empty dict if project directory does not exist
+    if not project_dir.is_dir():
+        return {}
+
+    return get_fused_config_from_dir(project_dir, run.override_config)
+
+
+def flatten_dict(
+    raw_dict: Optional[dict[str, Any]], parent_key: str = ""
+) -> UserConfig:
+    """Flatten dict by joining nested keys with a given separator."""
+    if raw_dict is None:
+        return {}
+
+    items: list[tuple[str, UserConfigValue]] = []
+    separator: str = "."
+    for k, v in raw_dict.items():
+        new_key = f"{parent_key}{separator}{k}" if parent_key else k
+        if isinstance(v, dict):
+            items.extend(flatten_dict(v, parent_key=new_key).items())
+        elif isinstance(v, get_args(UserConfigValue)):
+            items.append((new_key, cast(UserConfigValue, v)))
+        else:
+            raise ValueError(
+                f"The value for key {k} needs to be of type `int`, `float`, "
+                "`bool, `str`, or  a `dict` of those.",
+            )
+    return dict(items)
+
+
+def unflatten_dict(flat_dict: dict[str, Any]) -> dict[str, Any]:
+    """Unflatten a dict with keys containing separators into a nested dict."""
+    unflattened_dict: dict[str, Any] = {}
+    separator: str = "."
+
+    for key, value in flat_dict.items():
+        parts = key.split(separator)
+        d = unflattened_dict
+        for part in parts[:-1]:
+            if part not in d:
+                d[part] = {}
+            d = d[part]
+        d[parts[-1]] = value
+
+    return unflattened_dict
+
+
+def parse_config_args(
+    config: Optional[list[str]],
+) -> UserConfig:
+    """Parse separator separated list of key-value pairs separated by '='."""
+    overrides: UserConfig = {}
+
+    if config is None:
+        return overrides
+
+    # Handle if .toml file is passed
+    if len(config) == 1 and config[0].endswith(".toml"):
+        with Path(config[0]).open("rb") as config_file:
+            overrides = flatten_dict(tomli.load(config_file))
+        return overrides
+
+    # Regular expression to capture key-value pairs with possible quoted values
+    pattern = re.compile(r"(\S+?)=(\'[^\']*\'|\"[^\"]*\"|\S+)")
+
+    flat_overrides = {}
+    for config_line in config:
+        if config_line:
+            # .toml files aren't allowed alongside other configs
+            if config_line.endswith(".toml"):
+                raise ValueError(
+                    "TOML files cannot be passed alongside key-value pairs."
+                )
+
+            matches = pattern.findall(config_line)
+            toml_str = "\n".join(f"{k} = {v}" for k, v in matches)
+            overrides.update(tomli.loads(toml_str))
+            flat_overrides = flatten_dict(overrides)
+
+    return flat_overrides
+
+
+def get_metadata_from_config(config: dict[str, Any]) -> tuple[str, str]:
+    """Extract `fab_version` and `fab_id` from a project config."""
+    return (
+        config["project"]["version"],
+        f"{config['tool']['flwr']['app']['publisher']}/{config['project']['name']}",
+    )
+
+
+def user_config_to_configsrecord(config: UserConfig) -> ConfigsRecord:
+    """Construct a `ConfigsRecord` out of a `UserConfig`."""
+    c_record = ConfigsRecord()
+    for k, v in config.items():
+        c_record[k] = v
+
+    return c_record

flwr/common/constant.py

@@ -1,4 +1,4 @@
-# Copyright 2020 Flower Labs GmbH. All Rights Reserved.
+# Copyright 2023 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.
@@ -27,6 +27,7 @@ To use the REST API, install `flwr` with the `rest` extra:
 
 TRANSPORT_TYPE_GRPC_BIDI = "grpc-bidi"
 TRANSPORT_TYPE_GRPC_RERE = "grpc-rere"
+TRANSPORT_TYPE_GRPC_ADAPTER = "grpc-adapter"
 TRANSPORT_TYPE_REST = "rest"
 TRANSPORT_TYPE_VCE = "vce"
 TRANSPORT_TYPES = [
@@ -36,6 +37,86 @@ TRANSPORT_TYPES = [
     TRANSPORT_TYPE_VCE,
 ]
 
+# Addresses
+# Ports
+CLIENTAPPIO_PORT = "9094"
+SERVERAPPIO_PORT = "9091"
+FLEETAPI_GRPC_RERE_PORT = "9092"
+FLEETAPI_PORT = "9095"
+EXEC_API_PORT = "9093"
+SIMULATIONIO_PORT = "9096"
+# Octets
+SERVER_OCTET = "0.0.0.0"
+CLIENT_OCTET = "127.0.0.1"
+# SuperNode
+CLIENTAPPIO_API_DEFAULT_SERVER_ADDRESS = f"{SERVER_OCTET}:{CLIENTAPPIO_PORT}"
+CLIENTAPPIO_API_DEFAULT_CLIENT_ADDRESS = f"{CLIENT_OCTET}:{CLIENTAPPIO_PORT}"
+# SuperLink
+SERVERAPPIO_API_DEFAULT_SERVER_ADDRESS = f"{SERVER_OCTET}:{SERVERAPPIO_PORT}"
+SERVERAPPIO_API_DEFAULT_CLIENT_ADDRESS = f"{CLIENT_OCTET}:{SERVERAPPIO_PORT}"
+FLEET_API_GRPC_RERE_DEFAULT_ADDRESS = f"{SERVER_OCTET}:{FLEETAPI_GRPC_RERE_PORT}"
+FLEET_API_GRPC_BIDI_DEFAULT_ADDRESS = (
+    "[::]:8080"  # IPv6 to keep start_server compatible
+)
+FLEET_API_REST_DEFAULT_ADDRESS = f"{SERVER_OCTET}:{FLEETAPI_PORT}"
+EXEC_API_DEFAULT_SERVER_ADDRESS = f"{SERVER_OCTET}:{EXEC_API_PORT}"
+SIMULATIONIO_API_DEFAULT_SERVER_ADDRESS = f"{SERVER_OCTET}:{SIMULATIONIO_PORT}"
+SIMULATIONIO_API_DEFAULT_CLIENT_ADDRESS = f"{CLIENT_OCTET}:{SIMULATIONIO_PORT}"
+
+# Constants for ping
+PING_DEFAULT_INTERVAL = 30
+PING_CALL_TIMEOUT = 5
+PING_BASE_MULTIPLIER = 0.8
+PING_RANDOM_RANGE = (-0.1, 0.1)
+PING_MAX_INTERVAL = 1e300
+
+# IDs
+RUN_ID_NUM_BYTES = 8
+NODE_ID_NUM_BYTES = 8
+
+# Constants for FAB
+APP_DIR = "apps"
+FAB_ALLOWED_EXTENSIONS = {".py", ".toml", ".md"}
+FAB_CONFIG_FILE = "pyproject.toml"
+FAB_DATE = (2024, 10, 1, 0, 0, 0)
+FAB_HASH_TRUNCATION = 8
+FLWR_DIR = ".flwr"  # The default Flower directory: ~/.flwr/
+FLWR_HOME = "FLWR_HOME"  # If set, override the default Flower directory
+
+# Constants entries in Node config for Simulation
+PARTITION_ID_KEY = "partition-id"
+NUM_PARTITIONS_KEY = "num-partitions"
+
+# Constants for keys in `metadata` of `MessageContainer` in `grpc-adapter`
+GRPC_ADAPTER_METADATA_FLOWER_PACKAGE_NAME_KEY = "flower-package-name"
+GRPC_ADAPTER_METADATA_FLOWER_PACKAGE_VERSION_KEY = "flower-package-version"
+GRPC_ADAPTER_METADATA_FLOWER_VERSION_KEY = "flower-version"  # Deprecated
+GRPC_ADAPTER_METADATA_SHOULD_EXIT_KEY = "should-exit"
+GRPC_ADAPTER_METADATA_MESSAGE_MODULE_KEY = "grpc-message-module"
+GRPC_ADAPTER_METADATA_MESSAGE_QUALNAME_KEY = "grpc-message-qualname"
+
+# Message TTL
+MESSAGE_TTL_TOLERANCE = 1e-1
+
+# Isolation modes
+ISOLATION_MODE_SUBPROCESS = "subprocess"
+ISOLATION_MODE_PROCESS = "process"
+
+# Log streaming configurations
+CONN_REFRESH_PERIOD = 60  # Stream connection refresh period
+CONN_RECONNECT_INTERVAL = 0.5  # Reconnect interval between two stream connections
+LOG_STREAM_INTERVAL = 0.5  # Log stream interval for `ExecServicer.StreamLogs`
+LOG_UPLOAD_INTERVAL = 0.2  # Minimum interval between two log uploads
+
+# Retry configurations
+MAX_RETRY_DELAY = 20  # Maximum delay duration between two consecutive retries.
+
+# Constants for user authentication
+CREDENTIALS_DIR = ".credentials"
+AUTH_TYPE = "auth_type"
+ACCESS_TOKEN_KEY = "access_token"
+REFRESH_TOKEN_KEY = "refresh_token"
+
 
 class MessageType:
     """Message type."""
@@ -68,3 +149,53 @@ class SType:
     def __new__(cls) -> SType:
         """Prevent instantiation."""
         raise TypeError(f"{cls.__name__} cannot be instantiated.")
+
+
+class ErrorCode:
+    """Error codes for Message's Error."""
+
+    UNKNOWN = 0
+    LOAD_CLIENT_APP_EXCEPTION = 1
+    CLIENT_APP_RAISED_EXCEPTION = 2
+    MESSAGE_UNAVAILABLE = 3
+    REPLY_MESSAGE_UNAVAILABLE = 4
+
+    def __new__(cls) -> ErrorCode:
+        """Prevent instantiation."""
+        raise TypeError(f"{cls.__name__} cannot be instantiated.")
+
+
+class Status:
+    """Run status."""
+
+    PENDING = "pending"
+    STARTING = "starting"
+    RUNNING = "running"
+    FINISHED = "finished"
+
+    def __new__(cls) -> Status:
+        """Prevent instantiation."""
+        raise TypeError(f"{cls.__name__} cannot be instantiated.")
+
+
+class SubStatus:
+    """Run sub-status."""
+
+    COMPLETED = "completed"
+    FAILED = "failed"
+    STOPPED = "stopped"
+
+    def __new__(cls) -> SubStatus:
+        """Prevent instantiation."""
+        raise TypeError(f"{cls.__name__} cannot be instantiated.")
+
+
+class CliOutputFormat:
+    """Define output format for `flwr` CLI commands."""
+
+    DEFAULT = "default"
+    JSON = "json"
+
+    def __new__(cls) -> CliOutputFormat:
+        """Prevent instantiation."""
+        raise TypeError(f"{cls.__name__} cannot be instantiated.")