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

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]:
@@ -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
 
@@ -112,8 +110,11 @@ 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, str):
-            errors.append(f"Config value of key {key} is not of type `str`.")
+        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
@@ -163,7 +164,9 @@ def validate_fields(config: Dict[str, Any]) -> Tuple[bool, List[str], List[str]]
 
 
 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)
@@ -172,16 +175,15 @@ def validate(
         return False, errors, warnings
 
     # Validate serverapp
-    is_valid, reason = object_ref.validate(
-        config["tool"]["flwr"]["app"]["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["tool"]["flwr"]["app"]["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/new/new.py

@@ -38,7 +38,7 @@ class MlFramework(str, Enum):
     PYTORCH = "PyTorch"
     TENSORFLOW = "TensorFlow"
     JAX = "JAX"
-    HUGGINGFACE = "HF"
+    HUGGINGFACE = "HuggingFace"
     MLX = "MLX"
     SKLEARN = "sklearn"
     FLOWERTUNE = "FlowerTune"

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

@@ -17,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)
@@ -33,7 +34,7 @@ class FlowerClient(NumPyClient):
         train(
             self.net,
             self.trainloader,
-            epochs=int(self.context.run_config["local-epochs"]),
+            epochs=self.local_epochs,
         )
         return self.get_parameters(config={}), len(self.trainloader), {}
 
@@ -49,12 +50,13 @@ def client_fn(context: Context):
         CHECKPOINT, num_labels=2
     ).to(DEVICE)
 
-    partition_id = int(context.node_config["partition-id"])
-    num_partitions = int(context.node_config["num-partitions"])
+    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.mlx.py.tpl

@@ -19,13 +19,22 @@ from $import_name.task import (
 
 # Define Flower Client and client_fn
 class FlowerClient(NumPyClient):
-    def __init__(self, data):
-        num_layers = int(self.context.run_config["num-layers"])
-        hidden_dim = int(self.context.run_config["hidden-dim"])
-        num_classes = 10
-        batch_size = int(self.context.run_config["batch-size"])
-        learning_rate = float(self.context.run_config["lr"])
-        num_epochs = int(self.context.run_config["local-epochs"])
+    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(
@@ -61,12 +70,21 @@ class FlowerClient(NumPyClient):
 
 
 def client_fn(context: Context):
-    partition_id = int(context.node_config["partition-id"])
-    num_partitions = int(context.node_config["num-partitions"])
+    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.pytorch.py.tpl

@@ -16,10 +16,11 @@ 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)
@@ -27,7 +28,7 @@ class FlowerClient(NumPyClient):
             self.net,
             self.trainloader,
             self.valloader,
-            int(self.context.run_config["local-epochs"]),
+            self.local_epochs,
             DEVICE,
         )
         return get_weights(self.net), len(self.trainloader.dataset), results
@@ -41,12 +42,13 @@ class FlowerClient(NumPyClient):
 def client_fn(context: Context):
     # Load model and data
     net = Net().to(DEVICE)
-    partition_id = int(context.node_config["partition-id"])
-    num_partitions = int(context.node_config["num-partitions"])
+    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

@@ -69,8 +69,8 @@ class FlowerClient(NumPyClient):
 
 
 def client_fn(context: Context):
-    partition_id = int(context.node_config["partition-id"])
-    num_partitions = int(context.node_config["num-partitions"])
+    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")
 

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

@@ -8,12 +8,17 @@ 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()
@@ -23,9 +28,9 @@ class FlowerClient(NumPyClient):
         self.model.fit(
             self.x_train,
             self.y_train,
-            epochs=int(self.context.run_config["local-epochs"]),
-            batch_size=int(self.context.run_config["batch-size"]),
-            verbose=bool(self.context.run_config.get("verbose")),
+            epochs=self.epochs,
+            batch_size=self.batch_size,
+            verbose=self.verbose,
         )
         return self.model.get_weights(), len(self.x_train), {}
 
@@ -39,12 +44,17 @@ def client_fn(context: Context):
     # Load model and data
     net = load_model()
 
-    partition_id = int(context.node_config["partition-id"])
-    num_partitions = int(context.node_config["num-partitions"])
+    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

flwr/cli/new/templates/app/code/flwr_tune/app.py.tpl

@@ -9,8 +9,8 @@ from hydra import compose, initialize
 from hydra.utils import instantiate
 
 from flwr.client import ClientApp
-from flwr.common import ndarrays_to_parameters
-from flwr.server import ServerApp, ServerConfig
+from flwr.common import Context, ndarrays_to_parameters
+from flwr.server import ServerApp, ServerAppComponents, ServerConfig
 
 from $import_name.client_app import gen_client_fn, get_parameters
 from $import_name.dataset import get_tokenizer_and_data_collator_and_propt_formatting
@@ -67,20 +67,23 @@ init_model = get_model(cfg.model)
 init_model_parameters = get_parameters(init_model)
 init_model_parameters = ndarrays_to_parameters(init_model_parameters)
 
-# Instantiate strategy according to config. Here we pass other arguments
-# that are only defined at runtime.
-strategy = instantiate(
-    cfg.strategy,
-    on_fit_config_fn=get_on_fit_config(),
-    fit_metrics_aggregation_fn=fit_weighted_average,
-    initial_parameters=init_model_parameters,
-    evaluate_fn=get_evaluate_fn(
-        cfg.model, cfg.train.save_every_round, cfg_static.num_rounds, save_path
-    ),
-)
+def server_fn(context: Context):
+    # Instantiate strategy according to config. Here we pass other arguments
+    # that are only defined at runtime.
+    strategy = instantiate(
+        cfg.strategy,
+        on_fit_config_fn=get_on_fit_config(),
+        fit_metrics_aggregation_fn=fit_weighted_average,
+        initial_parameters=init_model_parameters,
+        evaluate_fn=get_evaluate_fn(
+            cfg.model, cfg.train.save_every_round, cfg_static.num_rounds, save_path
+        ),
+    )
+
+    config = ServerConfig(num_rounds=cfg_static.num_rounds)
+
+    return ServerAppComponents(strategy=strategy, config=config)
+
 
 # ServerApp for Flower Next
-server = ServerApp(
-    config=ServerConfig(num_rounds=cfg_static.num_rounds),
-    strategy=strategy,
-)
+server = ServerApp(server_fn=server_fn)

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

@@ -10,6 +10,7 @@ from transformers import TrainingArguments
 from trl import SFTTrainer
 
 from flwr.client import NumPyClient
+from flwr.common import Context
 from flwr.common.typing import NDArrays, Scalar
 from $import_name.dataset import reformat
 from $import_name.models import cosine_annealing, get_model
@@ -102,13 +103,14 @@ def gen_client_fn(
     model_cfg: DictConfig,
     train_cfg: DictConfig,
     save_path: str,
-) -> Callable[[str], FlowerClient]:  # pylint: disable=too-many-arguments
+) -> Callable[[Context], FlowerClient]:  # pylint: disable=too-many-arguments
     """Generate the client function that creates the Flower Clients."""
 
