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

flwr/cli/run/run.py

@@ -14,55 +14,233 @@
 # ==============================================================================
 """Flower command line interface `run` command."""
 
-import sys
+
+import io
+import json
+import subprocess
+from pathlib import Path
+from typing import Annotated, Any, Optional
 
 import typer
+from rich.console import Console
 
-from flwr.cli import flower_toml
-from flwr.simulation.run_simulation import _run_simulation
+from flwr.cli.build import build
+from flwr.cli.config_utils import (
+    get_fab_metadata,
+    load_and_validate,
+    process_loaded_project_config,
+    validate_federation_in_project_config,
+)
+from flwr.common.config import (
+    flatten_dict,
+    parse_config_args,
+    user_config_to_configsrecord,
+)
+from flwr.common.constant import CliOutputFormat
+from flwr.common.logger import print_json_error, redirect_output, restore_output
+from flwr.common.serde import (
+    configs_record_to_proto,
+    fab_to_proto,
+    user_config_to_proto,
+)
+from flwr.common.typing import Fab
+from flwr.proto.exec_pb2 import StartRunRequest  # pylint: disable=E0611
+from flwr.proto.exec_pb2_grpc import ExecStub
 
+from ..log import start_stream
+from ..utils import (
+    init_channel,
+    try_obtain_cli_auth_plugin,
+    unauthenticated_exc_handler,
+)
 
-def run() -> None:
-    """Run Flower project."""
-    typer.secho("Loading project configuration... ", fg=typer.colors.BLUE)
+CONN_REFRESH_PERIOD = 60  # Connection refresh period for log streaming (seconds)
 
-    config, errors, warnings = flower_toml.load_and_validate_with_defaults()
 
-    if config is None:
-        typer.secho(
-            "Project configuration could not be loaded.\nflower.toml is invalid:\n"
-            + "\n".join([f"- {line}" for line in errors]),
-            fg=typer.colors.RED,
-            bold=True,
-        )
-        sys.exit()
+# pylint: disable-next=too-many-locals
+def run(
+    app: Annotated[
+        Path,
+        typer.Argument(help="Path of the Flower App to run."),
+    ] = Path("."),
+    federation: Annotated[
+        Optional[str],
+        typer.Argument(help="Name of the federation to run the app on."),
+    ] = None,
+    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.",
+        ),
+    ] = None,
+    stream: Annotated[
+        bool,
+        typer.Option(
+            "--stream",
+            help="Use `--stream` with `flwr run` to display logs;\n "
+            "logs are not streamed by default.",
+        ),
+    ] = False,
+    output_format: Annotated[
+        str,
+        typer.Option(
+            "--format",
+            case_sensitive=False,
+            help="Format output using 'default' view or 'json'",
+        ),
+    ] = CliOutputFormat.DEFAULT,
+) -> None:
+    """Run Flower App."""
+    suppress_output = output_format == CliOutputFormat.JSON
+    captured_output = io.StringIO()
+    try:
+        if suppress_output:
+            redirect_output(captured_output)
+        typer.secho("Loading project configuration... ", fg=typer.colors.BLUE)
 
-    if warnings:
-        typer.secho(
-            "Project configuration is missing the following "
-            "recommended properties:\n" + "\n".join([f"- {line}" for line in warnings]),
-            fg=typer.colors.RED,
-            bold=True,
+        pyproject_path = app / "pyproject.toml" if app else None
+        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
         )
 
-    typer.secho("Success", fg=typer.colors.GREEN)
+        if "address" in federation_config:
+            _run_with_exec_api(
+                app,
+                federation,
+                federation_config,
+                config_overrides,
+                stream,
+                output_format,
+            )
+        else:
+            _run_without_exec_api(app, federation_config, config_overrides, federation)
+    except (typer.Exit, Exception) as err:  # pylint: disable=broad-except
+        if suppress_output:
+            restore_output()
+            e_message = captured_output.getvalue()
+            print_json_error(e_message, err)
+        else:
+            typer.secho(
+                f"{err}",
+                fg=typer.colors.RED,
+                bold=True,
+            )
+    finally:
+        if suppress_output:
+            restore_output()
+        captured_output.close()
 
-    server_app_ref = config["flower"]["components"]["serverapp"]
-    client_app_ref = config["flower"]["components"]["clientapp"]
-    engine = config["flower"]["engine"]["name"]
 
