flwr-nightly 1.10.0.dev20240721__py3-none-any.whl → 1.10.0.dev20240723__py3-none-any.whl

flwr/cli/new/templates/app/pyproject.mlx.toml.tpl

@@ -25,12 +25,12 @@ serverapp = "$import_name.server_app:app"
 clientapp = "$import_name.client_app:app"
 
 [tool.flwr.app.config]
-num-server-rounds = "3"
-local-epochs = "1"
-num-layers = "2"
-hidden-dim = "32"
-batch-size = "256"
-lr = "0.1"
+num-server-rounds = 3
+local-epochs = 1
+num-layers = 2
+hidden-dim = 32
+batch-size = 256
+lr = 0.1
 
 [tool.flwr.federations]
 default = "localhost"

flwr/cli/new/templates/app/pyproject.numpy.toml.tpl

@@ -23,7 +23,7 @@ serverapp = "$import_name.server_app:app"
 clientapp = "$import_name.client_app:app"
 
 [tool.flwr.app.config]
-num-server-rounds = "3"
+num-server-rounds = 3
 
 [tool.flwr.federations]
 default = "localhost"

flwr/cli/new/templates/app/pyproject.pytorch.toml.tpl

@@ -25,8 +25,8 @@ serverapp = "$import_name.server_app:app"
 clientapp = "$import_name.client_app:app"
 
 [tool.flwr.app.config]
-num-server-rounds = "3"
-local-epochs = "1"
+num-server-rounds = 3
+local-epochs = 1
 
 [tool.flwr.federations]
 default = "localhost"

flwr/cli/new/templates/app/pyproject.sklearn.toml.tpl

@@ -24,7 +24,7 @@ serverapp = "$import_name.server_app:app"
 clientapp = "$import_name.client_app:app"
 
 [tool.flwr.app.config]
-num-server-rounds = "3"
+num-server-rounds = 3
 
 [tool.flwr.federations]
 default = "localhost"

flwr/cli/new/templates/app/pyproject.tensorflow.toml.tpl

@@ -24,10 +24,10 @@ serverapp = "$import_name.server_app:app"
 clientapp = "$import_name.client_app:app"
 
 [tool.flwr.app.config]
-num-server-rounds = "3"
-local-epochs = "1"
-batch-size = "32"
-verbose = ""  # Empty string means False
+num-server-rounds = 3
+local-epochs = 1
+batch-size = 32
+verbose = false
 
 [tool.flwr.federations]
 default = "localhost"

flwr/cli/run/run.py

@@ -25,36 +25,40 @@ from typing_extensions import Annotated
 
 from flwr.cli.build import build
 from flwr.cli.config_utils import load_and_validate
-from flwr.common.config import parse_config_args
+from flwr.common.config import flatten_dict, parse_config_args
 from flwr.common.grpc import GRPC_MAX_MESSAGE_LENGTH, create_channel
 from flwr.common.logger import log
