flwr 1.21.0__py3-none-any.whl → 1.23.0__py3-none-any.whl

flwr/cli/login/login.py

@@ -20,6 +20,7 @@ from typing import Annotated, Optional
 
 import typer
 
+from flwr.cli.auth_plugin import LoginError, NoOpCliAuthPlugin
 from flwr.cli.config_utils import (
     exit_if_no_address,
     get_insecure_flag,
@@ -28,14 +29,19 @@ from flwr.cli.config_utils import (
     validate_federation_in_project_config,
 )
 from flwr.cli.constant import FEDERATION_CONFIG_HELP_MESSAGE
-from flwr.common.typing import UserAuthLoginDetails
+from flwr.common.typing import AccountAuthLoginDetails
 from flwr.proto.control_pb2 import (  # pylint: disable=E0611
     GetLoginDetailsRequest,
     GetLoginDetailsResponse,
 )
 from flwr.proto.control_pb2_grpc import ControlStub
 
-from ..utils import flwr_cli_grpc_exc_handler, init_channel, try_obtain_cli_auth_plugin
+from ..utils import (
+    account_auth_enabled,
+    flwr_cli_grpc_exc_handler,
+    init_channel,
+    load_cli_auth_plugin,
+)
 
 
 def login(  # pylint: disable=R0914
@@ -67,12 +73,13 @@ def login(  # pylint: disable=R0914
     )
     exit_if_no_address(federation_config, "login")
 
-    # Check if `enable-user-auth` is set to `true`
-    if not federation_config.get("enable-user-auth", False):
+    # Check if `enable-account-auth` is set to `true`
+
+    if not account_auth_enabled(federation_config):
         typer.secho(
-            f"❌ User authentication is not enabled for the federation '{federation}'. "
-            "To enable it, set `enable-user-auth = true` in the federation "
-            "configuration.",
+            "❌ Account authentication is not enabled for the federation "
+            f"'{federation}'. To enable it, set `enable-account-auth = true` "
+            "in the federation configuration.",
             fg=typer.colors.RED,
             bold=True,
         )
@@ -88,7 +95,7 @@ def login(  # pylint: disable=R0914
         )
         raise typer.Exit(code=1)
 
-    channel = init_channel(app, federation_config, None)
+    channel = init_channel(app, federation_config, NoOpCliAuthPlugin(Path()))
     stub = ControlStub(channel)
 
     login_request = GetLoginDetailsRequest()
@@ -96,28 +103,32 @@ def login(  # pylint: disable=R0914
         login_response: GetLoginDetailsResponse = stub.GetLoginDetails(login_request)
 
     # Get the auth plugin
-    auth_type = login_response.auth_type
-    auth_plugin = try_obtain_cli_auth_plugin(
-        app, federation, federation_config, auth_type
-    )
-    if auth_plugin is None:
-        typer.secho(
-            f'❌ Authentication type "{auth_type}" not found',
-            fg=typer.colors.RED,
-            bold=True,
-        )
-        raise typer.Exit(code=1)
+    authn_type = login_response.authn_type
+    auth_plugin = load_cli_auth_plugin(app, federation, federation_config, authn_type)
 
     # Login
-    details = UserAuthLoginDetails(
-        auth_type=login_response.auth_type,
+    details = AccountAuthLoginDetails(
+        authn_type=login_response.authn_type,
         device_code=login_response.device_code,
         verification_uri_complete=login_response.verification_uri_complete,
         expires_in=login_response.expires_in,
         interval=login_response.interval,
     )
-    with flwr_cli_grpc_exc_handler():
-        credentials = auth_plugin.login(details, stub)
+    try:
+        with flwr_cli_grpc_exc_handler():
+            credentials = auth_plugin.login(details, stub)
+        typer.secho(
+            "✅ Login successful.",
+            fg=typer.colors.GREEN,
+            bold=False,
+        )
+    except LoginError as e:
+        typer.secho(
+            f"❌ Login failed: {e.message}",
+            fg=typer.colors.RED,
+            bold=True,
+        )
+        raise typer.Exit(code=1) from None
 
     # Store the tokens
     auth_plugin.store_tokens(credentials)

flwr/cli/ls.py

@@ -19,7 +19,7 @@ import io
 import json
 from datetime import datetime, timedelta
 from pathlib import Path
-from typing import Annotated, Optional
+from typing import Annotated, Optional, cast
 
 import typer
 from rich.console import Console
@@ -44,12 +44,13 @@ from flwr.proto.control_pb2 import (  # pylint: disable=E0611
 )
 from flwr.proto.control_pb2_grpc import ControlStub
 
-from .utils import flwr_cli_grpc_exc_handler, init_channel, try_obtain_cli_auth_plugin
+from .utils import flwr_cli_grpc_exc_handler, init_channel, load_cli_auth_plugin
 
 _RunListType = tuple[int, str, str, str, str, str, str, str, str]
 
 
 def ls(  # pylint: disable=too-many-locals, too-many-branches, R0913, R0917
+    ctx: typer.Context,
     app: Annotated[
         Path,
         typer.Argument(help="Path of the Flower project"),
@@ -102,6 +103,9 @@ def ls(  # pylint: disable=too-many-locals, too-many-branches, R0913, R0917
 
     All timestamps follow ISO 8601, UTC and are formatted as ``YYYY-MM-DD HH:MM:SSZ``.
     """
+    # Resolve command used (list or ls)
+    command_name = cast(str, ctx.command.name) if ctx.command else "list"
+
     suppress_output = output_format == CliOutputFormat.JSON
     captured_output = io.StringIO()
     try:
@@ -116,14 +120,14 @@ def ls(  # pylint: disable=too-many-locals, too-many-branches, R0913, R0917
         federation, federation_config = validate_federation_in_project_config(
             federation, config, federation_config_overrides
         )
-        exit_if_no_address(federation_config, "ls")
+        exit_if_no_address(federation_config, command_name)
         channel = None
         try:
             if runs and run_id is not None:
                 raise ValueError(
                     "The options '--runs' and '--run-id' are mutually exclusive."
                 )
-            auth_plugin = try_obtain_cli_auth_plugin(app, federation, federation_config)
+            auth_plugin = load_cli_auth_plugin(app, federation, federation_config)
             channel = init_channel(app, federation_config, auth_plugin)
             stub = ControlStub(channel)
 
@@ -216,14 +220,14 @@ def _to_table(run_list: list[_RunListType]) -> Table:
 
     # Add columns
     table.add_column(
-        Text("Run ID", justify="center"), style="bright_white", overflow="fold"
+        Text("Run ID", justify="center"), style="bright_black", no_wrap=True
     )
-    table.add_column(Text("FAB", justify="center"), style="dim white")
+    table.add_column(Text("FAB", justify="center"), style="bright_black")
     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")
+    table.add_column(Text("Created At", justify="center"), style="bright_black")
+    table.add_column(Text("Running At", justify="center"), style="bright_black")
+    table.add_column(Text("Finished At", justify="center"), style="bright_black")
 
     for row in run_list:
         (

flwr/cli/new/new.py

@@ -15,14 +15,20 @@
 """Flower command line interface `new` command."""
 
 
+import io
+import json
 import re
+import zipfile
 from enum import Enum
 from pathlib import Path
 from string import Template
 from typing import Annotated, Optional
 
+import requests
 import typer
 
+from flwr.supercore.constant import APP_ID_PATTERN, PLATFORM_API_URL
+
 from ..utils import (
     is_valid_project_name,
     prompt_options,
@@ -35,15 +41,16 @@ class MlFramework(str, Enum):
     """Available frameworks."""
 
     PYTORCH = "PyTorch"
-    PYTORCH_MSG_API = "PyTorch (Message API)"
     TENSORFLOW = "TensorFlow"
     SKLEARN = "sklearn"
     HUGGINGFACE = "HuggingFace"
     JAX = "JAX"
     MLX = "MLX"
     NUMPY = "NumPy"
+    XGBOOST = "XGBoost"
     FLOWERTUNE = "FlowerTune"
     BASELINE = "Flower Baseline"
+    PYTORCH_LEGACY_API = "PyTorch (Legacy API, deprecated)"
 
 
 class LlmChallengeName(str, Enum):
@@ -92,6 +99,180 @@ def render_and_create(file_path: Path, template: str, context: dict[str, str]) -
     create_file(file_path, content)
 
 
+def print_success_prompt(
+    package_name: str, llm_challenge_str: Optional[str] = None
+) -> None:
+    """Print styled setup instructions for running a new Flower App after creation."""
+    prompt = typer.style(
+        "🎊 Flower App creation successful.\n\n"
+        "To run your Flower App, first install its dependencies:\n\n",
+        fg=typer.colors.GREEN,
+        bold=True,
+    )
+
+    _add = "	huggingface-cli login\n" if llm_challenge_str else ""
+
+    prompt += typer.style(
+        f"	cd {package_name} && pip install -e .\n" + _add + "\n",
+        fg=typer.colors.BRIGHT_CYAN,
+        bold=True,
+    )
+
+    prompt += typer.style(
+        "then, run the app:\n\n ",
+        fg=typer.colors.GREEN,
+        bold=True,
+    )
+
+    prompt += typer.style(
+        "\tflwr run .\n\n",
+        fg=typer.colors.BRIGHT_CYAN,
+        bold=True,
+    )
+
+    prompt += typer.style(
+        "💡 Check the README in your app directory to learn how to\n"
+        "customize it and how to run it using the Deployment Runtime.\n",
+        fg=typer.colors.GREEN,
+        bold=True,
+    )
+
+    print(prompt)
+
+
+# Security: prevent zip-slip
+def _safe_extract_zip(zf: zipfile.ZipFile, dest_dir: Path) -> None:
+    """Extract ZIP file into destination directory."""
+    dest_dir = dest_dir.resolve()
+
+    def _is_within_directory(base: Path, target: Path) -> bool:
+        try:
+            target.relative_to(base)
+            return True
+        except ValueError:
+            return False
+
+    for member in zf.infolist():
+        # Skip directory placeholders;
+        # ZipInfo can represent them as names ending with '/'.
+        if member.is_dir():
+            target_path = (dest_dir / member.filename).resolve()
+            if not _is_within_directory(dest_dir, target_path):
+                raise ValueError(f"Unsafe path in zip: {member.filename}")
+            target_path.mkdir(parents=True, exist_ok=True)
+            continue
+
+        # Files
+        target_path = (dest_dir / member.filename).resolve()
+        if not _is_within_directory(dest_dir, target_path):
+            raise ValueError(f"Unsafe path in zip: {member.filename}")
+
+        # Ensure parent exists
+        target_path.parent.mkdir(parents=True, exist_ok=True)
+
+        # Extract
+        with zf.open(member, "r") as src, open(target_path, "wb") as dst:
+            dst.write(src.read())
+
+
+def _download_zip_to_memory(presigned_url: str) -> io.BytesIO:
+    """Download ZIP file from Platform API to memory."""
+    try:
+        r = requests.get(presigned_url, timeout=60)
+        r.raise_for_status()
+    except requests.RequestException as e:
+        raise typer.BadParameter(f"ZIP download failed: {e}") from e
+
+    buf = io.BytesIO(r.content)
+    # Validate it's a zip
+    if not zipfile.is_zipfile(buf):
+        raise typer.BadParameter("Downloaded file is not a valid ZIP")
+    buf.seek(0)
+    return buf
+
+
+def _request_download_link(identifier: str) -> str:
+    """Request download link from Flower platform API."""
+    url = f"{PLATFORM_API_URL}/hub/fetch-zip"
+    headers = {
+        "Content-Type": "application/json",
+        "Accept": "application/json",
+    }
+    body = {
+        "identifier": identifier,  # send raw string of identifier
+    }
+
+    try:
+        resp = requests.post(url, headers=headers, data=json.dumps(body), timeout=20)
+    except requests.RequestException as e:
+        raise typer.BadParameter(f"Unable to connect to Platform API: {e}") from e
+
+    if resp.status_code == 404:
+        raise typer.BadParameter(f"'{identifier}' not found in Platform API")
+    if not resp.ok:
+        raise typer.BadParameter(
+            f"Platform API request failed with "
+            f"status {resp.status_code}. Details: {resp.text}"
+        )
+
+    data = resp.json()
+    if "zip_url" not in data:
+        raise typer.BadParameter("Invalid response from Platform API")
+    return str(data["zip_url"])
+
+
+def download_remote_app_via_api(identifier: str) -> None:
+    """Download App from Platform API."""
+    # Parse @user/app just to derive local dir name
+    m = re.match(APP_ID_PATTERN, identifier)
+    if not m:
+        raise typer.BadParameter(
+            "Invalid remote app ID. Expected format: '@user_name/app_name'."
+        )
+    app_name = m.group("app")
+
+    project_dir = Path.cwd() / app_name
+    if project_dir.exists():
+        if not typer.confirm(
+            typer.style(
+                f"\n💬 {app_name} already exists, do you want to override it?",
+                fg=typer.colors.MAGENTA,
+                bold=True,
+            )
+        ):
+            return
+
+    print(
+        typer.style(
+            f"\n🔗 Requesting download link for {identifier}...",
+            fg=typer.colors.GREEN,
+            bold=True,
+        )
+    )
+    presigned_url = _request_download_link(identifier)
+
+    print(
+        typer.style(
+            "⬇️  Downloading ZIP into memory...",
+            fg=typer.colors.GREEN,
+            bold=True,
+        )
+    )
+    zip_buf = _download_zip_to_memory(presigned_url)
+
+    print(
+        typer.style(
+            f"📦 Unpacking into {project_dir}...",
+            fg=typer.colors.GREEN,
+            bold=True,
+        )
+    )
+    with zipfile.ZipFile(zip_buf) as zf:
+        _safe_extract_zip(zf, Path.cwd())
+
+    print_success_prompt(app_name)
+
+
 # pylint: disable=too-many-locals,too-many-branches,too-many-statements
 def new(
     app_name: Annotated[
@@ -110,6 +291,12 @@ def new(
     """Create new Flower App."""
     if app_name is None:
         app_name = prompt_text("Please provide the app name")
+
+    # Download remote app
+    if app_name and app_name.startswith("@"):
+        download_remote_app_via_api(app_name)
+        return
+
     if not is_valid_project_name(app_name):
         app_name = prompt_text(
             "Please provide a name that only contains "
@@ -155,8 +342,8 @@ def new(
     if framework_str == MlFramework.BASELINE:
         framework_str = "baseline"
 
-    if framework_str == MlFramework.PYTORCH_MSG_API:
-        framework_str = "pytorch_msg_api"
+    if framework_str == MlFramework.PYTORCH_LEGACY_API:
+        framework_str = "pytorch_legacy_api"
 
     print(
         typer.style(
@@ -201,7 +388,7 @@ def new(
         }
 
         # Challenge specific context
-        fraction_fit = "0.2" if llm_challenge_str == "code" else "0.1"
+        fraction_train = "0.2" if llm_challenge_str == "code" else "0.1"
         if llm_challenge_str == "generalnlp":
             challenge_name = "General NLP"
             num_clients = "20"
@@ -220,7 +407,7 @@ def new(
             dataset_name = "flwrlabs/code-alpaca-20k"
 
         context["llm_challenge_str"] = llm_challenge_str
-        context["fraction_fit"] = fraction_fit
+        context["fraction_train"] = fraction_train
         context["challenge_name"] = challenge_name
         context["num_clients"] = num_clients
         context["dataset_name"] = dataset_name
@@ -247,14 +434,15 @@ def new(
             MlFramework.TENSORFLOW.value,
             MlFramework.SKLEARN.value,
             MlFramework.NUMPY.value,
-            "pytorch_msg_api",
+            MlFramework.XGBOOST.value,
+            "pytorch_legacy_api",
         ]
         if framework_str in frameworks_with_tasks:
             files[f"{import_name}/task.py"] = {
                 "template": f"app/code/task.{template_name}.py.tpl"
             }
 
-        if framework_str == "pytorch_msg_api":
+        if framework_str == "pytorch_legacy_api":
             # Use custom __init__ that better captures name of framework
             files[f"{import_name}/__init__.py"] = {
                 "template": f"app/code/__init__.{framework_str}.py.tpl"
@@ -280,38 +468,4 @@ def new(
             context=context,
         )
 
-    prompt = typer.style(
-        "🎊 Flower App creation successful.\n\n"
-        "To run your Flower App, first install its dependencies:\n\n",
-        fg=typer.colors.GREEN,
-        bold=True,
-    )
-
-    _add = "	huggingface-cli login\n" if llm_challenge_str else ""
-
-    prompt += typer.style(
-        f"	cd {package_name} && pip install -e .\n" + _add + "\n",
-        fg=typer.colors.BRIGHT_CYAN,
-        bold=True,
-    )
-
-    prompt += typer.style(
-        "then, run the app:\n\n ",
-        fg=typer.colors.GREEN,
-        bold=True,
-    )
-
-    prompt += typer.style(
-        "\tflwr run .\n\n",
-        fg=typer.colors.BRIGHT_CYAN,
-        bold=True,
-    )
-
-    prompt += typer.style(
-        "💡 Check the README in your app directory to learn how to\n"
-        "customize it and how to run it using the Deployment Runtime.\n",
-        fg=typer.colors.GREEN,
-        bold=True,
-    )
-
-    print(prompt)
+    print_success_prompt(package_name, llm_challenge_str)

flwr/cli/new/templates/app/README.flowertune.md.tpl

@@ -26,7 +26,7 @@ pip install -e .
 ## Experimental setup
 
 The dataset is divided into $num_clients partitions in an IID fashion, a partition is assigned to each ClientApp.
-We randomly sample a fraction ($fraction_fit) of the total nodes to participate in each round, for a total of `200` rounds.
+We randomly sample a fraction ($fraction_train) of the total nodes to participate in each round, for a total of `200` rounds.
 All settings are defined in `pyproject.toml`.
 
 > [!IMPORTANT]

flwr/cli/new/templates/app/code/client.baseline.py.tpl

@@ -1,58 +1,75 @@
 """$project_name: A Flower Baseline."""
 
 import torch
-from flwr.client import ClientApp, NumPyClient
-from flwr.common import Context
+from flwr.app import ArrayRecord, Context, Message, MetricRecord, RecordDict
+from flwr.clientapp import ClientApp
 
 from $import_name.dataset import load_data
-from $import_name.model import Net, get_weights, set_weights, test, train
-
-
-class FlowerClient(NumPyClient):
-    """A class defining the client."""
-
-    def __init__(self, net, trainloader, valloader, local_epochs):
-        self.net = net
-        self.trainloader = trainloader
-        self.valloader = valloader
-        self.local_epochs = local_epochs
-        self.device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
-        self.net.to(self.device)
-
-    def fit(self, parameters, config):
-        """Traim model using this client's data."""
-        set_weights(self.net, parameters)
-        train_loss = train(
-            self.net,
-            self.trainloader,
-            self.local_epochs,
-            self.device,
-        )
-        return (
-            get_weights(self.net),
-            len(self.trainloader.dataset),
-            {"train_loss": train_loss},
-        )
-
-    def evaluate(self, parameters, config):
-        """Evaluate model using this client's data."""
-        set_weights(self.net, parameters)
-        loss, accuracy = test(self.net, self.valloader, self.device)
-        return loss, len(self.valloader.dataset), {"accuracy": accuracy}
-
-
-def client_fn(context: Context):
-    """Construct a Client that will be run in a ClientApp."""
-    # Load model and data
-    net = Net()
+from $import_name.model import Net
+from $import_name.model import test as test_fn
+from $import_name.model import train as train_fn
+
+# Flower ClientApp
+app = ClientApp()
+
+
+@app.train()
+def train(msg: Message, context: Context):
+    """Train the model on local data."""
+
+    # Load the model and initialize it with the received weights
+    model = Net()
+    model.load_state_dict(msg.content["arrays"].to_torch_state_dict())
+    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+
+    # Load the data
     partition_id = int(context.node_config["partition-id"])
     num_partitions = int(context.node_config["num-partitions"])
-    trainloader, valloader = load_data(partition_id, num_partitions)
+    trainloader, _ = load_data(partition_id, num_partitions)
     local_epochs = context.run_config["local-epochs"]
 
-    # Return Client instance
-    return FlowerClient(net, trainloader, valloader, local_epochs).to_client()
+    # Call the training function
+    train_loss = train_fn(
+        model,
+        trainloader,
+        local_epochs,
+        device,
+    )
 
+    # Construct and return reply Message
+    model_record = ArrayRecord(model.state_dict())
+    metrics = {
+        "train_loss": train_loss,
+        "num-examples": len(trainloader.dataset),
+    }
+    metric_record = MetricRecord(metrics)
+    content = RecordDict({"arrays": model_record, "metrics": metric_record})
+    return Message(content=content, reply_to=msg)
 
-# Flower ClientApp
-app = ClientApp(client_fn)
+
+@app.evaluate()
+def evaluate(msg: Message, context: Context):
+    """Evaluate the model on local data."""
+
+    # Load the model and initialize it with the received weights
+    model = Net()
+    model.load_state_dict(msg.content["arrays"].to_torch_state_dict())
+    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+
+    # Load the data
+    partition_id = int(context.node_config["partition-id"])
+    num_partitions = int(context.node_config["num-partitions"])
+    _, valloader = load_data(partition_id, num_partitions)
+
+    # Call the evaluation function
+    eval_loss, eval_acc = test_fn(model, valloader, device)
+
+    # Construct and return reply Message
+    metrics = {
+        "eval_loss": eval_loss,
+        "eval_acc": eval_acc,
+        "num-examples": len(valloader.dataset),
+    }
+    metric_record = MetricRecord(metrics)
+    content = RecordDict({"metrics": metric_record})
+    return Message(content=content, reply_to=msg)