-    if engine == "simulation":
-        num_supernodes = config["flower"]["engine"]["simulation"]["supernode"]["num"]
+# pylint: disable-next=R0913, R0914, R0917
+def _run_with_exec_api(
+    app: Path,
+    federation: str,
+    federation_config: dict[str, Any],
+    config_overrides: Optional[list[str]],
+    stream: bool,
+    output_format: str,
+) -> None:
+    auth_plugin = try_obtain_cli_auth_plugin(app, federation)
+    channel = init_channel(app, federation_config, auth_plugin)
+    stub = ExecStub(channel)
 
-        typer.secho("Starting run... ", fg=typer.colors.BLUE)
-        _run_simulation(
-            server_app_attr=server_app_ref,
-            client_app_attr=client_app_ref,
-            num_supernodes=num_supernodes,
-        )
+    fab_path, fab_hash = build(app)
+    content = Path(fab_path).read_bytes()
+    fab_id, fab_version = get_fab_metadata(Path(fab_path))
+
+    # Delete FAB file once the bytes is computed
+    Path(fab_path).unlink()
+
+    fab = Fab(fab_hash, content)
+
+    # Construct a `ConfigsRecord` out of a flattened `UserConfig`
+    fed_conf = flatten_dict(federation_config.get("options", {}))
+    c_record = user_config_to_configsrecord(fed_conf)
+
+    req = StartRunRequest(
+        fab=fab_to_proto(fab),
+        override_config=user_config_to_proto(parse_config_args(config_overrides)),
+        federation_options=configs_record_to_proto(c_record),
+    )
+    with unauthenticated_exc_handler():
+        res = stub.StartRun(req)
+
+    if res.HasField("run_id"):
+        typer.secho(f"🎊 Successfully started run {res.run_id}", fg=typer.colors.GREEN)
     else:
+        typer.secho("❌ Failed to start run", fg=typer.colors.RED)
+        raise typer.Exit(code=1)
+
+    if output_format == CliOutputFormat.JSON:
+        run_output = json.dumps(
+            {
+                "success": res.HasField("run_id"),
+                "run-id": res.run_id if res.HasField("run_id") else None,
+                "fab-id": fab_id,
+                "fab-name": fab_id.rsplit("/", maxsplit=1)[-1],
+                "fab-version": fab_version,
+                "fab-hash": fab_hash[:8],
+                "fab-filename": fab_path,
+            }
+        )
+        restore_output()
+        Console().print_json(run_output)
+
+    if stream:
+        start_stream(res.run_id, channel, CONN_REFRESH_PERIOD)
+
+
+def _run_without_exec_api(
+    app: Optional[Path],
+    federation_config: dict[str, Any],
+    config_overrides: Optional[list[str]],
+    federation: str,
+) -> None:
+    try:
+        num_supernodes = federation_config["options"]["num-supernodes"]
+        verbose: Optional[bool] = federation_config["options"].get("verbose")
+        backend_cfg = federation_config["options"].get("backend", {})
+    except KeyError as err:
         typer.secho(
-            f"Engine '{engine}' is not yet supported in `flwr run`",
+            "❌ The project's `pyproject.toml` needs to declare the number of"
+            " SuperNodes in the simulation. To simulate 10 SuperNodes,"
+            " use the following notation:\n\n"
+            f"[tool.flwr.federations.{federation}]\n"
+            "options.num-supernodes = 10\n",
             fg=typer.colors.RED,
             bold=True,
         )
+        raise typer.Exit(code=1) from err
+
+    command = [
+        "flower-simulation",
+        "--app",
+        f"{app}",
+        "--num-supernodes",
+        f"{num_supernodes}",
+    ]
+
+    if backend_cfg:
+        # Stringify as JSON
+        command.extend(["--backend-config", json.dumps(backend_cfg)])
+
+    if verbose:
+        command.extend(["--verbose"])
+
+    if config_overrides:
+        command.extend(["--run-config", f"{' '.join(config_overrides)}"])
+
+    # Run the simulation
+    subprocess.run(
+        command,
+        check=True,
+        text=True,
+    )

flwr/cli/stop.py

