flwr-nightly 1.11.1.dev20240912__tar.gz → 1.12.0.dev20240906__tar.gz

{flwr_nightly-1.11.1.dev20240912 → flwr_nightly-1.12.0.dev20240906}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: flwr-nightly
-Version: 1.11.1.dev20240912
+Version: 1.12.0.dev20240906
 Summary: Flower: A Friendly Federated Learning Framework
 Home-page: https://flower.ai
 License: Apache-2.0

{flwr_nightly-1.11.1.dev20240912 → flwr_nightly-1.12.0.dev20240906}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "flwr-nightly"
-version = "1.11.1.dev20240912"
+version = "1.12.0.dev20240906"
 description = "Flower: A Friendly Federated Learning Framework"
 license = "Apache-2.0"
 authors = ["The Flower Authors <hello@flower.ai>"]
@@ -101,7 +101,6 @@ docformatter = "==1.7.5"
 mypy = "==1.8.0"
 pylint = "==3.0.3"
 flake8 = "==5.0.4"
-parameterized = "==0.9.0"
 pytest = "==7.4.4"
 pytest-cov = "==4.1.0"
 pytest-watcher = "==0.4.1"

{flwr_nightly-1.11.1.dev20240912 → flwr_nightly-1.12.0.dev20240906}/src/py/flwr/cli/new/new.py