-    def client_fn(cid: str) -> FlowerClient:
+    def client_fn(context: Context) -> FlowerClient:
         """Create a Flower client representing a single organization."""
         # Let's get the partition corresponding to the i-th client
-        client_trainset = fds.load_partition(int(cid), "train")
+        partition_id = context.node_config["partition-id"]
+        client_trainset = fds.load_partition(partition_id, "train")
         client_trainset = reformat(client_trainset, llm_task="$llm_challenge_str")
 
         return FlowerClient(

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

@@ -7,7 +7,7 @@ from flwr.server import ServerApp, ServerAppComponents, ServerConfig
 
 def server_fn(context: Context):
     # Read from config
-    num_rounds = int(context.run_config["num-server-rounds"])
+    num_rounds = context.run_config["num-server-rounds"]
 
     # Define strategy
     strategy = FedAvg(
@@ -18,5 +18,6 @@ def server_fn(context: Context):
 
     return ServerAppComponents(strategy=strategy, config=config)
 
+
 # Create ServerApp
 app = ServerApp(server_fn=server_fn)

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

@@ -7,7 +7,7 @@ from flwr.server import ServerApp, ServerAppComponents, ServerConfig
 
 def server_fn(context: Context):
     # Read from config
-    num_rounds = int(context.run_config["num-server-rounds"])
+    num_rounds = context.run_config["num-server-rounds"]
 
     # Define strategy
     strategy = FedAvg()
@@ -15,5 +15,6 @@ def server_fn(context: Context):
 
     return ServerAppComponents(strategy=strategy, config=config)
 
+
 # Create ServerApp
 app = ServerApp(server_fn=server_fn)

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

@@ -7,7 +7,7 @@ from flwr.server.strategy import FedAvg
 
 def server_fn(context: Context):
     # Read from config
-    num_rounds = int(context.run_config["num-server-rounds"])
+    num_rounds = context.run_config["num-server-rounds"]
 
     # Define strategy
     strategy = FedAvg()
@@ -15,5 +15,6 @@ def server_fn(context: Context):
 
     return ServerAppComponents(strategy=strategy, config=config)
 
+
 # Create ServerApp
 app = ServerApp(server_fn=server_fn)

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

@@ -7,7 +7,7 @@ from flwr.server.strategy import FedAvg
 
 def server_fn(context: Context):
     # Read from config
-    num_rounds = int(context.run_config["num-server-rounds"])
+    num_rounds = context.run_config["num-server-rounds"]
 
     # Define strategy
     strategy = FedAvg()
@@ -15,5 +15,6 @@ def server_fn(context: Context):
 
     return ServerAppComponents(strategy=strategy, config=config)
 
+
 # Create ServerApp
 app = ServerApp(server_fn=server_fn)

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

@@ -13,7 +13,7 @@ parameters = ndarrays_to_parameters(ndarrays)
 
 def server_fn(context: Context):
     # Read from config
-    num_rounds = int(context.run_config["num-server-rounds"])
+    num_rounds = context.run_config["num-server-rounds"]
 
     # Define strategy
     strategy = FedAvg(

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

@@ -7,7 +7,7 @@ from flwr.server.strategy import FedAvg
 
 def server_fn(context: Context):
     # Read from config
-    num_rounds = int(context.run_config["num-server-rounds"])
+    num_rounds = context.run_config["num-server-rounds"]
 
     # Define strategy
     strategy = FedAvg(
@@ -19,5 +19,6 @@ def server_fn(context: Context):
 
     return ServerAppComponents(strategy=strategy, config=config)
 
+
 # Create ServerApp
 app = ServerApp(server_fn=server_fn)

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

@@ -13,7 +13,7 @@ parameters = ndarrays_to_parameters(load_model().get_weights())
 
 def server_fn(context: Context):
     # Read from config
-    num_rounds = int(context.run_config["num-server-rounds"])
+    num_rounds = context.run_config["num-server-rounds"]
 
     # Define strategy
     strategy = strategy = FedAvg(

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

@@ -10,15 +10,27 @@ from torch.utils.data import DataLoader
 from transformers import AutoTokenizer, DataCollatorWithPadding
 
 from flwr_datasets import FederatedDataset
+from flwr_datasets.partitioner import IidPartitioner
+
 
 warnings.filterwarnings("ignore", category=UserWarning)
 DEVICE = torch.device("cpu")
 CHECKPOINT = "distilbert-base-uncased"  # transformer model checkpoint
 
 
+fds = None  # Cache FederatedDataset
+
+
 def load_data(partition_id: int, num_partitions: int):
     """Load IMDB data (training and eval)"""
-    fds = FederatedDataset(dataset="imdb", partitioners={"train": num_partitions})
+    # Only initialize `FederatedDataset` once
+    global fds
+    if fds is None:
+        partitioner = IidPartitioner(num_partitions=num_partitions)
+        fds = FederatedDataset(
+            dataset="stanfordnlp/imdb",
+            partitioners={"train": partitioner},
+        )
     partition = fds.load_partition(partition_id)
     # Divide data: 80% train, 20% test
     partition_train_test = partition.train_test_split(test_size=0.2, seed=42)

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

@@ -5,10 +5,12 @@ import mlx.nn as nn
 import numpy as np
 from datasets.utils.logging import disable_progress_bar
 from flwr_datasets import FederatedDataset
+from flwr_datasets.partitioner import IidPartitioner
 
 
 disable_progress_bar()
 
+
 class MLP(nn.Module):
     """A simple MLP."""
 
@@ -43,8 +45,19 @@ def batch_iterate(batch_size, X, y):
         yield X[ids], y[ids]
 
 
+fds = None  # Cache FederatedDataset
+
+
 def load_data(partition_id: int, num_partitions: int):
-    fds = FederatedDataset(dataset="mnist", partitioners={"train": num_partitions})
+    # Only initialize `FederatedDataset` once
+    global fds
+    if fds is None:
+        partitioner = IidPartitioner(num_partitions=num_partitions)
+        fds = FederatedDataset(
+            dataset="ylecun/mnist",
+            partitioners={"train": partitioner},
+            trust_remote_code=True,
+        )
     partition = fds.load_partition(partition_id)
     partition_splits = partition.train_test_split(test_size=0.2, seed=42)
 

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

@@ -6,9 +6,10 @@ import torch
 import torch.nn as nn
 import torch.nn.functional as F
 from torch.utils.data import DataLoader
-from torchvision.datasets import CIFAR10
 from torchvision.transforms import Compose, Normalize, ToTensor
 from flwr_datasets import FederatedDataset
+from flwr_datasets.partitioner import IidPartitioner
+
 
 DEVICE = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
 
@@ -34,9 +35,19 @@ class Net(nn.Module):
         return self.fc3(x)
 
 
+fds = None  # Cache FederatedDataset
+
+
 def load_data(partition_id: int, num_partitions: int):
     """Load partition CIFAR10 data."""
-    fds = FederatedDataset(dataset="cifar10", partitioners={"train": num_partitions})
+    # Only initialize `FederatedDataset` once
+    global fds
+    if fds is None:
+        partitioner = IidPartitioner(num_partitions=num_partitions)
+        fds = FederatedDataset(
+            dataset="uoft-cs/cifar10",
+            partitioners={"train": partitioner},
+        )
     partition = fds.load_partition(partition_id)
     # Divide data on each node: 80% train, 20% test
     partition_train_test = partition.train_test_split(test_size=0.2, seed=42)

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

@@ -4,11 +4,13 @@ import os
 
 import tensorflow as tf
 from flwr_datasets import FederatedDataset
+from flwr_datasets.partitioner import IidPartitioner
 
 
 # Make TensorFlow log less verbose
 os.environ["TF_CPP_MIN_LOG_LEVEL"] = "3"
 
+
 def load_model():
     # Load model and data (MobileNetV2, CIFAR-10)
     model = tf.keras.applications.MobileNetV2((32, 32, 3), classes=10, weights=None)
@@ -16,9 +18,19 @@ def load_model():
     return model
 
 
+fds = None  # Cache FederatedDataset
+
+
 def load_data(partition_id, num_partitions):
     # Download and partition dataset
-    fds = FederatedDataset(dataset="cifar10", partitioners={"train": num_partitions})
+    # Only initialize `FederatedDataset` once
+    global fds
+    if fds is None:
+        partitioner = IidPartitioner(num_partitions=num_partitions)
+        fds = FederatedDataset(
+            dataset="uoft-cs/cifar10",
+            partitioners={"train": partitioner},
+        )
     partition = fds.load_partition(partition_id, "train")
     partition.set_format("numpy")
 

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

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

flwr/cli/new/templates/app/{pyproject.hf.toml.tpl → pyproject.huggingface.toml.tpl}

@@ -28,8 +28,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.jax.toml.tpl

@@ -25,7 +25,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"