@@ -0,0 +1,130 @@
+# 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 `stop` command."""
+
+
+import io
+import json
+from pathlib import Path
+from typing import Annotated, Optional
+
+import typer
+from rich.console import Console
+
+from flwr.cli.config_utils import (
+    exit_if_no_address,
+    load_and_validate,
+    process_loaded_project_config,
+    validate_federation_in_project_config,
+)
+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
+from flwr.proto.exec_pb2_grpc import ExecStub
+
+from .utils import init_channel, try_obtain_cli_auth_plugin, unauthenticated_exc_handler
+
+
+def stop(  # pylint: disable=R0914
+    run_id: Annotated[  # pylint: disable=unused-argument
+        int,
+        typer.Argument(help="The Flower run ID to stop"),
+    ],
+    app: Annotated[
+        Path,
+        typer.Argument(help="Path of the Flower project"),
+    ] = Path("."),
+    federation: Annotated[
+        Optional[str],
+        typer.Argument(help="Name of the federation"),
+    ] = None,
+    output_format: Annotated[
+        str,
+        typer.Option(
+            "--format",
+            case_sensitive=False,
+            help="Format output using 'default' view or 'json'",
+        ),
+    ] = CliOutputFormat.DEFAULT,
+) -> None:
+    """Stop a run."""
+    suppress_output = output_format == CliOutputFormat.JSON
+    captured_output = io.StringIO()
+    try:
+        if suppress_output:
+            redirect_output(captured_output)
+
+        # 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 = process_loaded_project_config(config, errors, warnings)
+        federation, federation_config = validate_federation_in_project_config(
+            federation, config
+        )
+        exit_if_no_address(federation_config, "stop")
+
+        try:
+            auth_plugin = try_obtain_cli_auth_plugin(app, federation)
+            channel = init_channel(app, federation_config, auth_plugin)
+            stub = ExecStub(channel)  # pylint: disable=unused-variable # noqa: F841
+
+            typer.secho(f"✋ Stopping run ID {run_id}...", fg=typer.colors.GREEN)
+            _stop_run(stub=stub, run_id=run_id, output_format=output_format)
+
+        except ValueError as err:
+            typer.secho(
+                f"❌ {err}",
+                fg=typer.colors.RED,
+                bold=True,
+            )
+            raise typer.Exit(code=1) from err
+        finally:
+            channel.close()
+    except (typer.Exit, Exception) as err:  # pylint: disable=broad-except
+        if suppress_output:
+            restore_output()
+            e_message = captured_output.getvalue()
+            print_json_error(e_message, err)
+        else:
+            typer.secho(
+                f"{err}",
+                fg=typer.colors.RED,
+                bold=True,
+            )
+    finally:
+        if suppress_output:
+            restore_output()
+        captured_output.close()
+
+
+def _stop_run(stub: ExecStub, run_id: int, output_format: str) -> None:
+    """Stop a run."""
+    with unauthenticated_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)
+        if output_format == CliOutputFormat.JSON:
+            run_output = json.dumps(
+                {
+                    "success": True,
+                    "run-id": run_id,
+                }
+            )
+            restore_output()
+            Console().print_json(run_output)
+    else:
+        typer.secho(f"❌ Run {run_id} couldn't be stopped.", fg=typer.colors.RED)

flwr/cli/utils.py

@@ -14,25 +14,55 @@
 # ==============================================================================
 """Flower command line interface utils."""
 
-from typing import List, cast
 
+import hashlib
+import json
+import re
+from collections.abc import Iterator
+from contextlib import contextmanager
+from logging import DEBUG
+from pathlib import Path
+from typing import Any, Callable, Optional, Union, cast
+
+import grpc
 import typer
 
+from flwr.cli.cli_user_auth_interceptor import CliUserAuthInterceptor
+from flwr.common.auth_plugin import CliAuthPlugin
+from flwr.common.constant import AUTH_TYPE, CREDENTIALS_DIR, FLWR_DIR
+from flwr.common.grpc import GRPC_MAX_MESSAGE_LENGTH, create_channel
+from flwr.common.logger import log
+
+from .config_utils import validate_certificate_in_federation_config
+
+try:
+    from flwr.ee import get_cli_auth_plugins
+except ImportError:
 
-def prompt_text(text: str) -> str:
+    def get_cli_auth_plugins() -> dict[str, type[CliAuthPlugin]]:
+        """Return all CLI authentication plugins."""
+        raise NotImplementedError("No authentication plugins are currently supported.")
+
+
+def prompt_text(
+    text: str,
+    predicate: Callable[[str], bool] = lambda _: True,
+    default: Optional[str] = None,
+) -> str:
     """Ask user to enter text input."""
     while True:
         result = typer.prompt(
-            typer.style(f"\n💬 {text}", fg=typer.colors.MAGENTA, bold=True)
+            typer.style(f"\n💬 {text}", fg=typer.colors.MAGENTA, bold=True),
+            default=default,
         )