@@ -136,23 +136,36 @@ 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_str = prompt_options(
+        framework_value = prompt_options(
             "Please select ML framework by typing in the number",
             [mlf.value for mlf in MlFramework],
         )
+        selected_value = [
+            name
+            for name, value in vars(MlFramework).items()
+            if value == framework_value
+        ]
+        framework_str_upper = selected_value[0]
+
+    framework_str = framework_str_upper.lower()
 
     llm_challenge_str = None
-    if framework_str == MlFramework.FLOWERTUNE:
+    if framework_str == "flowertune":
         llm_challenge_value = prompt_options(
             "Please select LLM challenge by typing in the number",
             sorted([challenge.value for challenge in LlmChallengeName]),
         )
-        llm_challenge_str = llm_challenge_value.lower()
+        selected_value = [
+            name
+            for name, value in vars(LlmChallengeName).items()
+            if value == llm_challenge_value
+        ]
+        llm_challenge_str = selected_value[0]
+        llm_challenge_str = llm_challenge_str.lower()
 
-    if framework_str == MlFramework.BASELINE:
-        framework_str = "baseline"
+    is_baseline_project = framework_str == "baseline"
 
     print(
         typer.style(
@@ -163,21 +176,19 @@ def new(
     )
 
     context = {
-        "framework_str": framework_str,
+        "framework_str": framework_str_upper,
         "import_name": import_name.replace("-", "_"),
         "package_name": package_name,
         "project_name": app_name,
         "username": username,
     }
 
-    template_name = framework_str.lower()
-
     # List of files to render
     if llm_challenge_str:
         files = {
             ".gitignore": {"template": "app/.gitignore.tpl"},
-            "pyproject.toml": {"template": f"app/pyproject.{template_name}.toml.tpl"},
-            "README.md": {"template": f"app/README.{template_name}.md.tpl"},
+            "pyproject.toml": {"template": f"app/pyproject.{framework_str}.toml.tpl"},
+            "README.md": {"template": f"app/README.{framework_str}.md.tpl"},
             f"{import_name}/__init__.py": {"template": "app/code/__init__.py.tpl"},
             f"{import_name}/server_app.py": {
                 "template": "app/code/flwr_tune/server_app.py.tpl"
@@ -224,42 +235,44 @@ def new(
         files = {
             ".gitignore": {"template": "app/.gitignore.tpl"},
             "README.md": {"template": "app/README.md.tpl"},
-            "pyproject.toml": {"template": f"app/pyproject.{template_name}.toml.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_app.py": {
-                "template": f"app/code/server.{template_name}.py.tpl"
+                "template": f"app/code/server.{framework_str}.py.tpl"
             },
             f"{import_name}/client_app.py": {
-                "template": f"app/code/client.{template_name}.py.tpl"
+                "template": f"app/code/client.{framework_str}.py.tpl"
             },
         }
 
         # Depending on the framework, generate task.py file
         frameworks_with_tasks = [
-            MlFramework.PYTORCH.value,
-            MlFramework.JAX.value,
-            MlFramework.HUGGINGFACE.value,
-            MlFramework.MLX.value,
-            MlFramework.TENSORFLOW.value,
+            MlFramework.PYTORCH.value.lower(),
+            MlFramework.JAX.value.lower(),
+            MlFramework.HUGGINGFACE.value.lower(),
+            MlFramework.MLX.value.lower(),
+            MlFramework.TENSORFLOW.value.lower(),
         ]
         if framework_str in frameworks_with_tasks:
             files[f"{import_name}/task.py"] = {
-                "template": f"app/code/task.{template_name}.py.tpl"
+                "template": f"app/code/task.{framework_str}.py.tpl"
             }
 
-        if framework_str == "baseline":
+        if is_baseline_project:
             # Include additional files for baseline template
             for file_name in ["model", "dataset", "strategy", "utils", "__init__"]:
                 files[f"{import_name}/{file_name}.py"] = {
-                    "template": f"app/code/{file_name}.{template_name}.py.tpl"
+                    "template": f"app/code/{file_name}.{framework_str}.py.tpl"
                 }
 
             # Replace README.md
-            files["README.md"]["template"] = f"app/README.{template_name}.md.tpl"
+            files["README.md"]["template"] = f"app/README.{framework_str}.md.tpl"
 
             # Add LICENSE
             files["LICENSE"] = {"template": "app/LICENSE.tpl"}
 
+            context["framework_str"] = "baseline"
+
     for file_path, value in files.items():
         render_and_create(
             file_path=project_dir / file_path,

{flwr_nightly-1.11.1.dev20240912 → flwr_nightly-1.12.0.dev20240906}/src/py/flwr/cli/new/templates/app/code/client.huggingface.py.tpl

@@ -1,11 +1,18 @@
 """$project_name: A Flower / $framework_str app."""
 
-import torch
 from flwr.client import ClientApp, NumPyClient
 from flwr.common import Context
 from transformers import AutoModelForSequenceClassification
 
-from $import_name.task import get_weights, load_data, set_weights, test, train
+from $import_name.task import (
+    get_weights,
+    load_data,
+    set_weights,
+    train,
+    test,
+    CHECKPOINT,
+    DEVICE,
+)
 
 
 # Flower client
@@ -15,34 +22,37 @@ class FlowerClient(NumPyClient):
         self.trainloader = trainloader
         self.testloader = testloader
         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):
+    def get_parameters(self, config):
+        return get_weights(self.net)
+
+    def set_parameters(self, parameters):
         set_weights(self.net, parameters)
-        train(self.net, self.trainloader, epochs=self.local_epochs, device=self.device)
-        return get_weights(self.net), len(self.trainloader), {}
+
+    def fit(self, parameters, config):
+        self.set_parameters(parameters)
+        train(
+            self.net,
+            self.trainloader,
+            epochs=self.local_epochs,
+        )
+        return self.get_parameters(config={}), len(self.trainloader), {}
 
     def evaluate(self, parameters, config):
-        set_weights(self.net, parameters)
-        loss, accuracy = test(self.net, self.testloader, self.device)
+        self.set_parameters(parameters)
+        loss, accuracy = test(self.net, self.testloader)
         return float(loss), len(self.testloader), {"accuracy": accuracy}
 
 
 def client_fn(context: Context):
+    # Load model and data
+    net = AutoModelForSequenceClassification.from_pretrained(
+        CHECKPOINT, num_labels=2
+    ).to(DEVICE)
 
-    # Get this client's dataset partition
     partition_id = context.node_config["partition-id"]
     num_partitions = context.node_config["num-partitions"]
-    model_name = context.run_config["model-name"]
-    trainloader, valloader = load_data(partition_id, num_partitions, model_name)
-
-    # Load model
-    num_labels = context.run_config["num-labels"]
-    net = AutoModelForSequenceClassification.from_pretrained(
-        model_name, num_labels=num_labels
-    )
-
+    trainloader, valloader = load_data(partition_id, num_partitions)
     local_epochs = context.run_config["local-epochs"]
 
     # Return Client instance

{flwr_nightly-1.11.1.dev20240912 → flwr_nightly-1.12.0.dev20240906}/src/py/flwr/cli/new/templates/app/code/client.tensorflow.py.tpl

@@ -17,6 +17,9 @@ class FlowerClient(NumPyClient):
         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(

flwr_nightly-1.12.0.dev20240906/src/py/flwr/cli/new/templates/app/code/server.huggingface.py.tpl

@@ -0,0 +1,23 @@
+"""$project_name: A Flower / $framework_str app."""
+
+from flwr.common import Context
+from flwr.server.strategy import FedAvg
+from flwr.server import ServerApp, ServerAppComponents, ServerConfig
+
+
+def server_fn(context: Context):
+    # Read from config
+    num_rounds = context.run_config["num-server-rounds"]
+
+    # Define strategy
+    strategy = FedAvg(
+        fraction_fit=1.0,
+        fraction_evaluate=1.0,
+    )
+    config = ServerConfig(num_rounds=num_rounds)
+
+    return ServerAppComponents(strategy=strategy, config=config)
+
+
+# Create ServerApp
+app = ServerApp(server_fn=server_fn)

{flwr_nightly-1.11.1.dev20240912 → flwr_nightly-1.12.0.dev20240906}/src/py/flwr/cli/new/templates/app/code/task.huggingface.py.tpl

@@ -4,25 +4,24 @@ import warnings
 from collections import OrderedDict
 
 import torch
-import transformers
-from datasets.utils.logging import disable_progress_bar
 from evaluate import load as load_metric
-from flwr_datasets import FederatedDataset
-from flwr_datasets.partitioner import IidPartitioner
 from torch.optim import AdamW
 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)
-warnings.filterwarnings("ignore", category=FutureWarning)
-disable_progress_bar()
-transformers.logging.set_verbosity_error()
+DEVICE = torch.device("cpu")
+CHECKPOINT = "distilbert-base-uncased"  # transformer model checkpoint
 
 
 fds = None  # Cache FederatedDataset
 
 
-def load_data(partition_id: int, num_partitions: int, model_name: str):
+def load_data(partition_id: int, num_partitions: int):
     """Load IMDB data (training and eval)"""
     # Only initialize `FederatedDataset` once
     global fds
@@ -36,12 +35,10 @@ def load_data(partition_id: int, num_partitions: int, model_name: str):
     # Divide data: 80% train, 20% test
     partition_train_test = partition.train_test_split(test_size=0.2, seed=42)
 
-    tokenizer = AutoTokenizer.from_pretrained(model_name)
+    tokenizer = AutoTokenizer.from_pretrained(CHECKPOINT)
 
     def tokenize_function(examples):
-        return tokenizer(
-            examples["text"], truncation=True, add_special_tokens=True, max_length=512
-        )
+        return tokenizer(examples["text"], truncation=True)
 
     partition_train_test = partition_train_test.map(tokenize_function, batched=True)
     partition_train_test = partition_train_test.remove_columns("text")
@@ -62,12 +59,12 @@ def load_data(partition_id: int, num_partitions: int, model_name: str):
     return trainloader, testloader
 
 
-def train(net, trainloader, epochs, device):
+def train(net, trainloader, epochs):
     optimizer = AdamW(net.parameters(), lr=5e-5)
     net.train()
     for _ in range(epochs):
         for batch in trainloader:
-            batch = {k: v.to(device) for k, v in batch.items()}
+            batch = {k: v.to(DEVICE) for k, v in batch.items()}
             outputs = net(**batch)
             loss = outputs.loss
             loss.backward()
@@ -75,12 +72,12 @@ def train(net, trainloader, epochs, device):
             optimizer.zero_grad()
 
 
-def test(net, testloader, device):
+def test(net, testloader):
     metric = load_metric("accuracy")
     loss = 0
     net.eval()
     for batch in testloader:
-        batch = {k: v.to(device) for k, v in batch.items()}
+        batch = {k: v.to(DEVICE) for k, v in batch.items()}
         with torch.no_grad():
             outputs = net(**batch)
         logits = outputs.logits

flwr_nightly-1.12.0.dev20240906/src/py/flwr/cli/new/templates/app/pyproject.huggingface.toml.tpl

@@ -0,0 +1,38 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "$package_name"
+version = "1.0.0"
+description = ""
+license = "Apache-2.0"
+dependencies = [
+    "flwr[simulation]>=1.10.0",
+    "flwr-datasets>=0.3.0",
+    "torch==2.2.1",
+    "transformers>=4.30.0,<5.0",
+    "evaluate>=0.4.0,<1.0",
+    "datasets>=2.0.0, <3.0",
+    "scikit-learn>=1.3.1, <2.0",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["."]
+
+[tool.flwr.app]
+publisher = "$username"
+
+[tool.flwr.app.components]
+serverapp = "$import_name.server_app:app"
+clientapp = "$import_name.client_app:app"
+
+[tool.flwr.app.config]
+num-server-rounds = 3
+local-epochs = 1
+
+[tool.flwr.federations]
+default = "localhost"
+
+[tool.flwr.federations.localhost]
+options.num-supernodes = 10

{flwr_nightly-1.11.1.dev20240912 → flwr_nightly-1.12.0.dev20240906}/src/py/flwr/client/app.py

@@ -35,7 +35,6 @@ from flwr.client.typing import ClientFnExt
 from flwr.common import GRPC_MAX_MESSAGE_LENGTH, Context, EventType, Message, event
 from flwr.common.address import parse_address
 from flwr.common.constant import (
-    CLIENTAPPIO_API_DEFAULT_ADDRESS,
     MISSING_EXTRA_REST,
     RUN_ID_NUM_BYTES,
     TRANSPORT_TYPE_GRPC_ADAPTER,
@@ -61,6 +60,8 @@ from .message_handler.message_handler import handle_control_message
 from .node_state import NodeState
 from .numpy_client import NumPyClient
 
+ADDRESS_CLIENTAPPIO_API_GRPC_RERE = "0.0.0.0:9094"
+
 ISOLATION_MODE_SUBPROCESS = "subprocess"
 ISOLATION_MODE_PROCESS = "process"
 
@@ -210,7 +211,7 @@ def start_client_internal(
     max_wait_time: Optional[float] = None,
     flwr_path: Optional[Path] = None,
     isolation: Optional[str] = None,
-    supernode_address: Optional[str] = CLIENTAPPIO_API_DEFAULT_ADDRESS,
+    supernode_address: Optional[str] = ADDRESS_CLIENTAPPIO_API_GRPC_RERE,
 ) -> None:
     """Start a Flower client node which connects to a Flower server.
 
@@ -265,7 +266,7 @@ def start_client_internal(
         by the SueprNode and communicates using gRPC at the address
         `supernode_address`. If `process`, the `ClientApp` runs in a separate isolated
         process and communicates using gRPC at the address `supernode_address`.
-    supernode_address : Optional[str] (default: `CLIENTAPPIO_API_DEFAULT_ADDRESS`)
+    supernode_address : Optional[str] (default: `ADDRESS_CLIENTAPPIO_API_GRPC_RERE`)
         The SuperNode gRPC server address.
     """
     if insecure is None:

{flwr_nightly-1.11.1.dev20240912 → flwr_nightly-1.12.0.dev20240906}/src/py/flwr/client/client_app.py

@@ -41,11 +41,11 @@ def _alert_erroneous_client_fn() -> None:
 
 def _inspect_maybe_adapt_client_fn_signature(client_fn: ClientFnExt) -> ClientFnExt:
     client_fn_args = inspect.signature(client_fn).parameters
+    first_arg = list(client_fn_args.keys())[0]
 
     if len(client_fn_args) != 1:
         _alert_erroneous_client_fn()
 
-    first_arg = list(client_fn_args.keys())[0]
     first_arg_type = client_fn_args[first_arg].annotation
 
     if first_arg_type is str or first_arg == "cid":
@@ -263,7 +263,7 @@ def _registration_error(fn_name: str) -> ValueError:
         >>> class FlowerClient(NumPyClient):
         >>>     # ...
         >>>
-        >>> def client_fn(context: Context):
+        >>> def client_fn(cid) -> Client:
         >>>     return FlowerClient().to_client()
         >>>
         >>> app = ClientApp(

{flwr_nightly-1.11.1.dev20240912 → flwr_nightly-1.12.0.dev20240906}/src/py/flwr/client/grpc_rere_client/client_interceptor.py

@@ -130,12 +130,13 @@ class AuthenticateClientInterceptor(grpc.UnaryUnaryClientInterceptor):  # type:
             if self.shared_secret is None:
                 raise RuntimeError("Failure to compute hmac")
 
-            message_bytes = request.SerializeToString(deterministic=True)
             metadata.append(
                 (
                     _AUTH_TOKEN_HEADER,
                     base64.urlsafe_b64encode(
-                        compute_hmac(self.shared_secret, message_bytes)
+                        compute_hmac(
+                            self.shared_secret, request.SerializeToString(True)
+                        )
                     ),
                 )
             )

{flwr_nightly-1.11.1.dev20240912 → flwr_nightly-1.12.0.dev20240906}/src/py/flwr/client/supernode/app.py

@@ -30,7 +30,6 @@ from cryptography.hazmat.primitives.serialization import (
 from flwr.common import EventType, event
 from flwr.common.config import parse_config_args
 from flwr.common.constant import (
-    FLEET_API_GRPC_RERE_DEFAULT_ADDRESS,
     TRANSPORT_TYPE_GRPC_ADAPTER,
     TRANSPORT_TYPE_GRPC_RERE,
     TRANSPORT_TYPE_REST,
@@ -45,6 +44,8 @@ from ..app import (
 )
 from ..clientapp.utils import get_load_client_app_fn
 
+ADDRESS_FLEET_API_GRPC_RERE = "0.0.0.0:9092"
+
 
 def run_supernode() -> None:
     """Run Flower SuperNode."""
@@ -102,11 +103,11 @@ def run_client_app() -> None:
 
 def _warn_deprecated_server_arg(args: argparse.Namespace) -> None:
     """Warn about the deprecated argument `--server`."""
-    if args.server != FLEET_API_GRPC_RERE_DEFAULT_ADDRESS:
+    if args.server != ADDRESS_FLEET_API_GRPC_RERE:
         warn = "Passing flag --server is deprecated. Use --superlink instead."
         warn_deprecated_feature(warn)
 
-        if args.superlink != FLEET_API_GRPC_RERE_DEFAULT_ADDRESS:
+        if args.superlink != ADDRESS_FLEET_API_GRPC_RERE:
             # if `--superlink` also passed, then
             # warn user that this argument overrides what was passed with `--server`
             log(
@@ -246,12 +247,12 @@ def _parse_args_common(parser: argparse.ArgumentParser) -> None:
     )
     parser.add_argument(
         "--server",
-        default=FLEET_API_GRPC_RERE_DEFAULT_ADDRESS,
+        default=ADDRESS_FLEET_API_GRPC_RERE,
         help="Server address",
     )
     parser.add_argument(
         "--superlink",
-        default=FLEET_API_GRPC_RERE_DEFAULT_ADDRESS,
+        default=ADDRESS_FLEET_API_GRPC_RERE,
         help="SuperLink Fleet API (gRPC-rere) address (IPv4, IPv6, or a domain name)",
     )
     parser.add_argument(

{flwr_nightly-1.11.1.dev20240912 → flwr_nightly-1.12.0.dev20240906}/src/py/flwr/common/constant.py

@@ -37,18 +37,7 @@ TRANSPORT_TYPES = [
     TRANSPORT_TYPE_VCE,
 ]
 
-# Addresses
-# SuperNode
-CLIENTAPPIO_API_DEFAULT_ADDRESS = "0.0.0.0:9094"
-# SuperExec
-EXEC_API_DEFAULT_ADDRESS = "0.0.0.0:9093"
-# SuperLink
-DRIVER_API_DEFAULT_ADDRESS = "0.0.0.0:9091"
-FLEET_API_GRPC_RERE_DEFAULT_ADDRESS = "0.0.0.0:9092"
-FLEET_API_GRPC_BIDI_DEFAULT_ADDRESS = (
-    "[::]:8080"  # IPv6 to keep start_server compatible
-)
-FLEET_API_REST_DEFAULT_ADDRESS = "0.0.0.0:9093"
+SUPEREXEC_DEFAULT_ADDRESS = "0.0.0.0:9093"
 
 # Constants for ping
 PING_DEFAULT_INTERVAL = 30

{flwr_nightly-1.11.1.dev20240912 → flwr_nightly-1.12.0.dev20240906}/src/py/flwr/common/record/recordset.py

@@ -119,7 +119,7 @@ class RecordSet:
     Let's see an example.
 
     >>>  from flwr.common import RecordSet
-    >>>  from flwr.common import ConfigsRecord, MetricsRecord, ParametersRecord
+    >>>  from flwr.common import ConfigsRecords, MetricsRecords, ParametersRecord
     >>>
     >>>  # Let's begin with an empty record
     >>>  my_recordset = RecordSet()

{flwr_nightly-1.11.1.dev20240912 → flwr_nightly-1.12.0.dev20240906}/src/py/flwr/common/record/typeddict.py

@@ -15,18 +15,7 @@
 """Typed dict base class for *Records."""
 
 
-from typing import (
-    Callable,
-    Dict,
-    Generic,
-    ItemsView,
-    Iterator,
-    KeysView,
-    MutableMapping,
-    TypeVar,
-    ValuesView,
-    cast,
-)
+from typing import Callable, Dict, Generic, Iterator, MutableMapping, TypeVar, cast
 
 K = TypeVar("K")  # Key type
 V = TypeVar("V")  # Value type
@@ -84,15 +73,3 @@ class TypedDict(MutableMapping[K, V], Generic[K, V]):
         if isinstance(other, dict):
             return data == other
         return NotImplemented
-
-    def keys(self) -> KeysView[K]:
-        """D.keys() -> a set-like object providing a view on D's keys."""
-        return cast(Dict[K, V], self.__dict__["_data"]).keys()
-
-    def values(self) -> ValuesView[V]:
-        """D.values() -> an object providing a view on D's values."""
-        return cast(Dict[K, V], self.__dict__["_data"]).values()
-
-    def items(self) -> ItemsView[K, V]:
-        """D.items() -> a set-like object providing a view on D's items."""
-        return cast(Dict[K, V], self.__dict__["_data"]).items()

{flwr_nightly-1.11.1.dev20240912 → flwr_nightly-1.12.0.dev20240906}/src/py/flwr/server/app.py

@@ -36,10 +36,6 @@ from flwr.common import GRPC_MAX_MESSAGE_LENGTH, EventType, event
 from flwr.common.address import parse_address
 from flwr.common.config import get_flwr_dir
 from flwr.common.constant import (
-    DRIVER_API_DEFAULT_ADDRESS,
-    FLEET_API_GRPC_BIDI_DEFAULT_ADDRESS,
-    FLEET_API_GRPC_RERE_DEFAULT_ADDRESS,
-    FLEET_API_REST_DEFAULT_ADDRESS,
     MISSING_EXTRA_REST,
     TRANSPORT_TYPE_GRPC_ADAPTER,
     TRANSPORT_TYPE_GRPC_RERE,
@@ -72,13 +68,18 @@ from .superlink.fleet.grpc_rere.fleet_servicer import FleetServicer
 from .superlink.fleet.grpc_rere.server_interceptor import AuthenticateServerInterceptor
 from .superlink.state import StateFactory
 
+ADDRESS_DRIVER_API = "0.0.0.0:9091"
+ADDRESS_FLEET_API_GRPC_RERE = "0.0.0.0:9092"
+ADDRESS_FLEET_API_GRPC_BIDI = "[::]:8080"  # IPv6 to keep start_server compatible
+ADDRESS_FLEET_API_REST = "0.0.0.0:9093"
+
 DATABASE = ":flwr-in-memory-state:"
 BASE_DIR = get_flwr_dir() / "superlink" / "ffs"
 
 
 def start_server(  # pylint: disable=too-many-arguments,too-many-locals
     *,
-    server_address: str = FLEET_API_GRPC_BIDI_DEFAULT_ADDRESS,
+    server_address: str = ADDRESS_FLEET_API_GRPC_BIDI,
     server: Optional[Server] = None,
     config: Optional[ServerConfig] = None,
     strategy: Optional[Strategy] = None,
@@ -231,9 +232,9 @@ def run_superlink() -> None:
             TRANSPORT_TYPE_GRPC_RERE,
             TRANSPORT_TYPE_GRPC_ADAPTER,
         ]:
-            args.fleet_api_address = FLEET_API_GRPC_RERE_DEFAULT_ADDRESS
+            args.fleet_api_address = ADDRESS_FLEET_API_GRPC_RERE
         elif args.fleet_api_type == TRANSPORT_TYPE_REST:
-            args.fleet_api_address = FLEET_API_REST_DEFAULT_ADDRESS
+            args.fleet_api_address = ADDRESS_FLEET_API_REST
 
     fleet_address, host, port = _format_address(args.fleet_api_address)
 
@@ -652,7 +653,7 @@ def _add_args_driver_api(parser: argparse.ArgumentParser) -> None:
     parser.add_argument(
         "--driver-api-address",
         help="Driver API (gRPC) server address (IPv4, IPv6, or a domain name).",
-        default=DRIVER_API_DEFAULT_ADDRESS,
+        default=ADDRESS_DRIVER_API,
     )
 
 

{flwr_nightly-1.11.1.dev20240912 → flwr_nightly-1.12.0.dev20240906}/src/py/flwr/server/driver/grpc_driver.py

@@ -22,7 +22,6 @@ from typing import Iterable, List, Optional, cast
 import grpc
 
 from flwr.common import DEFAULT_TTL, Message, Metadata, RecordSet
-from flwr.common.constant import DRIVER_API_DEFAULT_ADDRESS
 from flwr.common.grpc import create_channel
 from flwr.common.logger import log
 from flwr.common.serde import (
@@ -46,6 +45,8 @@ from flwr.proto.task_pb2 import TaskIns  # pylint: disable=E0611
 
 from .driver import Driver
 
+DEFAULT_SERVER_ADDRESS_DRIVER = "[::]:9091"
+
 ERROR_MESSAGE_DRIVER_NOT_CONNECTED = """
 [Driver] Error: Not connected.
 
@@ -72,7 +73,7 @@ class GrpcDriver(Driver):
     def __init__(  # pylint: disable=too-many-arguments
         self,
         run_id: int,
-        driver_service_address: str = DRIVER_API_DEFAULT_ADDRESS,
+        driver_service_address: str = DEFAULT_SERVER_ADDRESS_DRIVER,
         root_certificates: Optional[bytes] = None,
     ) -> None:
         self._run_id = run_id