flwr-nightly 1.10.0.dev20240722__py3-none-any.whl → 1.11.0.dev20240805__py3-none-any.whl

flwr/cli/config_utils.py

@@ -25,8 +25,8 @@ from flwr.common import object_ref
 from flwr.common.typing import UserConfigValue
 
 
-def get_fab_metadata(fab_file: Union[Path, bytes]) -> Tuple[str, str]:
-    """Extract the fab_id and the fab_version from a FAB file or path.
+def get_fab_config(fab_file: Union[Path, bytes]) -> Dict[str, Any]:
+    """Extract the config from a FAB file or path.
 
     Parameters
     ----------
@@ -36,8 +36,8 @@ def get_fab_metadata(fab_file: Union[Path, bytes]) -> Tuple[str, str]:
 
     Returns
     -------
-    Tuple[str, str]
-        The `fab_version` and `fab_id` of the given Flower App Bundle.
+    Dict[str, Any]
+        The `config` of the given Flower App Bundle.
     """
     fab_file_archive: Union[Path, IO[bytes]]
     if isinstance(fab_file, bytes):
@@ -59,10 +59,29 @@ def get_fab_metadata(fab_file: Union[Path, bytes]) -> Tuple[str, str]:
         if not is_valid:
             raise ValueError(errors)
 
-        return (
-            conf["project"]["version"],
-            f"{conf['tool']['flwr']['app']['publisher']}/{conf['project']['name']}",
-        )
+        return conf
+
+
+def get_fab_metadata(fab_file: Union[Path, bytes]) -> Tuple[str, str]:
+    """Extract the fab_id and the fab_version from a FAB file or path.
+
+    Parameters
+    ----------
+    fab_file : Union[Path, bytes]
+        The Flower App Bundle file to validate and extract the metadata from.
+        It can either be a path to the file or the file itself as bytes.
+
+    Returns
+    -------
+    Tuple[str, str]
+        The `fab_version` and `fab_id` of the given Flower App Bundle.
+    """
+    conf = get_fab_config(fab_file)
+
+    return (
+        conf["project"]["version"],
+        f"{conf['tool']['flwr']['app']['publisher']}/{conf['project']['name']}",
+    )
 
 
 def load_and_validate(
@@ -77,6 +96,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:
@@ -86,7 +108,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)
@@ -94,14 +116,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
 
@@ -167,7 +183,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)
@@ -176,16 +194,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"
@@ -135,7 +135,7 @@ def new(
         username = prompt_text("Please provide your Flower username")
 
     if framework is not None:
-        framework_str = str(framework.value)
+        framework_str_upper = str(framework.value)
     else:
         framework_value = prompt_options(
             "Please select ML framework by typing in the number",
@@ -146,9 +146,9 @@ def new(
             for name, value in vars(MlFramework).items()
             if value == framework_value
         ]
-        framework_str = selected_value[0]
+        framework_str_upper = selected_value[0]
 
-    framework_str = framework_str.lower()
+    framework_str = framework_str_upper.lower()
 
     llm_challenge_str = None
     if framework_str == "flowertune":
@@ -173,9 +173,10 @@ def new(
     )
 
     context = {
-        "project_name": project_name,
-        "package_name": package_name,
+        "framework_str": framework_str_upper,
         "import_name": import_name.replace("-", "_"),
+        "package_name": package_name,
+        "project_name": project_name,
         "username": username,
     }
 

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

@@ -1,4 +1,4 @@
-# $project_name
+# $project_name: A Flower / $framework_str app
 
 ## Install dependencies
 

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

@@ -1 +1 @@
-"""$project_name."""
+"""$project_name: A Flower / $framework_str app."""

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

@@ -1,4 +1,4 @@
-"""$project_name: A Flower / HuggingFace Transformers app."""
+"""$project_name: A Flower / $framework_str app."""
 
 from flwr.client import ClientApp, NumPyClient
 from flwr.common import Context
@@ -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.jax.py.tpl

@@ -1,4 +1,4 @@
-"""$project_name: A Flower / JAX app."""
+"""$project_name: A Flower / $framework_str app."""
 
 import jax
 from flwr.client import NumPyClient, ClientApp

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

@@ -1,4 +1,4 @@
-"""$project_name: A Flower / MLX app."""
+"""$project_name: A Flower / $framework_str app."""
 
 import mlx.core as mx
 import mlx.nn as nn
@@ -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.numpy.py.tpl

@@ -1,4 +1,4 @@
-"""$project_name: A Flower / NumPy app."""
+"""$project_name: A Flower / $framework_str app."""
 
 from flwr.client import NumPyClient, ClientApp
 from flwr.common import Context

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

@@ -1,11 +1,11 @@
-"""$project_name: A Flower / PyTorch app."""
+"""$project_name: A Flower / $framework_str app."""
 
+import torch
 from flwr.client import NumPyClient, ClientApp
 from flwr.common import Context
 
 from $import_name.task import (
     Net,
-    DEVICE,
     load_data,
     get_weights,
     set_weights,
@@ -16,37 +16,40 @@ 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
+        self.device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+        self.net.to(self.device)
 
     def fit(self, parameters, config):
         set_weights(self.net, parameters)
-        results = train(
+        train_loss = train(
             self.net,
             self.trainloader,
-            self.valloader,
-            int(self.context.run_config["local-epochs"]),
-            DEVICE,
+            self.local_epochs,
+            self.device,
         )
-        return get_weights(self.net), len(self.trainloader.dataset), results
+        return get_weights(self.net), len(self.trainloader.dataset), {"train_loss": train_loss}
 
     def evaluate(self, parameters, config):
         set_weights(self.net, parameters)
-        loss, accuracy = test(self.net, self.valloader)
+        loss, accuracy = test(self.net, self.valloader, self.device)
         return loss, len(self.valloader.dataset), {"accuracy": accuracy}
 
 
 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"])
+    net = Net()
+    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

@@ -1,4 +1,4 @@
-"""$project_name: A Flower / Scikit-Learn app."""
+"""$project_name: A Flower / $framework_str app."""
 
 import warnings
 
@@ -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

@@ -1,4 +1,4 @@
-"""$project_name: A Flower / TensorFlow app."""
+"""$project_name: A Flower / $framework_str app."""
 
 from flwr.client import NumPyClient, ClientApp
 from flwr.common import Context
@@ -8,12 +8,14 @@ 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, data, 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.x_train, self.y_train, self.x_test, self.y_test = data
+        self.epochs = epochs
+        self.batch_size = batch_size
+        self.verbose = verbose
 
     def get_parameters(self, config):
         return self.model.get_weights()
@@ -23,9 +25,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 +41,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"])
-    x_train, y_train, x_test, y_test = load_data(partition_id, num_partitions)
+    partition_id = context.node_config["partition-id"]
+    num_partitions = context.node_config["num-partitions"]
+    data = 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, data, 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}

@@ -1,4 +1,4 @@
-"""$project_name: A Flower / HuggingFace Transformers app."""
+"""$project_name: A Flower / $framework_str app."""
 
 from flwr.common import Context
 from flwr.server.strategy import FedAvg
@@ -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

@@ -1,4 +1,4 @@
-"""$project_name: A Flower / JAX app."""
+"""$project_name: A Flower / $framework_str app."""
 
 from flwr.common import Context
 from flwr.server.strategy import FedAvg
@@ -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

@@ -1,4 +1,4 @@
-"""$project_name: A Flower / MLX app."""
+"""$project_name: A Flower / $framework_str app."""
 
 from flwr.common import Context
 from flwr.server import ServerApp, ServerAppComponents, ServerConfig
@@ -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

@@ -1,4 +1,4 @@
-"""$project_name: A Flower / NumPy app."""
+"""$project_name: A Flower / $framework_str app."""
 
 from flwr.common import Context
 from flwr.server import ServerApp, ServerAppComponents, ServerConfig
@@ -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

@@ -1,4 +1,4 @@
-"""$project_name: A Flower / PyTorch app."""
+"""$project_name: A Flower / $framework_str app."""
 
 from flwr.common import Context, ndarrays_to_parameters
 from flwr.server import ServerApp, ServerAppComponents, ServerConfig
@@ -7,17 +7,18 @@ from flwr.server.strategy import FedAvg
 from $import_name.task import Net, get_weights
 
 
-# Initialize model parameters
-ndarrays = get_weights(Net())
-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"]
+    fraction_fit = context.run_config["fraction-fit"]
+
+    # Initialize model parameters
+    ndarrays = get_weights(Net())
+    parameters = ndarrays_to_parameters(ndarrays)
 
     # Define strategy
     strategy = FedAvg(
-        fraction_fit=1.0,
+        fraction_fit=fraction_fit,
         fraction_evaluate=1.0,
         min_available_clients=2,
         initial_parameters=parameters,

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

@@ -1,4 +1,4 @@
-"""$project_name: A Flower / Scikit-Learn app."""
+"""$project_name: A Flower / $framework_str app."""
 
 from flwr.common import Context
 from flwr.server import ServerApp, ServerAppComponents, ServerConfig
@@ -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)