-        if len(result) > 0:
+        if predicate(result) and len(result) > 0:
             break
         print(typer.style("❌ Invalid entry", fg=typer.colors.RED, bold=True))
 
     return cast(str, result)
 
 
-def prompt_options(text: str, options: List[str]) -> str:
+def prompt_options(text: str, options: list[str]) -> str:
     """Ask user to select one of the given options and return the selected item."""
     # Turn options into a list with index as in " [ 0] quickstart-pytorch"
     options_formatted = [
@@ -65,3 +95,208 @@ def prompt_options(text: str, options: List[str]) -> str:
 
     result = options[int(index)]
     return result
+
+
+def is_valid_project_name(name: str) -> bool:
+    """Check if the given string is a valid Python project name.
+
+    A valid project name must start with a letter and can only contain letters, digits,
+    and hyphens.
+    """
+    if not name:
+        return False
+
+    # Check if the first character is a letter
+    if not name[0].isalpha():
+        return False
+
+    # Check if the rest of the characters are valid (letter, digit, or dash)
+    for char in name[1:]:
+        if not (char.isalnum() or char in "-"):
+            return False
+
+    return True
+
+
+def sanitize_project_name(name: str) -> str:
+    """Sanitize the given string to make it a valid Python project name.
+
+    This version replaces spaces, dots, slashes, and underscores with dashes, removes
+    any characters not allowed in Python project names, makes the string lowercase, and
+    ensures it starts with a valid character.
+    """
+    # Replace whitespace with '_'
+    name_with_hyphens = re.sub(r"[ ./_]", "-", name)
+
+    # Allowed characters in a module name: letters, digits, underscore
+    allowed_chars = set(
+        "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-"
+    )
+
+    # Make the string lowercase
+    sanitized_name = name_with_hyphens.lower()
+
+    # Remove any characters not allowed in Python module names
+    sanitized_name = "".join(c for c in sanitized_name if c in allowed_chars)
+
+    # Ensure the first character is a letter or underscore
+    while sanitized_name and (
+        sanitized_name[0].isdigit() or sanitized_name[0] not in allowed_chars
+    ):
+        sanitized_name = sanitized_name[1:]
+
+    return sanitized_name
+
+
+def get_sha256_hash(file_path_or_int: Union[Path, int]) -> str:
+    """Calculate the SHA-256 hash of a file."""
+    sha256 = hashlib.sha256()
+    if isinstance(file_path_or_int, Path):
+        with open(file_path_or_int, "rb") as f:
+            while True:
+                data = f.read(65536)  # Read in 64kB blocks
+                if not data:
+                    break
+                sha256.update(data)
+    elif isinstance(file_path_or_int, int):
+        sha256.update(str(file_path_or_int).encode())
+    return sha256.hexdigest()
+
+
+def get_user_auth_config_path(root_dir: Path, federation: str) -> Path:
+    """Return the path to the user auth config file.
+
+    Additionally, a `.gitignore` file will be created in the Flower directory to
+    include the `.credentials` folder to be excluded from git. If the `.gitignore`
+    file already exists, a warning will be displayed if the `.credentials` entry is
+    not found.
+    """
+    # Locate the credentials directory
+    abs_flwr_dir = root_dir.absolute() / FLWR_DIR
+    credentials_dir = abs_flwr_dir / CREDENTIALS_DIR
+    credentials_dir.mkdir(parents=True, exist_ok=True)
+
+    # Determine the absolute path of the Flower directory for .gitignore
+    gitignore_path = abs_flwr_dir / ".gitignore"
+    credential_entry = CREDENTIALS_DIR
+
+    try:
+        if gitignore_path.exists():
+            with open(gitignore_path, encoding="utf-8") as gitignore_file:
+                lines = gitignore_file.read().splitlines()
+
+            # Warn if .credentials is not already in .gitignore
+            if credential_entry not in lines:
+                typer.secho(
+                    f"`.gitignore` exists, but `{credential_entry}` entry not found. "
+                    "Consider adding it to your `.gitignore` to exclude Flower "
+                    "credentials from git.",
+                    fg=typer.colors.YELLOW,
+                    bold=True,
+                )
+        else:
+            typer.secho(
+                f"Creating a new `.gitignore` with `{credential_entry}` entry...",
+                fg=typer.colors.BLUE,
+            )
+            # Create a new .gitignore with .credentials
+            with open(gitignore_path, "w", encoding="utf-8") as gitignore_file:
+                gitignore_file.write(f"{credential_entry}\n")
+    except Exception as err:
+        typer.secho(
+            "❌ An error occurred while handling `.gitignore.` "
+            f"Please check the permissions of `{gitignore_path}` and try again.",
+            fg=typer.colors.RED,
+            bold=True,
+        )
+        raise typer.Exit(code=1) from err
+
+    return credentials_dir / f"{federation}.json"
+
+
+def try_obtain_cli_auth_plugin(
+    root_dir: Path,
+    federation: str,
+    auth_type: Optional[str] = None,
+) -> Optional[CliAuthPlugin]:
+    """Load the CLI-side user auth plugin for the given auth type."""
+    config_path = get_user_auth_config_path(root_dir, federation)
+
+    # Load the config file if it exists
+    json_file: dict[str, Any] = {}
+    if config_path.exists():
+        with config_path.open("r", encoding="utf-8") as file:
+            json_file = json.load(file)
+    # This is the case when the user auth is not enabled
+    elif auth_type is None:
+        return None
+
+    # Get the auth type from the config if not provided
+    if auth_type is None:
+        if AUTH_TYPE not in json_file:
+            return None
+        auth_type = json_file[AUTH_TYPE]
+
+    # Retrieve auth plugin class and instantiate it
+    try:
+        all_plugins: dict[str, type[CliAuthPlugin]] = get_cli_auth_plugins()
+        auth_plugin_class = all_plugins[auth_type]
+        return auth_plugin_class(config_path)
+    except KeyError:
+        typer.echo(f"❌ Unknown user authentication type: {auth_type}")
+        raise typer.Exit(code=1) from None
+    except ImportError:
+        typer.echo("❌ No authentication plugins are currently supported.")
+        raise typer.Exit(code=1) from None
+
+
+def init_channel(
+    app: Path, federation_config: dict[str, Any], auth_plugin: Optional[CliAuthPlugin]
+) -> grpc.Channel:
+    """Initialize gRPC channel to the Exec API."""
+
+    def on_channel_state_change(channel_connectivity: str) -> None:
+        """Log channel connectivity."""
+        log(DEBUG, channel_connectivity)
+
+    insecure, root_certificates_bytes = validate_certificate_in_federation_config(
+        app, federation_config
+    )
+
+    # Initialize the CLI-side user auth interceptor
+    interceptors: list[grpc.UnaryUnaryClientInterceptor] = []
+    if auth_plugin is not None:
+        auth_plugin.load_tokens()
+        interceptors = CliUserAuthInterceptor(auth_plugin)
+
+    # Create the gRPC channel
+    channel = create_channel(
+        server_address=federation_config["address"],
+        insecure=insecure,
+        root_certificates=root_certificates_bytes,
+        max_message_length=GRPC_MAX_MESSAGE_LENGTH,
+        interceptors=interceptors or None,
+    )
+    channel.subscribe(on_channel_state_change)
+    return channel
+
+
+@contextmanager
+def unauthenticated_exc_handler() -> Iterator[None]:
+    """Context manager to handle gRPC UNAUTHENTICATED errors.
+
+    It catches grpc.RpcError exceptions with UNAUTHENTICATED status, informs the user,
+    and exits the application. All other exceptions will be allowed to escape.
+    """
+    try:
+        yield
+    except grpc.RpcError as e:
+        if e.code() != grpc.StatusCode.UNAUTHENTICATED:
+            raise
+        typer.secho(
+            "❌ Authentication failed. Please run `flwr login`"
+            " to authenticate and try again.",
+            fg=typer.colors.RED,
+            bold=True,
+        )
+        raise typer.Exit(code=1) from None

flwr/client/__init__.py

@@ -15,20 +15,21 @@
 """Flower client."""
 
 
-from .app import run_client_app as run_client_app
 from .app import start_client as start_client
 from .app import start_numpy_client as start_numpy_client
 from .client import Client as Client
 from .client_app import ClientApp as ClientApp
 from .numpy_client import NumPyClient as NumPyClient
 from .typing import ClientFn as ClientFn
+from .typing import ClientFnExt as ClientFnExt
 
 __all__ = [
     "Client",
     "ClientApp",
     "ClientFn",
+    "ClientFnExt",
     "NumPyClient",
-    "run_client_app",
+    "mod",
     "start_client",
     "start_numpy_client",
 ]