+from flwr.common.serde import user_config_to_proto
 from flwr.proto.exec_pb2 import StartRunRequest  # pylint: disable=E0611
 from flwr.proto.exec_pb2_grpc import ExecStub
 
 
 # pylint: disable-next=too-many-locals
 def run(
-    directory: Annotated[
+    app_dir: Annotated[
         Path,
-        typer.Argument(help="Path of the Flower project to run"),
+        typer.Argument(help="Path of the Flower project to run."),
     ] = Path("."),
-    federation_name: Annotated[
+    federation: Annotated[
         Optional[str],
-        typer.Argument(help="Name of the federation to run the app on"),
+        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",
+            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,
 ) -> None:
     """Run Flower project."""
     typer.secho("Loading project configuration... ", fg=typer.colors.BLUE)
 
-    pyproject_path = directory / "pyproject.toml" if directory else None
+    pyproject_path = app_dir / "pyproject.toml" if app_dir else None
     config, errors, warnings = load_and_validate(path=pyproject_path)
 
     if config is None:
@@ -77,11 +81,9 @@ def run(
 
     typer.secho("Success", fg=typer.colors.GREEN)
 
-    federation_name = federation_name or config["tool"]["flwr"]["federations"].get(
-        "default"
-    )
+    federation = federation or config["tool"]["flwr"]["federations"].get("default")
 
-    if federation_name is None:
+    if federation is None:
         typer.secho(
             "❌ No federation name was provided and the project's `pyproject.toml` "
             "doesn't declare a default federation (with a SuperExec address or an "
@@ -92,13 +94,13 @@ def run(
         raise typer.Exit(code=1)
 
     # Validate the federation exists in the configuration
-    federation = config["tool"]["flwr"]["federations"].get(federation_name)
-    if federation is None:
+    federation_config = config["tool"]["flwr"]["federations"].get(federation)
+    if federation_config is None:
         available_feds = {
             fed for fed in config["tool"]["flwr"]["federations"] if fed != "default"
         }
         typer.secho(
-            f"❌ There is no `{federation_name}` federation declared in the "
+            f"❌ There is no `{federation}` federation declared in "
             "`pyproject.toml`.\n The following federations were found:\n\n"
             + "\n".join(available_feds),
             fg=typer.colors.RED,
@@ -106,15 +108,15 @@ def run(
         )
         raise typer.Exit(code=1)
 
-    if "address" in federation:
-        _run_with_superexec(federation, directory, config_overrides)
+    if "address" in federation_config:
+        _run_with_superexec(federation_config, app_dir, config_overrides)
     else:
-        _run_without_superexec(directory, federation, federation_name, config_overrides)
+        _run_without_superexec(app_dir, federation_config, federation, config_overrides)
 
 
 def _run_with_superexec(
-    federation: Dict[str, str],
-    directory: Optional[Path],
+    federation_config: Dict[str, Any],
+    app_dir: Optional[Path],
     config_overrides: Optional[List[str]],
 ) -> None:
 
@@ -122,8 +124,8 @@ def _run_with_superexec(
         """Log channel connectivity."""
         log(DEBUG, channel_connectivity)
 
-    insecure_str = federation.get("insecure")
-    if root_certificates := federation.get("root-certificates"):
+    insecure_str = federation_config.get("insecure")
+    if root_certificates := federation_config.get("root-certificates"):
         root_certificates_bytes = Path(root_certificates).read_bytes()
         if insecure := bool(insecure_str):
             typer.secho(
@@ -151,7 +153,7 @@ def _run_with_superexec(
             raise typer.Exit(code=1)
 
     channel = create_channel(
-        server_address=federation["address"],
+        server_address=federation_config["address"],
         insecure=insecure,
         root_certificates=root_certificates_bytes,
         max_message_length=GRPC_MAX_MESSAGE_LENGTH,
@@ -160,11 +162,16 @@ def _run_with_superexec(
     channel.subscribe(on_channel_state_change)
     stub = ExecStub(channel)
 
-    fab_path = build(directory)
+    fab_path = build(app_dir)
 
     req = StartRunRequest(
         fab_file=Path(fab_path).read_bytes(),
-        override_config=parse_config_args(config_overrides, separator=","),
+        override_config=user_config_to_proto(
+            parse_config_args(config_overrides, separator=",")
+        ),
+        federation_config=user_config_to_proto(
+            flatten_dict(federation_config.get("options"))
+        ),
     )
     res = stub.StartRun(req)
     typer.secho(f"🎊 Successfully started run {res.run_id}", fg=typer.colors.GREEN)
@@ -172,18 +179,18 @@ def _run_with_superexec(
 
 def _run_without_superexec(
     app_path: Optional[Path],
-    federation: Dict[str, Any],
-    federation_name: str,
+    federation_config: Dict[str, Any],
+    federation: str,
     config_overrides: Optional[List[str]],
 ) -> None:
     try:
-        num_supernodes = federation["options"]["num-supernodes"]
+        num_supernodes = federation_config["options"]["num-supernodes"]
     except KeyError as err:
         typer.secho(
             "❌ 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_name}]\n"
+            f"[tool.flwr.federations.{federation}]\n"
             "options.num-supernodes = 10\n",
             fg=typer.colors.RED,
             bold=True,

flwr/client/app.py

@@ -42,7 +42,7 @@ from flwr.common.constant import (
 from flwr.common.logger import log, warn_deprecated_feature
 from flwr.common.message import Error
 from flwr.common.retry_invoker import RetryInvoker, RetryState, exponential
-from flwr.common.typing import Run
+from flwr.common.typing import Run, UserConfig
 
 from .grpc_adapter_client.connection import grpc_adapter
 from .grpc_client.connection import grpc_connection
@@ -182,7 +182,7 @@ def start_client(
 def _start_client_internal(
     *,
     server_address: str,
-    node_config: Dict[str, str],
+    node_config: UserConfig,
     load_client_app_fn: Optional[Callable[[str, str], ClientApp]] = None,
     client_fn: Optional[ClientFnExt] = None,
     client: Optional[Client] = None,
@@ -205,7 +205,7 @@ def _start_client_internal(
         The IPv4 or IPv6 address of the server. If the Flower
         server runs on the same machine on port 8080, then `server_address`
         would be `"[::]:8080"`.
-    node_config: Dict[str, str]
+    node_config: UserConfig
         The configuration of the node.
     load_client_app_fn : Optional[Callable[[], ClientApp]] (default: None)
         A function that can be used to load a `ClientApp` instance.

flwr/client/grpc_rere_client/connection.py

@@ -40,7 +40,11 @@ from flwr.common.grpc import create_channel
 from flwr.common.logger import log
 from flwr.common.message import Message, Metadata
 from flwr.common.retry_invoker import RetryInvoker
-from flwr.common.serde import message_from_taskins, message_to_taskres
+from flwr.common.serde import (
+    message_from_taskins,
+    message_to_taskres,
+    user_config_from_proto,
+)
 from flwr.common.typing import Run
 from flwr.proto.fleet_pb2 import (  # pylint: disable=E0611
     CreateNodeRequest,
@@ -281,7 +285,7 @@ def grpc_request_response(  # pylint: disable=R0913, R0914, R0915
             run_id,
             get_run_response.run.fab_id,
             get_run_response.run.fab_version,
-            dict(get_run_response.run.override_config.items()),
+            user_config_from_proto(get_run_response.run.override_config),
         )
 
     try:

flwr/client/node_state.py

@@ -21,7 +21,7 @@ from typing import Dict, Optional
 
 from flwr.common import Context, RecordSet
 from flwr.common.config import get_fused_config, get_fused_config_from_dir
-from flwr.common.typing import Run
+from flwr.common.typing import Run, UserConfig
 
 
 @dataclass()
@@ -29,7 +29,7 @@ class RunInfo:
     """Contains the Context and initial run_config of a Run."""
 
     context: Context
-    initial_run_config: Dict[str, str]
+    initial_run_config: UserConfig
 
 
 class NodeState:
@@ -38,7 +38,7 @@ class NodeState:
     def __init__(
         self,
         node_id: int,
-        node_config: Dict[str, str],
+        node_config: UserConfig,
     ) -> None:
         self.node_id = node_id
         self.node_config = node_config

flwr/client/rest_client/connection.py

@@ -40,7 +40,11 @@ from flwr.common.constant import (
 from flwr.common.logger import log
 from flwr.common.message import Message, Metadata
 from flwr.common.retry_invoker import RetryInvoker
-from flwr.common.serde import message_from_taskins, message_to_taskres
+from flwr.common.serde import (
+    message_from_taskins,
+    message_to_taskres,
+    user_config_from_proto,
+)
 from flwr.common.typing import Run
 from flwr.proto.fleet_pb2 import (  # pylint: disable=E0611
     CreateNodeRequest,
@@ -359,7 +363,7 @@ def http_request_response(  # pylint: disable=,R0913, R0914, R0915
             run_id,
             res.run.fab_id,
             res.run.fab_version,
-            dict(res.run.override_config.items()),
+            user_config_from_proto(res.run.override_config),
         )
 
     try:

flwr/client/supernode/app.py

@@ -62,8 +62,8 @@ def run_supernode() -> None:
     root_certificates = _get_certificates(args)
     load_fn = _get_load_client_app_fn(
         default_app_ref=getattr(args, "client-app"),
-        dir_arg=args.dir,
-        flwr_dir_arg=args.flwr_dir,
+        project_dir=args.dir,
+        flwr_dir=args.flwr_dir,
         multi_app=True,
     )
     authentication_keys = _try_setup_client_authentication(args)
@@ -100,7 +100,7 @@ def run_client_app() -> None:
     root_certificates = _get_certificates(args)
     load_fn = _get_load_client_app_fn(
         default_app_ref=getattr(args, "client-app"),
-        dir_arg=args.dir,
+        project_dir=args.dir,
         multi_app=False,
     )
     authentication_keys = _try_setup_client_authentication(args)
@@ -176,9 +176,9 @@ def _get_certificates(args: argparse.Namespace) -> Optional[bytes]:
 
 def _get_load_client_app_fn(
     default_app_ref: str,
-    dir_arg: str,
+    project_dir: str,
     multi_app: bool,
-    flwr_dir_arg: Optional[str] = None,
+    flwr_dir: Optional[str] = None,
 ) -> Callable[[str, str], ClientApp]:
     """Get the load_client_app_fn function.
 
@@ -189,38 +189,21 @@ def _get_load_client_app_fn(
     If `multi_app` is False, it ignores `fab_id` and `fab_version` and
     loads a default ClientApp.
     """
-    # Find the Flower directory containing Flower Apps (only for multi-app)
-    if not multi_app:
-        flwr_dir = Path("")
-    else:
-        if flwr_dir_arg is None:
-            flwr_dir = get_flwr_dir()
-        else:
-            flwr_dir = Path(flwr_dir_arg).absolute()
-
-    inserted_path = None
-
     if not multi_app:
         log(
             DEBUG,
             "Flower SuperNode will load and validate ClientApp `%s`",
             default_app_ref,
         )
-        # Insert sys.path
-        dir_path = Path(dir_arg).absolute()
-        sys.path.insert(0, str(dir_path))
-        inserted_path = str(dir_path)
 
-        valid, error_msg = validate(default_app_ref)
+        valid, error_msg = validate(default_app_ref, project_dir=project_dir)
         if not valid and error_msg:
             raise LoadClientAppError(error_msg) from None
 
     def _load(fab_id: str, fab_version: str) -> ClientApp:
+        runtime_project_dir = Path(project_dir).absolute()
         # If multi-app feature is disabled
         if not multi_app:
-            # Get sys path to be inserted
-            dir_path = Path(dir_arg).absolute()
-
             # Set app reference
             client_app_ref = default_app_ref
         # If multi-app feature is enabled but the fab id is not specified
@@ -231,43 +214,29 @@ def _get_load_client_app_fn(
                 ) from None
 
             log(WARN, "FAB ID is not provided; the default ClientApp will be loaded.")
-            # Get sys path to be inserted
-            dir_path = Path(dir_arg).absolute()
 
             # Set app reference
             client_app_ref = default_app_ref
         # If multi-app feature is enabled
         else:
             try:
-                project_dir = get_project_dir(fab_id, fab_version, flwr_dir)
-                config = get_project_config(project_dir)
+                runtime_project_dir = get_project_dir(
+                    fab_id, fab_version, get_flwr_dir(flwr_dir)
+                )
+                config = get_project_config(runtime_project_dir)
             except Exception as e:
                 raise LoadClientAppError("Failed to load ClientApp") from e
 
-            # Get sys path to be inserted
-            dir_path = Path(project_dir).absolute()
-
             # Set app reference
             client_app_ref = config["tool"]["flwr"]["app"]["components"]["clientapp"]
 
-        # Set sys.path
-        nonlocal inserted_path
-        if inserted_path != str(dir_path):
-            # Remove the previously inserted path
-            if inserted_path is not None:
-                sys.path.remove(inserted_path)
-            # Insert the new path
-            sys.path.insert(0, str(dir_path))
-
-        inserted_path = str(dir_path)
-
         # Load ClientApp
         log(
             DEBUG,
             "Loading ClientApp `%s`",
             client_app_ref,
         )
-        client_app = load_app(client_app_ref, LoadClientAppError, dir_path)
+        client_app = load_app(client_app_ref, LoadClientAppError, runtime_project_dir)
 
         if not isinstance(client_app, ClientApp):
             raise LoadClientAppError(

flwr/common/config.py

@@ -16,13 +16,13 @@
 
 import os
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Tuple, Union
+from typing import Any, Dict, List, Optional, Tuple, Union, cast, get_args
 
 import tomli
 
 from flwr.cli.config_utils import validate_fields
 from flwr.common.constant import APP_DIR, FAB_CONFIG_FILE, FLWR_HOME
-from flwr.common.typing import Run
+from flwr.common.typing import Run, UserConfig, UserConfigValue
 
 
 def get_flwr_dir(provided_path: Optional[str] = None) -> Path:
@@ -75,8 +75,9 @@ def get_project_config(project_dir: Union[str, Path]) -> Dict[str, Any]:
 
 
 def _fuse_dicts(
-    main_dict: Dict[str, str], override_dict: Dict[str, str]
-) -> Dict[str, str]:
+    main_dict: UserConfig,
+    override_dict: UserConfig,
+) -> UserConfig:
     fused_dict = main_dict.copy()
 
     for key, value in override_dict.items():
@@ -87,8 +88,8 @@ def _fuse_dicts(
 
 
 def get_fused_config_from_dir(
-    project_dir: Path, override_config: Dict[str, str]
-) -> Dict[str, str]:
+    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", {}
@@ -98,7 +99,7 @@ def get_fused_config_from_dir(
     return _fuse_dicts(flat_default_config, override_config)
 
 
-def get_fused_config(run: Run, flwr_dir: Optional[Path]) -> Dict[str, str]:
+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
@@ -112,19 +113,25 @@ def get_fused_config(run: Run, flwr_dir: Optional[Path]) -> Dict[str, str]:
     return get_fused_config_from_dir(project_dir, run.override_config)
 
 
-def flatten_dict(raw_dict: Dict[str, Any], parent_key: str = "") -> Dict[str, str]:
+def flatten_dict(
+    raw_dict: Optional[Dict[str, Any]], parent_key: str = ""
+) -> UserConfig:
     """Flatten dict by joining nested keys with a given separator."""
-    items: List[Tuple[str, str]] = []
+    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, str):
-            items.append((new_key, v))
+        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 a `str` or a `dict`.",
+                f"The value for key {k} needs to be of type `int`, `float`, "
+                "`bool, `str`, or  a `dict` of those.",
             )
     return dict(items)
 
@@ -132,9 +139,9 @@ def flatten_dict(raw_dict: Dict[str, Any], parent_key: str = "") -> Dict[str, st
 def parse_config_args(
     config: Optional[List[str]],
     separator: str = ",",
-) -> Dict[str, str]:
+) -> UserConfig:
     """Parse separator separated list of key-value pairs separated by '='."""
-    overrides: Dict[str, str] = {}
+    overrides: UserConfig = {}
 
     if config is None:
         return overrides
@@ -150,8 +157,7 @@ def parse_config_args(
                 with Path(overrides_list[0]).open("rb") as config_file:
                     overrides = flatten_dict(tomli.load(config_file))
             else:
-                for kv_pair in overrides_list:
-                    key, value = kv_pair.split("=")
-                    overrides[key] = value
+                toml_str = "\n".join(overrides_list)
+                overrides.update(tomli.loads(toml_str))
 
     return overrides

flwr/common/context.py

@@ -16,9 +16,9 @@
 
 
 from dataclasses import dataclass
-from typing import Dict
 
 from .record import RecordSet
+from .typing import UserConfig
 
 
 @dataclass
@@ -29,7 +29,7 @@ class Context:
     ----------
     node_id : int
         The ID that identifies the node.
-    node_config : Dict[str, str]
+    node_config : UserConfig
         A config (key/value mapping) unique to the node and independent of the
         `run_config`. This config persists across all runs this node participates in.
     state : RecordSet
@@ -39,23 +39,23 @@ class Context:
         executing mods. It can also be used as a memory to access
         at different points during the lifecycle of this entity (e.g. across
         multiple rounds)
-    run_config : Dict[str, str]
+    run_config : UserConfig
         A config (key/value mapping) held by the entity in a given run and that will
         stay local. It can be used at any point during the lifecycle of this entity
         (e.g. across multiple rounds)
     """
 
     node_id: int
-    node_config: Dict[str, str]
+    node_config: UserConfig
     state: RecordSet
-    run_config: Dict[str, str]
+    run_config: UserConfig
 
     def __init__(  # pylint: disable=too-many-arguments
         self,
         node_id: int,
-        node_config: Dict[str, str],
+        node_config: UserConfig,
         state: RecordSet,
-        run_config: Dict[str, str],
+        run_config: UserConfig,
     ) -> None:
         self.node_id = node_id
         self.node_config = node_config