flwr-nightly 1.19.0.dev20250510__py3-none-any.whl → 1.19.0.dev20250512__py3-none-any.whl

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/cli/new/templates/app/code/client.baseline.py.tpl

@@ -1,9 +1,9 @@
 """$project_name: A Flower Baseline."""
 
 import torch
-
 from flwr.client import ClientApp, NumPyClient
 from flwr.common import Context
+
 from $import_name.dataset import load_data
 from $import_name.model import Net, get_weights, set_weights, test, train
 

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/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/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/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/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/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/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`.

flwr/server/superlink/linkstate/sqlite_linkstate.py

@@ -28,12 +28,15 @@ from uuid import UUID, uuid4
 
 from flwr.common import Context, Message, Metadata, 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.message import make_message
 from flwr.common.record import ConfigRecord
@@ -92,6 +95,8 @@ CREATE INDEX IF NOT EXISTS idx_online_until ON node (online_until);
 SQL_CREATE_TABLE_RUN = """
 CREATE TABLE IF NOT EXISTS run(
     run_id                INTEGER UNIQUE,
+    active_until          REAL,
+    heartbeat_interval    REAL,
     fab_id                TEXT,
     fab_version           TEXT,
     fab_hash              TEXT,
@@ -742,20 +747,21 @@ class SqliteLinkState(LinkState):  # pylint: disable=R0904
         if self.query(query, (sint64_run_id,))[0]["COUNT(*)"] == 0:
             query = (
                 "INSERT INTO run "
-                "(run_id, fab_id, fab_version, fab_hash, override_config, "
-                "federation_options, pending_at, starting_at, running_at, finished_at, "
-                "sub_status, details) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);"
+                "(run_id, active_until, heartbeat_interval, fab_id, fab_version, "
+                "fab_hash, override_config, federation_options, pending_at, "
+                "starting_at, running_at, finished_at, sub_status, details) "
+                "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);"
             )
             override_config_json = json.dumps(override_config)
             data = [
                 sint64_run_id,
+                0,  # The `active_until` is not used until the run is started
+                0,  # This `heartbeat_interval` is not used until the run is started
                 fab_id,
                 fab_version,
                 fab_hash,
                 override_config_json,
                 configrecord_to_bytes(federation_options),
-            ]
-            data += [
                 now().isoformat(),
                 "",
                 "",
@@ -796,8 +802,33 @@ class SqliteLinkState(LinkState):  # pylint: disable=R0904
         rows = self.query(query)
         return {convert_sint64_to_uint64(row["run_id"]) for row in rows}
 
+    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`.
+        """
+        sint_run_ids = [convert_uint64_to_sint64(run_id) for run_id in run_ids]
+        query = "UPDATE run SET finished_at = ?, sub_status = ?, details = ? "
+        query += "WHERE starting_at != '' AND finished_at = '' AND active_until < ?"
+        query += f" AND run_id IN ({','.join(['?'] * len(run_ids))});"
+        current = now()
+        self.query(
+            query,
+            (
+                current.isoformat(),
+                SubStatus.FAILED,
+                RUN_FAILURE_DETAILS_NO_HEARTBEAT,
+                current.timestamp(),
+                *sint_run_ids,
+            ),
+        )
+
     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})
+
         # Convert the uint64 value to sint64 for SQLite
         sint64_run_id = convert_uint64_to_sint64(run_id)
         query = "SELECT * FROM run WHERE run_id = ?;"
@@ -825,6 +856,9 @@ class SqliteLinkState(LinkState):  # pylint: disable=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)
+
         # Convert the uint64 value to sint64 for SQLite
         sint64_run_ids = (convert_uint64_to_sint64(run_id) for run_id in set(run_ids))
         query = f"SELECT * FROM run WHERE run_id IN ({','.join(['?'] * len(run_ids))});"
@@ -842,6 +876,9 @@ class SqliteLinkState(LinkState):  # pylint: disable=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})
+
         # Convert the uint64 value to sint64 for SQLite
         sint64_run_id = convert_uint64_to_sint64(run_id)
         query = "SELECT * FROM run WHERE run_id = ?;"
@@ -879,9 +916,22 @@ class SqliteLinkState(LinkState):  # pylint: disable=R0904
             return False
 
         # Update the status
-        query = "UPDATE run SET %s= ?, sub_status = ?, details = ? "
+        query = "UPDATE run SET %s= ?, sub_status = ?, details = ?, "
+        query += "active_until = ?, heartbeat_interval = ? "
         query += "WHERE run_id = ?;"
 
+        # Prepare data for query
+        # Initialize heartbeat_interval and active_until
+        # when switching to starting or running
+        current = now()
+        if new_status.status in (Status.STARTING, Status.RUNNING):
+            heartbeat_interval = HEARTBEAT_MAX_INTERVAL
+            active_until = current.timestamp() + heartbeat_interval
+        else:
+            heartbeat_interval = 0
+            active_until = 0
+
+        # Determine the timestamp field based on the new status
         timestamp_fld = ""
         if new_status.status == Status.STARTING:
             timestamp_fld = "starting_at"
@@ -891,10 +941,12 @@ class SqliteLinkState(LinkState):  # pylint: disable=R0904
             timestamp_fld = "finished_at"
 
         data = (
-            now().isoformat(),
+            current.isoformat(),
             new_status.sub_status,
             new_status.details,
-            sint64_run_id,
+            active_until,
+            heartbeat_interval,
+            convert_uint64_to_sint64(run_id),
         )
         self.query(query % timestamp_fld, data)
         return True
@@ -957,6 +1009,44 @@ class SqliteLinkState(LinkState):  # pylint: disable=R0904
         )
         return True
 
+    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"`.
+        """
+        # Check if runs are still active
+        self._check_and_tag_inactive_run(run_ids={run_id})
+
+        # Search for the run
+        sint_run_id = convert_uint64_to_sint64(run_id)
+        query = "SELECT * FROM run WHERE run_id = ?;"
+        rows = self.query(query, (sint_run_id,))
+
+        if not rows:
+            log(ERROR, "`run_id` is invalid")
+            return False
+
+        # Check if the run is of status "running"/"starting"
+        row = rows[0]
+        status = determine_run_status(row)
+        if status not in (Status.RUNNING, Status.STARTING):
+            log(
+                ERROR,
+                'Cannot acknowledge heartbeat for run with status "%s"',
+                status,
+            )
+            return False
+
+        # Update the `active_until` and `heartbeat_interval` for the given run
+        active_until = now().timestamp() + HEARTBEAT_PATIENCE * heartbeat_interval
+        query = "UPDATE run SET active_until = ?, heartbeat_interval = ? "
+        query += "WHERE run_id = ?"
+        self.query(query, (active_until, heartbeat_interval, sint_run_id))
+        return True
+
     def get_serverapp_context(self, run_id: int) -> Optional[Context]:
         """Get the context for the specified `run_id`."""
         # Retrieve context if any

