flwr-nightly 1.19.0.dev20250510__tar.gz → 1.19.0.dev20250512__tar.gz

{flwr_nightly-1.19.0.dev20250510 → flwr_nightly-1.19.0.dev20250512}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: flwr-nightly
-Version: 1.19.0.dev20250510
+Version: 1.19.0.dev20250512
 Summary: Flower: A Friendly Federated AI Framework
 License: Apache-2.0
 Keywords: Artificial Intelligence,Federated AI,Federated Analytics,Federated Evaluation,Federated Learning,Flower,Machine Learning
@@ -31,6 +31,7 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Typing :: Typed
 Provides-Extra: rest
 Provides-Extra: simulation
+Requires-Dist: click (<8.2.0)
 Requires-Dist: cryptography (>=44.0.1,<45.0.0)
 Requires-Dist: grpcio (>=1.62.3,<2.0.0,!=1.65.0)
 Requires-Dist: iterators (>=0.0.2,<0.0.3)

{flwr_nightly-1.19.0.dev20250510 → flwr_nightly-1.19.0.dev20250512}/py/flwr/cli/build.py

@@ -16,10 +16,8 @@
 
 
 import hashlib
-import os
-import shutil
-import tempfile
 import zipfile
+from io import BytesIO
 from pathlib import Path
 from typing import Annotated, Any, Optional, Union
 
@@ -29,6 +27,7 @@ import typer
 
 from flwr.common.constant import FAB_ALLOWED_EXTENSIONS, FAB_DATE, FAB_HASH_TRUNCATION
 
+from .config_utils import load as load_toml
 from .config_utils import load_and_validate
 from .utils import is_valid_project_name
 
