flwr-nightly 1.10.0.dev20240707__py3-none-any.whl → 1.11.0.dev20240724__py3-none-any.whl

flwr/cli/build.py

@@ -20,6 +20,7 @@ from pathlib import Path
 from typing import Optional
 
 import pathspec
+import tomli_w
 import typer
 from typing_extensions import Annotated
 
@@ -85,7 +86,7 @@ def build(
 
     # Set the name of the zip file
     fab_filename = (
-        f"{conf['flower']['publisher']}"
+        f"{conf['tool']['flwr']['app']['publisher']}"
         f".{directory.name}"
         f".{conf['project']['version'].replace('.', '-')}.fab"
     )
@@ -93,15 +94,28 @@ def build(
 
     allowed_extensions = {".py", ".toml", ".md"}
 
+    # Remove the 'federations' field from 'tool.flwr' if it exists
+    if (
+        "tool" in conf
+        and "flwr" in conf["tool"]
+        and "federations" in conf["tool"]["flwr"]
+    ):
+        del conf["tool"]["flwr"]["federations"]
+
+    toml_contents = tomli_w.dumps(conf)
+
     with zipfile.ZipFile(fab_filename, "w", zipfile.ZIP_DEFLATED) as fab_file:
+        fab_file.writestr("pyproject.toml", toml_contents)
+
+        # Continue with adding other files
         for root, _, files in os.walk(directory, topdown=True):
-            # Filter directories and files based on .gitignore
             files = [
                 f
                 for f in files
                 if not ignore_spec.match_file(Path(root) / f)
                 and f != fab_filename
                 and Path(f).suffix in allowed_extensions
+                and f != "pyproject.toml"  # Exclude the original pyproject.toml
             ]
 
             for file in files:

flwr/cli/config_utils.py

@@ -17,11 +17,12 @@
 import zipfile
 from io import BytesIO
 from pathlib import Path
-from typing import IO, Any, Dict, List, Optional, Tuple, Union
+from typing import IO, Any, Dict, List, Optional, Tuple, Union, get_args
 
 import tomli
 
 from flwr.common import object_ref
+from flwr.common.typing import UserConfigValue
 
 
 def get_fab_metadata(fab_file: Union[Path, bytes]) -> Tuple[str, str]:
@@ -60,7 +61,7 @@ def get_fab_metadata(fab_file: Union[Path, bytes]) -> Tuple[str, str]:
 
         return (
             conf["project"]["version"],
-            f"{conf['flower']['publisher']}/{conf['project']['name']}",
+            f"{conf['tool']['flwr']['app']['publisher']}/{conf['project']['name']}",
         )
 
 
@@ -76,6 +77,9 @@ def load_and_validate(
         A tuple with the optional config in case it exists and is valid
         and associated errors and warnings.
     """
+    if path is None:
+        path = Path.cwd() / "pyproject.toml"
+
     config = load(path)
 
     if config is None:
@@ -85,7 +89,7 @@ def load_and_validate(
         ]
         return (None, errors, [])
 
-    is_valid, errors, warnings = validate(config, check_module)
+    is_valid, errors, warnings = validate(config, check_module, path.parent)
 
     if not is_valid:
         return (None, errors, warnings)
@@ -93,14 +97,8 @@ def load_and_validate(
     return (config, errors, warnings)
 
 
-def load(path: Optional[Path] = None) -> Optional[Dict[str, Any]]:
+def load(toml_path: Path) -> Optional[Dict[str, Any]]:
     """Load pyproject.toml and return as dict."""
-    if path is None:
-        cur_dir = Path.cwd()
-        toml_path = cur_dir / "pyproject.toml"
-    else:
-        toml_path = path
-
     if not toml_path.is_file():
         return None
 
@@ -108,6 +106,17 @@ def load(path: Optional[Path] = None) -> Optional[Dict[str, Any]]:
         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."""
@@ -128,24 +137,36 @@ def validate_fields(config: Dict[str, Any]) -> Tuple[bool, List[str], List[str]]
         if "authors" not in config["project"]:
             warnings.append('Recommended property "authors" missing in [project]')
 
-    if "flower" not in config:
-        errors.append("Missing [flower] section")
+    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["flower"]:
-            errors.append('Property "publisher" missing in [flower]')
-        if "components" not in config["flower"]:
-            errors.append("Missing [flower.components] section")
+        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["flower"]["components"]:
-                errors.append('Property "serverapp" missing in [flower.components]')
-            if "clientapp" not in config["flower"]["components"]:
-                errors.append('Property "clientapp" missing in [flower.components]')
+            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
+    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)
@@ -154,16 +175,15 @@ def validate(
         return False, errors, warnings
 
     # Validate serverapp
-    is_valid, reason = object_ref.validate(
-        config["flower"]["components"]["serverapp"], check_module
-    )
+    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
-    is_valid, reason = object_ref.validate(
-        config["flower"]["components"]["clientapp"], check_module
-    )
+    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], []

flwr/cli/install.py

@@ -16,6 +16,7 @@
 
 
 import shutil
+import subprocess
 import tempfile
 import zipfile
 from io import BytesIO
@@ -149,7 +150,7 @@ def validate_and_install(
         )
         raise typer.Exit(code=1)
 
-    publisher = config["flower"]["publisher"]
+    publisher = config["tool"]["flwr"]["app"]["publisher"]
     project_name = config["project"]["name"]
     version = config["project"]["version"]
 
@@ -192,6 +193,21 @@ def validate_and_install(
         else:
             shutil.copy2(item, install_dir / item.name)
 
+    try:
+        subprocess.run(
+            ["pip", "install", "-e", install_dir, "--no-deps"],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+    except subprocess.CalledProcessError as e:
+        typer.secho(
+            f"❌ Failed to `pip install` package(s) from {install_dir}:\n{e.stderr}",
+            fg=typer.colors.RED,
+            bold=True,
+        )
+        raise typer.Exit(code=1) from e
+
     typer.secho(
         f"🎊 Successfully installed {project_name} to {install_dir}.",
         fg=typer.colors.GREEN,

flwr/cli/new/new.py

@@ -14,9 +14,9 @@
 # ==============================================================================
 """Flower command line interface `new` command."""
 
-import os
 import re
 from enum import Enum
+from pathlib import Path
 from string import Template
 from typing import Dict, Optional
 
@@ -38,7 +38,7 @@ class MlFramework(str, Enum):
     PYTORCH = "PyTorch"
     TENSORFLOW = "TensorFlow"
     JAX = "JAX"
-    HUGGINGFACE = "HF"
+    HUGGINGFACE = "HuggingFace"
     MLX = "MLX"
     SKLEARN = "sklearn"
     FLOWERTUNE = "FlowerTune"
@@ -59,10 +59,10 @@ class TemplateNotFound(Exception):
 
 def load_template(name: str) -> str:
     """Load template from template directory and return as text."""
-    tpl_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), "templates"))
-    tpl_file_path = os.path.join(tpl_dir, name)
+    tpl_dir = (Path(__file__).parent / "templates").absolute()
+    tpl_file_path = tpl_dir / name
 
-    if not os.path.isfile(tpl_file_path):
+    if not tpl_file_path.is_file():
         raise TemplateNotFound(f"Template '{name}' not found")
 
     with open(tpl_file_path, encoding="utf-8") as tpl_file:
@@ -78,14 +78,13 @@ def render_template(template: str, data: Dict[str, str]) -> str:
     return tpl.template
 
 
-def create_file(file_path: str, content: str) -> None:
+def create_file(file_path: Path, content: str) -> None:
     """Create file including all nessecary directories and write content into file."""
-    os.makedirs(os.path.dirname(file_path), exist_ok=True)
-    with open(file_path, "w", encoding="utf-8") as f:
-        f.write(content)
+    file_path.parent.mkdir(exist_ok=True)
+    file_path.write_text(content)
 
 
-def render_and_create(file_path: str, template: str, context: Dict[str, str]) -> None:
+def render_and_create(file_path: Path, template: str, context: Dict[str, str]) -> None:
     """Render template and write to file."""
     content = render_template(template, context)
     create_file(file_path, content)
@@ -117,6 +116,21 @@ def new(
             default=sanitize_project_name(project_name),
         )
 
+    # Set project directory path
+    package_name = re.sub(r"[-_.]+", "-", project_name).lower()
+    import_name = package_name.replace("-", "_")
+    project_dir = Path.cwd() / package_name
+
+    if project_dir.exists():
+        if not typer.confirm(
+            typer.style(
+                f"\n💬 {project_name} already exists, do you want to override it?",
+                fg=typer.colors.MAGENTA,
+                bold=True,
+            )
+        ):
+            return
+
     if username is None:
         username = prompt_text("Please provide your Flower username")
 
@@ -136,6 +150,7 @@ def new(
 
     framework_str = framework_str.lower()
 
+    llm_challenge_str = None
     if framework_str == "flowertune":
         llm_challenge_value = prompt_options(
             "Please select LLM challenge by typing in the number",
@@ -157,12 +172,6 @@ def new(
         )
     )
 
-    # Set project directory path
-    cwd = os.getcwd()
-    package_name = re.sub(r"[-_.]+", "-", project_name).lower()
-    import_name = package_name.replace("-", "_")
-    project_dir = os.path.join(cwd, package_name)
-
     context = {
         "project_name": project_name,
         "package_name": package_name,
@@ -171,7 +180,7 @@ def new(
     }
 
     # List of files to render
-    if framework_str == "flowertune":
+    if llm_challenge_str:
         files = {
             ".gitignore": {"template": "app/.gitignore.tpl"},
             "pyproject.toml": {"template": f"app/pyproject.{framework_str}.toml.tpl"},
@@ -228,10 +237,10 @@ def new(
             "README.md": {"template": "app/README.md.tpl"},
             "pyproject.toml": {"template": f"app/pyproject.{framework_str}.toml.tpl"},
             f"{import_name}/__init__.py": {"template": "app/code/__init__.py.tpl"},
-            f"{import_name}/server.py": {
+            f"{import_name}/server_app.py": {
                 "template": f"app/code/server.{framework_str}.py.tpl"
             },
-            f"{import_name}/client.py": {
+            f"{import_name}/client_app.py": {
                 "template": f"app/code/client.{framework_str}.py.tpl"
             },
         }
@@ -251,7 +260,7 @@ def new(
 
     for file_path, value in files.items():
         render_and_create(
-            file_path=os.path.join(project_dir, file_path),
+            file_path=project_dir / file_path,
             template=value["template"],
             context=context,
         )
@@ -264,9 +273,11 @@ def new(
             bold=True,
         )
     )
+
+    _add = "	huggingface-cli login\n" if framework_str == "flowertune" else ""
     print(
         typer.style(
-            f"	cd {package_name}\n" + "	pip install -e .\n	flwr run\n",
+            f"	cd {package_name}\n" + "	pip install -e .\n" + _add + "	flwr run\n",
             fg=typer.colors.BRIGHT_CYAN,
             bold=True,
         )

flwr/cli/new/templates/app/code/{client.hf.py.tpl → client.huggingface.py.tpl}

@@ -1,6 +1,7 @@
 """$project_name: A Flower / HuggingFace Transformers app."""
 
 from flwr.client import ClientApp, NumPyClient
+from flwr.common import Context
 from transformers import AutoModelForSequenceClassification
 
 from $import_name.task import (
@@ -16,10 +17,11 @@ from $import_name.task import (
 
 # Flower client
 class FlowerClient(NumPyClient):
-    def __init__(self, net, trainloader, testloader):
+    def __init__(self, net, trainloader, testloader, local_epochs):
         self.net = net
         self.trainloader = trainloader
         self.testloader = testloader
+        self.local_epochs = local_epochs
 
     def get_parameters(self, config):
         return get_weights(self.net)
@@ -29,7 +31,11 @@ class FlowerClient(NumPyClient):
 
     def fit(self, parameters, config):
         self.set_parameters(parameters)
-        train(self.net, self.trainloader, epochs=1)
+        train(
+            self.net,
+            self.trainloader,
+            epochs=self.local_epochs,
+        )
         return self.get_parameters(config={}), len(self.trainloader), {}
 
     def evaluate(self, parameters, config):
@@ -38,15 +44,19 @@ class FlowerClient(NumPyClient):
         return float(loss), len(self.testloader), {"accuracy": accuracy}
 
 
-def client_fn(cid):
+def client_fn(context: Context):
     # Load model and data
     net = AutoModelForSequenceClassification.from_pretrained(
         CHECKPOINT, num_labels=2
     ).to(DEVICE)
-    trainloader, valloader = load_data(int(cid), 2)
+
+    partition_id = context.node_config["partition-id"]
+    num_partitions = context.node_config["num-partitions"]
+    trainloader, valloader = load_data(partition_id, num_partitions)
+    local_epochs = context.run_config["local-epochs"]
 
     # Return Client instance
-    return FlowerClient(net, trainloader, valloader).to_client()
+    return FlowerClient(net, trainloader, valloader, local_epochs).to_client()
 
 
 # Flower ClientApp

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

@@ -2,6 +2,7 @@
 
 import jax
 from flwr.client import NumPyClient, ClientApp
+from flwr.common import Context
 
 from $import_name.task import (
     evaluation,
@@ -44,7 +45,7 @@ class FlowerClient(NumPyClient):
         )
         return float(loss), num_examples, {"loss": float(loss)}
 
-def client_fn(cid):
+def client_fn(context: Context):
     # Return Client instance
     return FlowerClient().to_client()
 

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

@@ -4,6 +4,7 @@ import mlx.core as mx
 import mlx.nn as nn
 import mlx.optimizers as optim
 from flwr.client import NumPyClient, ClientApp
+from flwr.common import Context
 
 from $import_name.task import (
     batch_iterate,
@@ -18,18 +19,29 @@ from $import_name.task import (
 
 # Define Flower Client and client_fn
 class FlowerClient(NumPyClient):
-    def __init__(self, data):
-        num_layers = 2
-        hidden_dim = 32
-        num_classes = 10
-        batch_size = 256
-        num_epochs = 1
-        learning_rate = 1e-1
+    def __init__(
+        self,
+        data,
+        num_layers,
+        hidden_dim,
+        num_classes,
+        batch_size,
+        learning_rate,
+        num_epochs,
+    ):
+        self.num_layers = num_layers
+        self.hidden_dim = hidden_dim
+        self.num_classes = num_classes
+        self.batch_size = batch_size
+        self.learning_rate = learning_rate
+        self.num_epochs = num_epochs
 
         self.train_images, self.train_labels, self.test_images, self.test_labels = data
-        self.model = MLP(num_layers, self.train_images.shape[-1], hidden_dim, num_classes) 
-        self.optimizer = optim.SGD(learning_rate=learning_rate) 
-        self.loss_and_grad_fn = nn.value_and_grad(self.model, loss_fn) 
+        self.model = MLP(
+            num_layers, self.train_images.shape[-1], hidden_dim, num_classes
+        )
+        self.optimizer = optim.SGD(learning_rate=learning_rate)
+        self.loss_and_grad_fn = nn.value_and_grad(self.model, loss_fn)
         self.num_epochs = num_epochs
         self.batch_size = batch_size
 
@@ -57,11 +69,22 @@ class FlowerClient(NumPyClient):
         return loss.item(), len(self.test_images), {"accuracy": accuracy.item()}
 
 
-def client_fn(cid):
-    data = load_data(int(cid), 2)
+def client_fn(context: Context):
+    partition_id = context.node_config["partition-id"]
+    num_partitions = context.node_config["num-partitions"]
+    data = load_data(partition_id, num_partitions)
+
+    num_layers = context.run_config["num-layers"]
+    hidden_dim = context.run_config["hidden-dim"]
+    num_classes = 10
+    batch_size = context.run_config["batch-size"]
+    learning_rate = context.run_config["lr"]
+    num_epochs = context.run_config["local-epochs"]
 
     # Return Client instance
-    return FlowerClient(data).to_client()
+    return FlowerClient(
+        data, num_layers, hidden_dim, num_classes, batch_size, learning_rate, num_epochs
+    ).to_client()
 
 
 # Flower ClientApp

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

@@ -1,6 +1,7 @@
 """$project_name: A Flower / NumPy app."""
 
 from flwr.client import NumPyClient, ClientApp
+from flwr.common import Context
 import numpy as np
 
 
@@ -15,7 +16,7 @@ class FlowerClient(NumPyClient):
         return float(0.0), 1, {"accuracy": float(1.0)}
 
 
-def client_fn(cid: str):
+def client_fn(context: Context):
     return FlowerClient().to_client()
 
 

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

@@ -1,6 +1,7 @@
 """$project_name: A Flower / PyTorch app."""
 
 from flwr.client import NumPyClient, ClientApp
+from flwr.common import Context
 
 from $import_name.task import (
     Net,
@@ -15,14 +16,21 @@ from $import_name.task import (
 
 # Define Flower Client and client_fn
 class FlowerClient(NumPyClient):
-    def __init__(self, net, trainloader, valloader):
+    def __init__(self, net, trainloader, valloader, local_epochs):
         self.net = net
         self.trainloader = trainloader
         self.valloader = valloader
+        self.local_epochs = local_epochs
 
     def fit(self, parameters, config):
         set_weights(self.net, parameters)
-        results = train(self.net, self.trainloader, self.valloader, 1, DEVICE)
+        results = train(
+            self.net,
+            self.trainloader,
+            self.valloader,
+            self.local_epochs,
+            DEVICE,
+        )
         return get_weights(self.net), len(self.trainloader.dataset), results
 
     def evaluate(self, parameters, config):
@@ -31,13 +39,16 @@ class FlowerClient(NumPyClient):
         return loss, len(self.valloader.dataset), {"accuracy": accuracy}
 
 
-def client_fn(cid):
+def client_fn(context: Context):
     # Load model and data
     net = Net().to(DEVICE)
-    trainloader, valloader = load_data(int(cid), 2)
+    partition_id = context.node_config["partition-id"]
+    num_partitions = context.node_config["num-partitions"]
+    trainloader, valloader = load_data(partition_id, num_partitions)
+    local_epochs = context.run_config["local-epochs"]
 
     # Return Client instance
-    return FlowerClient(net, trainloader, valloader).to_client()
+    return FlowerClient(net, trainloader, valloader, local_epochs).to_client()
 
 
 # Flower ClientApp

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

@@ -4,6 +4,7 @@ import warnings
 
 import numpy as np
 from flwr.client import NumPyClient, ClientApp
+from flwr.common import Context
 from flwr_datasets import FederatedDataset
 from sklearn.linear_model import LogisticRegression
 from sklearn.metrics import log_loss
@@ -66,10 +67,12 @@ class FlowerClient(NumPyClient):
 
         return loss, len(self.X_test), {"accuracy": accuracy}
 
-fds = FederatedDataset(dataset="mnist", partitioners={"train": 2})
 
-def client_fn(cid: str):
-    dataset = fds.load_partition(int(cid), "train").with_format("numpy")
+def client_fn(context: Context):
+    partition_id = context.node_config["partition-id"]
+    num_partitions = context.node_config["num-partitions"]
+    fds = FederatedDataset(dataset="mnist", partitioners={"train": num_partitions})
+    dataset = fds.load_partition(partition_id, "train").with_format("numpy")
 
     X, y = dataset["image"].reshape((len(dataset), -1)), dataset["label"]
 

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

@@ -1,25 +1,37 @@
 """$project_name: A Flower / TensorFlow app."""
 
 from flwr.client import NumPyClient, ClientApp
+from flwr.common import Context
 
 from $import_name.task import load_data, load_model
 
 
 # Define Flower Client and client_fn
 class FlowerClient(NumPyClient):
-    def __init__(self, model, x_train, y_train, x_test, y_test):
+    def __init__(
+        self, model, x_train, y_train, x_test, y_test, epochs, batch_size, verbose
+    ):
         self.model = model
         self.x_train = x_train
         self.y_train = y_train
         self.x_test = x_test
         self.y_test = y_test
+        self.epochs = epochs
+        self.batch_size = batch_size
+        self.verbose = verbose
 
     def get_parameters(self, config):
         return self.model.get_weights()
 
     def fit(self, parameters, config):
         self.model.set_weights(parameters)
-        self.model.fit(self.x_train, self.y_train, epochs=1, batch_size=32, verbose=0)
+        self.model.fit(
+            self.x_train,
+            self.y_train,
+            epochs=self.epochs,
+            batch_size=self.batch_size,
+            verbose=self.verbose,
+        )
         return self.model.get_weights(), len(self.x_train), {}
 
     def evaluate(self, parameters, config):
@@ -28,13 +40,21 @@ class FlowerClient(NumPyClient):
         return loss, len(self.x_test), {"accuracy": accuracy}
 
 
-def client_fn(cid):
+def client_fn(context: Context):
     # Load model and data
     net = load_model()
-    x_train, y_train, x_test, y_test = load_data(int(cid), 2)
+
+    partition_id = context.node_config["partition-id"]
+    num_partitions = context.node_config["num-partitions"]
+    x_train, y_train, x_test, y_test = load_data(partition_id, num_partitions)
+    epochs = context.run_config["local-epochs"]
+    batch_size = context.run_config["batch-size"]
+    verbose = context.run_config.get("verbose")
 
     # Return Client instance
-    return FlowerClient(net, x_train, y_train, x_test, y_test).to_client()
+    return FlowerClient(
+        net, x_train, y_train, x_test, y_test, epochs, batch_size, verbose
+    ).to_client()
 
 
 # Flower ClientApp