{flwr_nightly-1.19.0.dev20250510.dist-info → flwr_nightly-1.19.0.dev20250512.dist-info}/METADATA

@@ -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.dist-info → flwr_nightly-1.19.0.dev20250512.dist-info}/RECORD

@@ -3,7 +3,7 @@ flwr/cli/__init__.py,sha256=EfMGmHoobET6P2blBt_eOByXL8299MgFfB7XNdaPQ6I,720
 flwr/cli/app.py,sha256=AKCP45Dkbpvdil_4Ir9S93L3HP3iUOnHmcZjscoM8uU,1856
 flwr/cli/auth_plugin/__init__.py,sha256=FyaoqPzcxlBTFfJ2sBRC5USwQLmAhFr5KuBwfMO4bmo,1052
 flwr/cli/auth_plugin/oidc_cli_plugin.py,sha256=gIhW6Jg9QAo-jL43LYPpw_kn7pdUZZae0s0H8dEgjLM,5384
-flwr/cli/build.py,sha256=sPzCAZC0gDytpDqMO3aHBcdCzQVXqRhts4TJYSZNu1E,6375
+flwr/cli/build.py,sha256=bzvXbA0MdNMni3uu8KUl32y3VOTJpsUToxNQl_0qE6U,6967
 flwr/cli/cli_user_auth_interceptor.py,sha256=-JqDXpeZNQVwoSG7hMKsiS5qY5k5oklNSlQOVpM0-aY,3126
 flwr/cli/config_utils.py,sha256=IAVn2uWTXpN72YYt7raLtwp8ziwZugUKSURpc471VzU,9123
 flwr/cli/constant.py,sha256=g7Ad7o3DJDkJNrWS0T3SSJETWSTkkVJWGpLM8zlbpcY,1289