@@ -43,11 +42,11 @@ def write_to_zip(
     return zipfile_obj
 
 
-def get_fab_filename(conf: dict[str, Any], fab_hash: str) -> str:
+def get_fab_filename(config: dict[str, Any], fab_hash: str) -> str:
     """Get the FAB filename based on the given config and FAB hash."""
-    publisher = conf["tool"]["flwr"]["app"]["publisher"]
-    name = conf["project"]["name"]
-    version = conf["project"]["version"].replace(".", "-")
+    publisher = config["tool"]["flwr"]["app"]["publisher"]
+    name = config["project"]["name"]
+    version = config["project"]["version"].replace(".", "-")
     fab_hash_truncated = fab_hash[:FAB_HASH_TRUNCATION]
     return f"{publisher}.{name}.{version}.{fab_hash_truncated}.fab"
 
@@ -89,8 +88,8 @@ def build(
         )
         raise typer.Exit(code=1)
 
-    conf, errors, warnings = load_and_validate(app / "pyproject.toml")
-    if conf is None:
+    config, errors, warnings = load_and_validate(app / "pyproject.toml")
+    if config is None:
         typer.secho(
             "Project configuration could not be loaded.\npyproject.toml is invalid:\n"
             + "\n".join([f"- {line}" for line in errors]),
@@ -107,70 +106,96 @@ def build(
             bold=True,
         )
 
-    # Load .gitignore rules if present
-    ignore_spec = _load_gitignore(app)
+    # Build FAB
+    fab_bytes, fab_hash, _ = build_fab(app)
 
-    list_file_content = ""
+    # Get the name of the zip file
+    fab_filename = get_fab_filename(config, fab_hash)
+
+    # Write the FAB
+    Path(fab_filename).write_bytes(fab_bytes)
+
+    typer.secho(
+        f"🎊 Successfully built {fab_filename}", fg=typer.colors.GREEN, bold=True
+    )
+
+    return fab_filename, fab_hash
 
-    # Remove the 'federations' field from 'tool.flwr' if it exists
-    if (
-        "tool" in conf
-        and "flwr" in conf["tool"]
-        and "federations" in conf["tool"]["flwr"]
-    ):
-        del conf["tool"]["flwr"]["federations"]
 
-    toml_contents = tomli_w.dumps(conf)
+def build_fab(app: Path) -> tuple[bytes, str, dict[str, Any]]:
+    """Build a FAB in memory and return the bytes, hash, and config.
 
-    with tempfile.NamedTemporaryFile(suffix=".zip", delete=False) as temp_file:
-        temp_filename = temp_file.name
+    This function assumes that the provided path points to a valid Flower app and
+    bundles it into a FAB without performing additional validation.
 
-        with zipfile.ZipFile(temp_filename, "w", zipfile.ZIP_DEFLATED) as fab_file:
-            write_to_zip(fab_file, "pyproject.toml", toml_contents)
+    Parameters
+    ----------
+    app : Path
+        Path to the Flower app to bundle into a FAB.
 
-            # Continue with adding other files
-            all_files = [
-                f
-                for f in app.rglob("*")
-                if not ignore_spec.match_file(f)
-                and f.name != temp_filename
-                and f.suffix in FAB_ALLOWED_EXTENSIONS
-                and f.name != "pyproject.toml"  # Exclude the original pyproject.toml
-            ]
+    Returns
+    -------
+    tuple[bytes, str, dict[str, Any]]
+        A tuple containing:
+        - the FAB as bytes
+        - the SHA256 hash of the FAB
+        - the project configuration (with the 'federations' field removed)
+    """
+    app = app.resolve()
+
+    # Load the pyproject.toml file
+    config = load_toml(app / "pyproject.toml")
+    if config is None:
+        raise ValueError("Project configuration could not be loaded.")
 
-            all_files.sort()
+    # Remove the 'federations' field if it exists
+    if (
+        "tool" in config
+        and "flwr" in config["tool"]
+        and "federations" in config["tool"]["flwr"]
+    ):
+        del config["tool"]["flwr"]["federations"]
 
-            for file_path in all_files:
-                # Read the file content manually
-                with open(file_path, "rb") as f:
-                    file_contents = f.read()
+    # Load .gitignore rules if present
+    ignore_spec = _load_gitignore(app)
 
-                archive_path = file_path.relative_to(app)
-                write_to_zip(fab_file, str(archive_path), file_contents)
+    # Search for all files in the app directory
+    all_files = [
+        f
+        for f in app.rglob("*")
+        if not ignore_spec.match_file(f)
+        and f.suffix in FAB_ALLOWED_EXTENSIONS
+        and f.name != "pyproject.toml"  # Exclude the original pyproject.toml
+    ]
+    all_files.sort()
+
+    # Create a zip file in memory
+    list_file_content = ""
 
-                # Calculate file info
-                sha256_hash = hashlib.sha256(file_contents).hexdigest()
-                file_size_bits = os.path.getsize(file_path) * 8  # size in bits
-                list_file_content += f"{archive_path},{sha256_hash},{file_size_bits}\n"
+    fab_buffer = BytesIO()
+    with zipfile.ZipFile(fab_buffer, "w", zipfile.ZIP_DEFLATED) as fab_file:
+        # Add pyproject.toml
+        write_to_zip(fab_file, "pyproject.toml", tomli_w.dumps(config))
 
-            # Add CONTENT and CONTENT.jwt to the zip file
-            write_to_zip(fab_file, ".info/CONTENT", list_file_content)
+        for file_path in all_files:
+            # Read the file content manually
+            file_contents = file_path.read_bytes()
 
-    # Get hash of FAB file
-    content = Path(temp_filename).read_bytes()
-    fab_hash = hashlib.sha256(content).hexdigest()
+            archive_path = str(file_path.relative_to(app))
+            write_to_zip(fab_file, archive_path, file_contents)
 
-    # Set the name of the zip file
-    fab_filename = get_fab_filename(conf, fab_hash)
+            # Calculate file info
+            sha256_hash = hashlib.sha256(file_contents).hexdigest()
+            file_size_bits = len(file_contents) * 8  # size in bits
+            list_file_content += f"{archive_path},{sha256_hash},{file_size_bits}\n"
 
-    # Once the temporary zip file is created, rename it to the final filename
-    shutil.move(temp_filename, fab_filename)
+        # Add CONTENT and CONTENT.jwt to the zip file
+        write_to_zip(fab_file, ".info/CONTENT", list_file_content)
 
-    typer.secho(
-        f"🎊 Successfully built {fab_filename}", fg=typer.colors.GREEN, bold=True
-    )
+    fab_bytes = fab_buffer.getvalue()
+    fab_hash = hashlib.sha256(fab_bytes).hexdigest()
 
-    return fab_filename, fab_hash
+    return fab_bytes, fab_hash, config
 
 
 def _load_gitignore(app: Path) -> pathspec.PathSpec:

{flwr_nightly-1.19.0.dev20250510 → flwr_nightly-1.19.0.dev20250512}/py/flwr/cli/new/templates/app/code/model.baseline.py.tpl

@@ -76,5 +76,5 @@ def get_weights(net):
 def set_weights(net, parameters):
     """Apply parameters to an existing model."""
     params_dict = zip(net.state_dict().keys(), parameters)
-    state_dict = OrderedDict({k: torch.tensor(v) for k, v in params_dict})
+    state_dict = OrderedDict({k: torch.from_numpy(v) for k, v in params_dict})
     net.load_state_dict(state_dict, strict=True)

{flwr_nightly-1.19.0.dev20250510 → flwr_nightly-1.19.0.dev20250512}/py/flwr/cli/new/templates/app/code/server.baseline.py.tpl

@@ -1,15 +1,14 @@
 """$project_name: A Flower Baseline."""
 
-from typing import List, Tuple
-
 from flwr.common import Context, Metrics, ndarrays_to_parameters
 from flwr.server import ServerApp, ServerAppComponents, ServerConfig
 from flwr.server.strategy import FedAvg
+
 from $import_name.model import Net, get_weights
 
 
 # Define metric aggregation function
-def weighted_average(metrics: List[Tuple[int, Metrics]]) -> Metrics:
+def weighted_average(metrics: list[tuple[int, Metrics]]) -> Metrics:
     """Do weighted average of accuracy metric."""
     # Multiply accuracy of each client by number of examples used
     accuracies = [num_examples * float(m["accuracy"]) for num_examples, m in metrics]

{flwr_nightly-1.19.0.dev20250510 → flwr_nightly-1.19.0.dev20250512}/py/flwr/cli/new/templates/app/pyproject.baseline.toml.tpl

@@ -10,8 +10,8 @@ license = "Apache-2.0"
 dependencies = [
     "flwr[simulation]>=1.19.0",
     "flwr-datasets[vision]>=0.5.0",
-    "torch==2.5.1",
-    "torchvision==0.20.1",
+    "torch==2.6.0",
+    "torchvision==0.21.0",
 ]
 
 [tool.hatch.metadata]
@@ -23,28 +23,23 @@ dev = [
     "black==24.2.0",
     "docformatter==1.7.5",
     "mypy==1.8.0",
-    "pylint==3.2.6",
-    "flake8==5.0.4",
-    "pytest==6.2.4",
+    "pylint==3.3.1",
+    "pytest==7.4.4",
     "pytest-watch==4.2.0",
-    "ruff==0.1.9",
+    "ruff==0.4.5",
     "types-requests==2.31.0.20240125",
 ]
 
 [tool.isort]
 profile = "black"
-known_first_party = ["flwr"]
 
 [tool.black]
 line-length = 88
-target-version = ["py38", "py39", "py310", "py311"]
+target-version = ["py310", "py311", "py312"]
 
 [tool.pytest.ini_options]
 minversion = "6.2"
 addopts = "-qq"
-testpaths = [
-    "flwr_baselines",
-]
 
 [tool.mypy]
 ignore_missing_imports = true
@@ -82,11 +77,8 @@ wrap-summaries = 88
 wrap-descriptions = 88
 
 [tool.ruff]
-target-version = "py38"
+target-version = "py310"
 line-length = 88
-select = ["D", "E", "F", "W", "B", "ISC", "C4"]
-fixable = ["D", "E", "F", "W", "B", "ISC", "C4"]
-ignore = ["B024", "B027"]
 exclude = [
     ".bzr",
     ".direnv",
@@ -111,7 +103,12 @@ exclude = [
     "proto",
 ]
 
-[tool.ruff.pydocstyle]
+[tool.ruff.lint]
+select = ["D", "E", "F", "W", "B", "ISC", "C4", "UP"]
+fixable = ["D", "E", "F", "W", "B", "ISC", "C4", "UP"]
+ignore = ["B024", "B027", "D205", "D209"]
+
+[tool.ruff.lint.pydocstyle]
 convention = "numpy"
 
 [tool.hatch.build.targets.wheel]

{flwr_nightly-1.19.0.dev20250510 → flwr_nightly-1.19.0.dev20250512}/py/flwr/cli/run/run.py

@@ -24,9 +24,8 @@ from typing import Annotated, Any, Optional
 import typer
 from rich.console import Console
 
-from flwr.cli.build import build
+from flwr.cli.build import build_fab, get_fab_filename
 from flwr.cli.config_utils import (
-    get_fab_metadata,
     load_and_validate,
     process_loaded_project_config,
     validate_federation_in_project_config,
@@ -34,6 +33,7 @@ from flwr.cli.config_utils import (
 from flwr.cli.constant import FEDERATION_CONFIG_HELP_MESSAGE
 from flwr.common.config import (
     flatten_dict,
+    get_metadata_from_config,
     parse_config_args,
     user_config_to_configrecord,
 )
@@ -158,18 +158,14 @@ def _run_with_exec_api(
     channel = init_channel(app, federation_config, auth_plugin)
     stub = ExecStub(channel)
 
-    fab_path, fab_hash = build(app)
-    content = Path(fab_path).read_bytes()
-    fab_id, fab_version = get_fab_metadata(Path(fab_path))
+    fab_bytes, fab_hash, config = build_fab(app)
+    fab_id, fab_version = get_metadata_from_config(config)
 
-    # Delete FAB file once the bytes is computed
-    Path(fab_path).unlink()
-
-    fab = Fab(fab_hash, content)
+    fab = Fab(fab_hash, fab_bytes)
 
     # Construct a `ConfigRecord` out of a flattened `UserConfig`
-    fed_conf = flatten_dict(federation_config.get("options", {}))
-    c_record = user_config_to_configrecord(fed_conf)
+    fed_config = flatten_dict(federation_config.get("options", {}))
+    c_record = user_config_to_configrecord(fed_config)
 
     req = StartRunRequest(
         fab=fab_to_proto(fab),
@@ -194,7 +190,7 @@ def _run_with_exec_api(
                 "fab-name": fab_id.rsplit("/", maxsplit=1)[-1],
                 "fab-version": fab_version,
                 "fab-hash": fab_hash[:8],
-                "fab-filename": fab_path,
+                "fab-filename": get_fab_filename(config, fab_hash),
             }
         )
         restore_output()

{flwr_nightly-1.19.0.dev20250510 → flwr_nightly-1.19.0.dev20250512}/py/flwr/common/constant.py

@@ -62,6 +62,7 @@ HEARTBEAT_BASE_MULTIPLIER = 0.8
 HEARTBEAT_RANDOM_RANGE = (-0.1, 0.1)
 HEARTBEAT_MAX_INTERVAL = 1e300
 HEARTBEAT_PATIENCE = 2
+RUN_FAILURE_DETAILS_NO_HEARTBEAT = "No heartbeat received from the run."
 
 # IDs
 RUN_ID_NUM_BYTES = 8

{flwr_nightly-1.19.0.dev20250510 → flwr_nightly-1.19.0.dev20250512}/py/flwr/server/superlink/linkstate/in_memory_linkstate.py

@@ -25,12 +25,15 @@ from uuid import UUID, uuid4
 
 from flwr.common import Context, Message, log, now
 from flwr.common.constant import (
+    HEARTBEAT_MAX_INTERVAL,
     HEARTBEAT_PATIENCE,
     MESSAGE_TTL_TOLERANCE,
     NODE_ID_NUM_BYTES,
+    RUN_FAILURE_DETAILS_NO_HEARTBEAT,
     RUN_ID_NUM_BYTES,
     SUPERLINK_NODE_ID,
     Status,
+    SubStatus,
 )
 from flwr.common.record import ConfigRecord
 from flwr.common.typing import Run, RunStatus, UserConfig
@@ -52,8 +55,11 @@ class RunRecord:  # pylint: disable=R0902
     """The record of a specific run, including its status and timestamps."""
 
     run: Run
+    active_until: float = 0.0
+    heartbeat_interval: float = 0.0
     logs: list[tuple[float, str]] = field(default_factory=list)
     log_lock: threading.Lock = field(default_factory=threading.Lock)
+    lock: threading.RLock = field(default_factory=threading.RLock)
 
 
 class InMemoryLinkState(LinkState):  # pylint: disable=R0902,R0904
@@ -461,8 +467,29 @@ class InMemoryLinkState(LinkState):  # pylint: disable=R0902,R0904
         with self.lock:
             return set(self.run_ids.keys())
 
+    def _check_and_tag_inactive_run(self, run_ids: set[int]) -> None:
+        """Check if any runs are no longer active.
+
+        Marks runs with status 'starting' or 'running' as failed
+        if they have not sent a heartbeat before `active_until`.
+        """
+        current = now()
+        for record in [self.run_ids[run_id] for run_id in run_ids]:
+            with record.lock:
+                if record.run.status.status in (Status.STARTING, Status.RUNNING):
+                    if record.active_until < current.timestamp():
+                        record.run.status = RunStatus(
+                            status=Status.FINISHED,
+                            sub_status=SubStatus.FAILED,
+                            details=RUN_FAILURE_DETAILS_NO_HEARTBEAT,
+                        )
+                        record.run.finished_at = now().isoformat()
+
     def get_run(self, run_id: int) -> Optional[Run]:
         """Retrieve information about the run with the specified `run_id`."""
+        # Check if runs are still active
+        self._check_and_tag_inactive_run(run_ids={run_id})
+
         with self.lock:
             if run_id not in self.run_ids:
                 log(ERROR, "`run_id` is invalid")
@@ -471,6 +498,9 @@ class InMemoryLinkState(LinkState):  # pylint: disable=R0902,R0904
 
     def get_run_status(self, run_ids: set[int]) -> dict[int, RunStatus]:
         """Retrieve the statuses for the specified runs."""
+        # Check if runs are still active
+        self._check_and_tag_inactive_run(run_ids=run_ids)
+
         with self.lock:
             return {
                 run_id: self.run_ids[run_id].run.status
@@ -480,12 +510,16 @@ class InMemoryLinkState(LinkState):  # pylint: disable=R0902,R0904
 
     def update_run_status(self, run_id: int, new_status: RunStatus) -> bool:
         """Update the status of the run with the specified `run_id`."""
+        # Check if runs are still active
+        self._check_and_tag_inactive_run(run_ids={run_id})
+
         with self.lock:
             # Check if the run_id exists
             if run_id not in self.run_ids:
                 log(ERROR, "`run_id` is invalid")
                 return False
 
+        with self.run_ids[run_id].lock:
             # Check if the status transition is valid
             current_status = self.run_ids[run_id].run.status
             if not is_valid_transition(current_status, new_status):
@@ -507,14 +541,23 @@ class InMemoryLinkState(LinkState):  # pylint: disable=R0902,R0904
                 )
                 return False
 
-            # Update the status
+            # Initialize heartbeat_interval and active_until
+            # when switching to starting or running
+            current = now()
             run_record = self.run_ids[run_id]
+            if new_status.status in (Status.STARTING, Status.RUNNING):
+                run_record.heartbeat_interval = HEARTBEAT_MAX_INTERVAL
+                run_record.active_until = (
+                    current.timestamp() + run_record.heartbeat_interval
+                )
+
+            # Update the run status
             if new_status.status == Status.STARTING:
-                run_record.run.starting_at = now().isoformat()
+                run_record.run.starting_at = current.isoformat()
             elif new_status.status == Status.RUNNING:
-                run_record.run.running_at = now().isoformat()
+                run_record.run.running_at = current.isoformat()
             elif new_status.status == Status.FINISHED:
-                run_record.run.finished_at = now().isoformat()
+                run_record.run.finished_at = current.isoformat()
             run_record.run.status = new_status
             return True
 
@@ -558,6 +601,43 @@ class InMemoryLinkState(LinkState):  # pylint: disable=R0902,R0904
                 return True
         return False
 
+    def acknowledge_app_heartbeat(self, run_id: int, heartbeat_interval: float) -> bool:
+        """Acknowledge a heartbeat received from a ServerApp for a given run.
+
+        A run with status `"running"` is considered alive as long as it sends heartbeats
+        within the tolerated interval: HEARTBEAT_PATIENCE × heartbeat_interval.
+        HEARTBEAT_PATIENCE = N allows for N-1 missed heartbeat before the run is
+        marked as `"completed:failed"`.
+        """
+        with self.lock:
+            # Search for the run
+            record = self.run_ids.get(run_id)
+
+            # Check if the run_id exists
+            if record is None:
+                log(ERROR, "`run_id` is invalid")
+                return False
+
+        with record.lock:
+            # Check if runs are still active
+            self._check_and_tag_inactive_run(run_ids={run_id})
+
+            # Check if the run is of status "running"/"starting"
+            current_status = record.run.status
+            if current_status.status not in (Status.RUNNING, Status.STARTING):
+                log(
+                    ERROR,
+                    'Cannot acknowledge heartbeat for run with status "%s"',
+                    current_status.status,
+                )
+                return False
+
+            # Update the `active_until` and `heartbeat_interval` for the given run
+            current = now().timestamp()
+            record.active_until = current + HEARTBEAT_PATIENCE * heartbeat_interval
+            record.heartbeat_interval = heartbeat_interval
+            return True
+
     def get_serverapp_context(self, run_id: int) -> Optional[Context]:
         """Get the context for the specified `run_id`."""
         return self.contexts.get(run_id)

{flwr_nightly-1.19.0.dev20250510 → flwr_nightly-1.19.0.dev20250512}/py/flwr/server/superlink/linkstate/linkstate.py

@@ -292,6 +292,29 @@ class LinkState(abc.ABC):  # pylint: disable=R0904
             True if the heartbeat is successfully acknowledged; otherwise, False.
         """
 
+    @abc.abstractmethod
+    def acknowledge_app_heartbeat(self, run_id: int, heartbeat_interval: float) -> bool:
+        """Acknowledge a heartbeat received from a ServerApp for a given run.
+
+        A run with status `"running"` is considered alive as long as it sends heartbeats
+        within the tolerated interval: HEARTBEAT_PATIENCE × heartbeat_interval.
+        HEARTBEAT_PATIENCE = N allows for N-1 missed heartbeat before the run is
+        marked as `"completed:failed"`.
+
+        Parameters
+        ----------
+        run_id : int
+            The `run_id` from which the heartbeat was received.
+        heartbeat_interval : float
+            The interval (in seconds) from the current timestamp within which the next
+            heartbeat from the ServerApp for this run must be received.
+
+        Returns
+        -------
+        is_acknowledged : bool
+            True if the heartbeat is successfully acknowledged; otherwise, False.
+        """
+
     @abc.abstractmethod
     def get_serverapp_context(self, run_id: int) -> Optional[Context]:
         """Get the context for the specified `run_id`.