@@ -25,7 +25,7 @@ flwr/cli/new/templates/app/__init__.py,sha256=LbR0ksGiF566JcHM_H5m1Tc4-oYUEilWFl
 flwr/cli/new/templates/app/code/__init__.baseline.py.tpl,sha256=YkHAgppUeD2BnBoGfVB6dEvBfjuIPGsU1gw4CiUi3qA,40
 flwr/cli/new/templates/app/code/__init__.py,sha256=zXa2YU1swzHxOKDQbwlDMEwVPOUswVeosjkiXNMTgFo,736
 flwr/cli/new/templates/app/code/__init__.py.tpl,sha256=J0Gn74E7khpLyKJVNqOPu7ev93vkcu1PZugsbxtABMw,52
-flwr/cli/new/templates/app/code/client.baseline.py.tpl,sha256=1htktXX3jXX05r0vuG_afjS1sXGtuONW9EpiQ7vSBes,1901
+flwr/cli/new/templates/app/code/client.baseline.py.tpl,sha256=IYlCZqnaxT2ucP1ReffRNohOkYwNrhtrnDoQBBcrThY,1901
 flwr/cli/new/templates/app/code/client.huggingface.py.tpl,sha256=ifD08KwjdoGieV26hFCgf3PQB6rMhj_NZLo5iUUndm8,1846
 flwr/cli/new/templates/app/code/client.jax.py.tpl,sha256=4EkcGGmbPAa6dgw8GYII-GfrGsu8VU6amRHpJvF0WuA,1319
 flwr/cli/new/templates/app/code/client.mlx.py.tpl,sha256=gOxt_QUTfGFpofdNaxdwTSLZlkTWHPYGix2OGHC1hYE,2376
@@ -40,8 +40,8 @@ flwr/cli/new/templates/app/code/flwr_tune/dataset.py.tpl,sha256=1NA2Sf-EviNtOaYN
 flwr/cli/new/templates/app/code/flwr_tune/models.py.tpl,sha256=ONJw_BgBWEofVNGRDu8KAIThb8saRQlUEK4uS2u_6To,2449
 flwr/cli/new/templates/app/code/flwr_tune/server_app.py.tpl,sha256=xkmmBKr0oGmewP56SP3s_6FG6JOVlGlquhg3a9nYMis,3270
 flwr/cli/new/templates/app/code/flwr_tune/strategy.py.tpl,sha256=BhiqRg9w1MGuU5h2_vrLhRc0oHItYzE69qX_JI411k8,2754
-flwr/cli/new/templates/app/code/model.baseline.py.tpl,sha256=cSz6-IWsnMl7s04DW4URINiIppCIberrtE8NqK6Qz48,2571
-flwr/cli/new/templates/app/code/server.baseline.py.tpl,sha256=outx7lDXsWS8QXKWOGOiDno6eE8WL7LBD51ZkAuC3WU,1570
+flwr/cli/new/templates/app/code/model.baseline.py.tpl,sha256=zJklLwH4vPx7rruzhzbAGdInxjjJw-djHCuCx5wshVA,2575
+flwr/cli/new/templates/app/code/server.baseline.py.tpl,sha256=rBB-DKEuA2SG1DGLW8uSHUg-GydEgb-7NHEclsC2X2g,1539
 flwr/cli/new/templates/app/code/server.huggingface.py.tpl,sha256=0PJmnZvR9_VPLSak1yVfkOx3dmqo6cynhY1l2s4AZrE,1158
 flwr/cli/new/templates/app/code/server.jax.py.tpl,sha256=IHk57syZhvO4nWVHGxE9S8f5DTxRKIrTitDufF4RhMY,828
 flwr/cli/new/templates/app/code/server.mlx.py.tpl,sha256=GAqalaI-U2uRdttNeRn75k1FzdEW3rmgT-ywuKkFdK4,988
@@ -58,7 +58,7 @@ flwr/cli/new/templates/app/code/task.pytorch.py.tpl,sha256=XlJqA4Ix_PloO_zJLhjiN
 flwr/cli/new/templates/app/code/task.sklearn.py.tpl,sha256=vHdhtMp0FHxbYafXyhDT9aKmmmA0Jvpx5Oum1Yu9lWY,1850
 flwr/cli/new/templates/app/code/task.tensorflow.py.tpl,sha256=SKXAZdgBnPpbAbJ90Rb7oQ5ilnopBx_j_JNFoUDeEAI,1732
 flwr/cli/new/templates/app/code/utils.baseline.py.tpl,sha256=YkHAgppUeD2BnBoGfVB6dEvBfjuIPGsU1gw4CiUi3qA,40
-flwr/cli/new/templates/app/pyproject.baseline.toml.tpl,sha256=2oESgA-m-fU_i4Tsjq-Sooe9t4BZmU3Jo4WvHbFbWsM,2666
+flwr/cli/new/templates/app/pyproject.baseline.toml.tpl,sha256=_hhn9kMIaiQDKe2qlx3flQVHVvqtckKG3WbuXw-ZUzc,2623
 flwr/cli/new/templates/app/pyproject.flowertune.toml.tpl,sha256=4WfSNMTbhJ-_CQ71gphHVocGBrPxOe33VThGXKmsiHY,1873
 flwr/cli/new/templates/app/pyproject.huggingface.toml.tpl,sha256=f7xUVuqemFliGqqmwJ_vDgIlBtJM71yTJsXdSzkPDDA,1143
 flwr/cli/new/templates/app/pyproject.jax.toml.tpl,sha256=35AUGbM1hMlJ4plYsFkydiYvG3XWIOLNnlcemWtIgn4,673
@@ -68,7 +68,7 @@ flwr/cli/new/templates/app/pyproject.pytorch.toml.tpl,sha256=dckyBDmvBHbPNB5LQhX
 flwr/cli/new/templates/app/pyproject.sklearn.toml.tpl,sha256=F93FdohqSBzcdFanew33V8bBeC3s9r3IaV8tfd4zw-E,686
 flwr/cli/new/templates/app/pyproject.tensorflow.toml.tpl,sha256=7aOtbvAAnVXyTEYLsg_LtxDRQD16XUjRmnENgAWyiMs,710
 flwr/cli/run/__init__.py,sha256=RPyB7KbYTFl6YRiilCch6oezxrLQrl1kijV7BMGkLbA,790
-flwr/cli/run/run.py,sha256=t3vgDeSGKgptYbGKLLTVAcGB-ZQqu3Ui0cVloA-eoy8,8277
+flwr/cli/run/run.py,sha256=mbyf46Tm3qrL8NW02JyDjs6BI49m9UMzXsGK8-Af1r4,8232
 flwr/cli/stop.py,sha256=iLbh1dq8XMdcIlh0Lh8ufG6h0VvrP1kyp_mGO-kimt0,4976
 flwr/cli/utils.py,sha256=FjRYfzTw75qh5YHmrg9XzBA6o73T6xWt9WQYIxq-iHY,11207
 flwr/client/__init__.py,sha256=FslaZOoCGPIzlK-NhL7bFMVVnmFDOh_PhW4AfGzno68,1192
@@ -115,7 +115,7 @@ flwr/common/args.py,sha256=-aX_jVnSaDrJR2KZ8Wq0Y3dQHII4R4MJtJOIXzVUA0c,5417
 flwr/common/auth_plugin/__init__.py,sha256=m271m9YjK2QfKDOuIIhcTvGmv1GWh1PL97QB05NTSHs,887
 flwr/common/auth_plugin/auth_plugin.py,sha256=GaXw4IiU2DkVNkp5S9ue821sbkU9zWSu6HSVZetEdjs,3938
 flwr/common/config.py,sha256=glcZDjco-amw1YfQcYTFJ4S1pt9APoexT-mf1QscuHs,13960
-flwr/common/constant.py,sha256=RmVW2YLGosdBzyePgj2EMdZnHrT1PKEtNScaNK_FHZ0,7302
+flwr/common/constant.py,sha256=Q8N-up1TvL_vllV_QA8mQlKjqVJ6Kdoze3iem6nSF9E,7375
 flwr/common/context.py,sha256=Be8obQR_OvEDy1OmshuUKxGRQ7Qx89mf5F4xlhkR10s,2407
 flwr/common/date.py,sha256=1ZT2cRSpC2DJqprOVTLXYCR_O2_OZR0zXO_brJ3LqWc,1554
 flwr/common/differential_privacy.py,sha256=FdlpdpPl_H_2HJa8CQM1iCUGBBQ5Dc8CzxmHERM-EoE,6148
@@ -293,10 +293,10 @@ flwr/server/superlink/fleet/vce/backend/backend.py,sha256=-wDHjgAy5mrfEgXj0GxkJI
 flwr/server/superlink/fleet/vce/backend/raybackend.py,sha256=Hx9hxL7lju1_VJoAwkhBOGerZ3628u0P1zgkPhGWRPY,7154
 flwr/server/superlink/fleet/vce/vce_api.py,sha256=m7WUiHRl-jTqzjH3cqNCj3RXe3ohT6V6I0JIR6zWZj8,12780
 flwr/server/superlink/linkstate/__init__.py,sha256=OtsgvDTnZLU3k0sUbkHbqoVwW6ql2FDmb6uT6DbNkZo,1064
-flwr/server/superlink/linkstate/in_memory_linkstate.py,sha256=vu36ntb9N1qeDWvt6YsnPfvVppZPJi04icAgolui9no,22520
-flwr/server/superlink/linkstate/linkstate.py,sha256=zrVR9UpeuCfgqK5MDIqudcXtFjvsCRjD2ylv4UZu8MU,12140
+flwr/server/superlink/linkstate/in_memory_linkstate.py,sha256=vvoOWjYlmOlbakH7AzpMh0jB70Qxx7UTlAGqjcA8ctM,25926
+flwr/server/superlink/linkstate/linkstate.py,sha256=j6nW351t07VrBhFqjO34z8tf2PuKOE9aCX9SqpW96pQ,13100
 flwr/server/superlink/linkstate/linkstate_factory.py,sha256=8RlosqSpKOoD_vhUUQPY0jtE3A84GeF96Z7sWNkRRcA,2069
-flwr/server/superlink/linkstate/sqlite_linkstate.py,sha256=c-6iopBJ3Y09Jh0qYka02tdIUF3Aq9X0nrBK5eAuwOk,39847
+flwr/server/superlink/linkstate/sqlite_linkstate.py,sha256=E43YO88vdnG9GW6Rwh9Fb7oWGgEABS9RXDRg3OR3T4Q,43573
 flwr/server/superlink/linkstate/utils.py,sha256=AJs9jTAEK7JnjF2AODXnOfy0pKAKpe6oUWPCanAP57s,15382
 flwr/server/superlink/serverappio/__init__.py,sha256=Fy4zJuoccZe5mZSEIpOmQvU6YeXFBa1M4eZuXXmJcn8,717
 flwr/server/superlink/serverappio/serverappio_grpc.py,sha256=opJ6SYwIAbu4NWEo3K-VxFO-tMSFmE4H3i2HwHIVRzw,2173
@@ -333,7 +333,7 @@ flwr/superexec/exec_servicer.py,sha256=Z0YYfs6eNPhqn8rY0x_R04XgR2mKFpggt07IH0EhU
 flwr/superexec/exec_user_auth_interceptor.py,sha256=iqygALkOMBUu_s_R9G0mFThZA7HTUzuXCLgxLCefiwI,4440
 flwr/superexec/executor.py,sha256=M5ucqSE53jfRtuCNf59WFLqQvA1Mln4741TySeZE7qQ,3112
 flwr/superexec/simulation.py,sha256=j6YwUvBN7EQ09ID7MYOCVZ70PGbuyBy8f9bXU0EszEM,4088
-flwr_nightly-1.19.0.dev20250510.dist-info/METADATA,sha256=xpLHVo5qUcXHQZ8I7pPAqABpFf4KBBoRQxccdZ8GmzY,15880
-flwr_nightly-1.19.0.dev20250510.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-flwr_nightly-1.19.0.dev20250510.dist-info/entry_points.txt,sha256=2-1L-GNKhwGw2_7_RoH55vHw2SIHjdAQy3HAVAWl9PY,374
-flwr_nightly-1.19.0.dev20250510.dist-info/RECORD,,
+flwr_nightly-1.19.0.dev20250512.dist-info/METADATA,sha256=Sc_-zl1MmehvY10Jr4aE7QBaKxEY_ZXfqbsGdnCAEAc,15910
+flwr_nightly-1.19.0.dev20250512.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+flwr_nightly-1.19.0.dev20250512.dist-info/entry_points.txt,sha256=2-1L-GNKhwGw2_7_RoH55vHw2SIHjdAQy3HAVAWl9PY,374
+flwr_nightly-1.19.0.dev20250512.dist-info/RECORD,,