flwr-nightly 1.12.0.dev20240916__py3-none-any.whl → 1.12.0.dev20241006__py3-none-any.whl

flwr/server/superlink/state/sqlite_state.py

@@ -33,7 +33,14 @@ from flwr.proto.task_pb2 import Task, TaskIns, TaskRes  # pylint: disable=E0611
 from flwr.server.utils.validator import validate_task_ins_or_res
 
 from .state import State
-from .utils import generate_rand_int_from_bytes, make_node_unavailable_taskres
+from .utils import (
+    convert_sint64_to_uint64,
+    convert_sint64_values_in_dict_to_uint64,
+    convert_uint64_to_sint64,
+    convert_uint64_values_in_dict_to_sint64,
+    generate_rand_int_from_bytes,
+    make_node_unavailable_taskres,
+)
 
 SQL_CREATE_TABLE_NODE = """
 CREATE TABLE IF NOT EXISTS node(
@@ -223,6 +230,12 @@ class SqliteState(State):  # pylint: disable=R0904
         # Store TaskIns
         task_ins.task_id = str(task_id)
         data = (task_ins_to_dict(task_ins),)
+
+        # Convert values from uint64 to sint64 for SQLite
+        convert_uint64_values_in_dict_to_sint64(
+            data[0], ["run_id", "producer_node_id", "consumer_node_id"]
+        )
+
         columns = ", ".join([f":{key}" for key in data[0]])
         query = f"INSERT INTO task_ins VALUES({columns});"
 
@@ -284,6 +297,9 @@ class SqliteState(State):  # pylint: disable=R0904
                 AND   delivered_at = ""
             """
         else:
+            # Convert the uint64 value to sint64 for SQLite
+            data["node_id"] = convert_uint64_to_sint64(node_id)
+
             # Retrieve all TaskIns for node_id
             query = """
                 SELECT task_id
@@ -292,7 +308,6 @@ class SqliteState(State):  # pylint: disable=R0904
                 AND   consumer_node_id == :node_id
                 AND   delivered_at = ""
             """
-            data["node_id"] = node_id
 
         if limit is not None:
             query += " LIMIT :limit"
@@ -322,6 +337,12 @@ class SqliteState(State):  # pylint: disable=R0904
             # Run query
             rows = self.query(query, data)
 
+        for row in rows:
+            # Convert values from sint64 to uint64
+            convert_sint64_values_in_dict_to_uint64(
+                row, ["run_id", "producer_node_id", "consumer_node_id"]
+            )
+
         result = [dict_to_task_ins(row) for row in rows]
 
         return result
@@ -351,9 +372,26 @@ class SqliteState(State):  # pylint: disable=R0904
         # Create task_id
         task_id = uuid4()
 
-        # Store TaskIns
+        task_ins_id = task_res.task.ancestry[0]
+        task_ins = self.get_valid_task_ins(task_ins_id)
+        if task_ins is None:
+            log(
+                ERROR,
+                "Failed to store TaskRes: "
+                "TaskIns with task_id %s does not exist or has expired.",
+                task_ins_id,
+            )
+            return None
+
+        # Store TaskRes
         task_res.task_id = str(task_id)
         data = (task_res_to_dict(task_res),)
+
+        # Convert values from uint64 to sint64 for SQLite
+        convert_uint64_values_in_dict_to_sint64(
+            data[0], ["run_id", "producer_node_id", "consumer_node_id"]
+        )
+
         columns = ", ".join([f":{key}" for key in data[0]])
         query = f"INSERT INTO task_res VALUES({columns});"
 
@@ -431,6 +469,12 @@ class SqliteState(State):  # pylint: disable=R0904
             # Run query
             rows = self.query(query, data)
 
+            for row in rows:
+                # Convert values from sint64 to uint64
+                convert_sint64_values_in_dict_to_uint64(
+                    row, ["run_id", "producer_node_id", "consumer_node_id"]
+                )
+
         result = [dict_to_task_res(row) for row in rows]
 
         # 1. Query: Fetch consumer_node_id of remaining task_ids
@@ -474,6 +518,13 @@ class SqliteState(State):  # pylint: disable=R0904
         for row in task_ins_rows:
             if limit and len(result) == limit:
                 break
+
+            for row in rows:
+                # Convert values from sint64 to uint64
+                convert_sint64_values_in_dict_to_uint64(
+                    row, ["run_id", "producer_node_id", "consumer_node_id"]
+                )
+
             task_ins = dict_to_task_ins(row)
             err_taskres = make_node_unavailable_taskres(
                 ref_taskins=task_ins,
@@ -544,8 +595,11 @@ class SqliteState(State):  # pylint: disable=R0904
         self, ping_interval: float, public_key: Optional[bytes] = None
     ) -> int:
         """Create, store in state, and return `node_id`."""
-        # Sample a random int64 as node_id
-        node_id = generate_rand_int_from_bytes(NODE_ID_NUM_BYTES)
+        # Sample a random uint64 as node_id
+        uint64_node_id = generate_rand_int_from_bytes(NODE_ID_NUM_BYTES)
+
+        # Convert the uint64 value to sint64 for SQLite
+        sint64_node_id = convert_uint64_to_sint64(uint64_node_id)
 
         query = "SELECT node_id FROM node WHERE public_key = :public_key;"
         row = self.query(query, {"public_key": public_key})
@@ -562,17 +616,28 @@ class SqliteState(State):  # pylint: disable=R0904
 
         try:
             self.query(
-                query, (node_id, time.time() + ping_interval, ping_interval, public_key)
+                query,
+                (
+                    sint64_node_id,
+                    time.time() + ping_interval,
+                    ping_interval,
+                    public_key,
+                ),
             )
         except sqlite3.IntegrityError:
             log(ERROR, "Unexpected node registration failure.")
             return 0
-        return node_id
+
+        # Note: we need to return the uint64 value of the node_id
+        return uint64_node_id
 
     def delete_node(self, node_id: int, public_key: Optional[bytes] = None) -> None:
         """Delete a node."""
+        # Convert the uint64 value to sint64 for SQLite
+        sint64_node_id = convert_uint64_to_sint64(node_id)
+
         query = "DELETE FROM node WHERE node_id = ?"
-        params = (node_id,)
+        params = (sint64_node_id,)
 
         if public_key is not None:
             query += " AND public_key = ?"
@@ -597,15 +662,20 @@ class SqliteState(State):  # pylint: disable=R0904
         If the provided `run_id` does not exist or has no matching nodes,
         an empty `Set` MUST be returned.
         """
+        # Convert the uint64 value to sint64 for SQLite
+        sint64_run_id = convert_uint64_to_sint64(run_id)
+
         # Validate run ID
         query = "SELECT COUNT(*) FROM run WHERE run_id = ?;"
-        if self.query(query, (run_id,))[0]["COUNT(*)"] == 0:
+        if self.query(query, (sint64_run_id,))[0]["COUNT(*)"] == 0:
             return set()
 
         # Get nodes
         query = "SELECT node_id FROM node WHERE online_until > ?;"
         rows = self.query(query, (time.time(),))
-        result: set[int] = {row["node_id"] for row in rows}
+
+        # Convert sint64 node_ids to uint64
+        result: set[int] = {convert_sint64_to_uint64(row["node_id"]) for row in rows}
         return result
 
     def get_node_id(self, node_public_key: bytes) -> Optional[int]:
@@ -614,7 +684,11 @@ class SqliteState(State):  # pylint: disable=R0904
         row = self.query(query, {"public_key": node_public_key})
         if len(row) > 0:
             node_id: int = row[0]["node_id"]
-            return node_id
+
+            # Convert the sint64 value to uint64 after reading from SQLite
+            uint64_node_id = convert_sint64_to_uint64(node_id)
+
+            return uint64_node_id
         return None
 
     def create_run(
@@ -626,12 +700,15 @@ class SqliteState(State):  # pylint: disable=R0904
     ) -> int:
         """Create a new run for the specified `fab_id` and `fab_version`."""
         # Sample a random int64 as run_id
-        run_id = generate_rand_int_from_bytes(RUN_ID_NUM_BYTES)
+        uint64_run_id = generate_rand_int_from_bytes(RUN_ID_NUM_BYTES)
+
+        # Convert the uint64 value to sint64 for SQLite
+        sint64_run_id = convert_uint64_to_sint64(uint64_run_id)
 
         # Check conflicts
         query = "SELECT COUNT(*) FROM run WHERE run_id = ?;"
-        # If run_id does not exist
-        if self.query(query, (run_id,))[0]["COUNT(*)"] == 0:
+        # If sint64_run_id does not exist
+        if self.query(query, (sint64_run_id,))[0]["COUNT(*)"] == 0:
             query = (
                 "INSERT INTO run "
                 "(run_id, fab_id, fab_version, fab_hash, override_config)"
@@ -639,14 +716,22 @@ class SqliteState(State):  # pylint: disable=R0904
             )
             if fab_hash:
                 self.query(
-                    query, (run_id, "", "", fab_hash, json.dumps(override_config))
+                    query,
+                    (sint64_run_id, "", "", fab_hash, json.dumps(override_config)),
                 )
             else:
                 self.query(
                     query,
-                    (run_id, fab_id, fab_version, "", json.dumps(override_config)),
+                    (
+                        sint64_run_id,
+                        fab_id,
+                        fab_version,
+                        "",
+                        json.dumps(override_config),
+                    ),
                 )
-            return run_id
+            # Note: we need to return the uint64 value of the run_id
+            return uint64_run_id
         log(ERROR, "Unexpected run creation failure.")
         return 0
 
@@ -705,31 +790,64 @@ class SqliteState(State):  # pylint: disable=R0904
 
     def get_run(self, run_id: int) -> Optional[Run]:
         """Retrieve information about the run with the specified `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 = ?;"
-        try:
-            row = self.query(query, (run_id,))[0]
+        rows = self.query(query, (sint64_run_id,))
+        if rows:
+            row = rows[0]
             return Run(
-                run_id=run_id,
+                run_id=convert_sint64_to_uint64(row["run_id"]),
                 fab_id=row["fab_id"],
                 fab_version=row["fab_version"],
                 fab_hash=row["fab_hash"],
                 override_config=json.loads(row["override_config"]),
             )
-        except sqlite3.IntegrityError:
-            log(ERROR, "`run_id` does not exist.")
-            return None
+        log(ERROR, "`run_id` does not exist.")
+        return None
 
     def acknowledge_ping(self, node_id: int, ping_interval: float) -> bool:
         """Acknowledge a ping received from a node, serving as a heartbeat."""
+        sint64_node_id = convert_uint64_to_sint64(node_id)
+
         # Update `online_until` and `ping_interval` for the given `node_id`
         query = "UPDATE node SET online_until = ?, ping_interval = ? WHERE node_id = ?;"
         try:
-            self.query(query, (time.time() + ping_interval, ping_interval, node_id))
+            self.query(
+                query, (time.time() + ping_interval, ping_interval, sint64_node_id)
+            )
             return True
         except sqlite3.IntegrityError:
             log(ERROR, "`node_id` does not exist.")
             return False
 
+    def get_valid_task_ins(self, task_id: str) -> Optional[dict[str, Any]]:
+        """Check if the TaskIns exists and is valid (not expired).
+
+        Return TaskIns if valid.
+        """
+        query = """
+            SELECT *
+            FROM task_ins
+            WHERE task_id = :task_id
+        """
+        data = {"task_id": task_id}
+        rows = self.query(query, data)
+        if not rows:
+            # TaskIns does not exist
+            return None
+
+        task_ins = rows[0]
+        created_at = task_ins["created_at"]
+        ttl = task_ins["ttl"]
+        current_time = time.time()
+
+        # Check if TaskIns is expired
+        if ttl is not None and created_at + ttl <= current_time:
+            return None
+
+        return task_ins
+
 
 def dict_factory(
     cursor: sqlite3.Cursor,

flwr/server/superlink/state/utils.py

@@ -33,8 +33,104 @@ NODE_UNAVAILABLE_ERROR_REASON = (
 
 
 def generate_rand_int_from_bytes(num_bytes: int) -> int:
-    """Generate a random `num_bytes` integer."""
-    return int.from_bytes(urandom(num_bytes), "little", signed=True)
+    """Generate a random unsigned integer from `num_bytes` bytes."""
+    return int.from_bytes(urandom(num_bytes), "little", signed=False)
+
+
+def convert_uint64_to_sint64(u: int) -> int:
+    """Convert a uint64 value to a sint64 value with the same bit sequence.
+
+    Parameters
+    ----------
+    u : int
+        The unsigned 64-bit integer to convert.
+
+    Returns
+    -------
+    int
+        The signed 64-bit integer equivalent.
+
+        The signed 64-bit integer will have the same bit pattern as the
+        unsigned 64-bit integer but may have a different decimal value.
+
+        For numbers within the range [0, `sint64` max value], the decimal
+        value remains the same. However, for numbers greater than the `sint64`
+        max value, the decimal value will differ due to the wraparound caused
+        by the sign bit.
+    """
+    if u >= (1 << 63):
+        return u - (1 << 64)
+    return u
+
+
+def convert_sint64_to_uint64(s: int) -> int:
+    """Convert a sint64 value to a uint64 value with the same bit sequence.
+
+    Parameters
+    ----------
+    s : int
+        The signed 64-bit integer to convert.
+
+    Returns
+    -------
+    int
+        The unsigned 64-bit integer equivalent.
+
+        The unsigned 64-bit integer will have the same bit pattern as the
+        signed 64-bit integer but may have a different decimal value.
+
+        For negative `sint64` values, the conversion adds 2^64 to the
+        signed value to obtain the equivalent `uint64` value. For non-negative
+        `sint64` values, the decimal value remains unchanged in the `uint64`
+        representation.
+    """
+    if s < 0:
+        return s + (1 << 64)
+    return s
+
+
+def convert_uint64_values_in_dict_to_sint64(
+    data_dict: dict[str, int], keys: list[str]
+) -> None:
+    """Convert uint64 values to sint64 in the given dictionary.
+
+    Parameters
+    ----------
+    data_dict : dict[str, int]
+        A dictionary where the values are integers to be converted.
+    keys : list[str]
+        A list of keys in the dictionary whose values need to be converted.
+
+    Returns
+    -------
+    None
+        This function does not return a value. It modifies `data_dict` in place.
+    """
+    for key in keys:
+        if key in data_dict:
+            data_dict[key] = convert_uint64_to_sint64(data_dict[key])
+
+
+def convert_sint64_values_in_dict_to_uint64(
+    data_dict: dict[str, int], keys: list[str]
+) -> None:
+    """Convert sint64 values to uint64 in the given dictionary.
+
+    Parameters
+    ----------
+    data_dict : dict[str, int]
+        A dictionary where the values are integers to be converted.
+    keys : list[str]
+        A list of keys in the dictionary whose values need to be converted.
+
+    Returns
+    -------
+    None
+        This function does not return a value. It modifies `data_dict` in place.
+    """
+    for key in keys:
+        if key in data_dict:
+            data_dict[key] = convert_sint64_to_uint64(data_dict[key])
 
 
 def make_node_unavailable_taskres(ref_taskins: TaskIns) -> TaskRes:

flwr/server/utils/validator.py

@@ -15,6 +15,7 @@
 """Validators."""
 
 
+import time
 from typing import Union
 
 from flwr.proto.task_pb2 import TaskIns, TaskRes  # pylint: disable=E0611
@@ -47,6 +48,11 @@ def validate_task_ins_or_res(tasks_ins_res: Union[TaskIns, TaskRes]) -> list[str
         # unix timestamp of 27 March 2024 00h:00m:00s UTC
         validation_errors.append("`pushed_at` is not a recent timestamp")
 
+    # Verify TTL and created_at time
+    current_time = time.time()
+    if tasks_ins_res.task.created_at + tasks_ins_res.task.ttl <= current_time:
+        validation_errors.append("Task TTL has expired")
+
     # TaskIns specific
     if isinstance(tasks_ins_res, TaskIns):
         # Task producer

flwr/superexec/deployment.py

@@ -28,8 +28,8 @@ from flwr.common.grpc import create_channel
 from flwr.common.logger import log
 from flwr.common.serde import fab_to_proto, user_config_to_proto
 from flwr.common.typing import Fab, UserConfig
-from flwr.proto.driver_pb2 import CreateRunRequest  # pylint: disable=E0611
 from flwr.proto.driver_pb2_grpc import DriverStub
+from flwr.proto.run_pb2 import CreateRunRequest  # pylint: disable=E0611
 
 from .executor import Executor, RunTracker
 
@@ -167,6 +167,8 @@ class DeploymentEngine(Executor):
             # Execute the command
             proc = subprocess.Popen(  # pylint: disable=consider-using-with
                 command,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
                 text=True,
             )
             log(INFO, "Started run %s", str(run_id))

flwr/superexec/exec_servicer.py

@@ -15,6 +15,10 @@
 """SuperExec API servicer."""
 
 
+import select
+import sys
+import threading
+import time
 from collections.abc import Generator
 from logging import ERROR, INFO
 from typing import Any
@@ -33,6 +37,8 @@ from flwr.proto.exec_pb2 import (  # pylint: disable=E0611
 
 from .executor import Executor, RunTracker
 
+SELECT_TIMEOUT = 1  # Timeout for selecting ready-to-read file descriptors (in seconds)
+
 
 class ExecServicer(exec_pb2_grpc.ExecServicer):
     """SuperExec API servicer."""
@@ -59,13 +65,72 @@ class ExecServicer(exec_pb2_grpc.ExecServicer):
 
         self.runs[run.run_id] = run
 
+        # Start a background thread to capture the log output
+        capture_thread = threading.Thread(
+            target=_capture_logs, args=(run,), daemon=True
+        )
+        capture_thread.start()
+
         return StartRunResponse(run_id=run.run_id)
 
-    def StreamLogs(
+    def StreamLogs(  # pylint: disable=C0103
         self, request: StreamLogsRequest, context: grpc.ServicerContext
     ) -> Generator[StreamLogsResponse, Any, None]:
         """Get logs."""
-        logs = ["a", "b", "c"]
+        log(INFO, "ExecServicer.StreamLogs")
+
+        # Exit if `run_id` not found
+        if request.run_id not in self.runs:
+            context.abort(grpc.StatusCode.NOT_FOUND, "Run ID not found")
+
+        last_sent_index = 0
         while context.is_active():
-            for i in range(len(logs)):  # pylint: disable=C0200
+            # Yield n'th row of logs, if n'th row < len(logs)
+            logs = self.runs[request.run_id].logs
+            for i in range(last_sent_index, len(logs)):
                 yield StreamLogsResponse(log_output=logs[i])
+            last_sent_index = len(logs)
+
+            # Wait for and continue to yield more log responses only if the
+            # run isn't completed yet. If the run is finished, the entire log
+            # is returned at this point and the server ends the stream.
+            if self.runs[request.run_id].proc.poll() is not None:
+                log(INFO, "All logs for run ID `%s` returned", request.run_id)
+                context.set_code(grpc.StatusCode.OK)
+                context.cancel()
+
+            time.sleep(1.0)  # Sleep briefly to avoid busy waiting
+
+
+def _capture_logs(
+    run: RunTracker,
+) -> None:
+    while True:
+        # Explicitly check if Popen.poll() is None. Required for `pytest`.
+        if run.proc.poll() is None:
+            # Select streams only when ready to read
+            ready_to_read, _, _ = select.select(
+                [run.proc.stdout, run.proc.stderr],
+                [],
+                [],
+                SELECT_TIMEOUT,
+            )
+            # Read from std* and append to RunTracker.logs
+            for stream in ready_to_read:
+                # Flush stdout to view output in real time
+                readline = stream.readline()
+                sys.stdout.write(readline)
+                sys.stdout.flush()
+                # Append to logs
+                line = readline.rstrip()
+                if line:
+                    run.logs.append(f"{line}")
+
+        # Close std* to prevent blocking
+        elif run.proc.poll() is not None:
+            log(INFO, "Subprocess finished, exiting log capture")
+            if run.proc.stdout:
+                run.proc.stdout.close()
+            if run.proc.stderr:
+                run.proc.stderr.close()
+            break

flwr/superexec/executor.py

@@ -15,7 +15,7 @@
 """Execute and monitor a Flower run."""
 
 from abc import ABC, abstractmethod
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from subprocess import Popen
 from typing import Optional
 
@@ -28,6 +28,7 @@ class RunTracker:
 
     run_id: int
     proc: Popen  # type: ignore
+    logs: list[str] = field(default_factory=list)
 
 
 class Executor(ABC):

{flwr_nightly-1.12.0.dev20240916.dist-info → flwr_nightly-1.12.0.dev20241006.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: flwr-nightly
-Version: 1.12.0.dev20240916
+Version: 1.12.0.dev20241006
 Summary: Flower: A Friendly Federated Learning Framework
 Home-page: https://flower.ai
 License: Apache-2.0
@@ -43,7 +43,7 @@ Requires-Dist: requests (>=2.31.0,<3.0.0) ; extra == "rest"
 Requires-Dist: starlette (>=0.31.0,<0.32.0) ; extra == "rest"
 Requires-Dist: tomli (>=2.0.1,<3.0.0)
 Requires-Dist: tomli-w (>=1.0.0,<2.0.0)
-Requires-Dist: typer[all] (>=0.9.0,<0.10.0)
+Requires-Dist: typer (>=0.12.5,<0.13.0)
 Requires-Dist: uvicorn[standard] (>=0.23.0,<0.24.0) ; extra == "rest"
 Project-URL: Documentation, https://flower.ai
 Project-URL: Repository, https://github.com/adap/flower
@@ -69,6 +69,7 @@ Description-Content-Type: text/markdown
 [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](https://github.com/adap/flower/blob/main/CONTRIBUTING.md)
 ![Build](https://github.com/adap/flower/actions/workflows/framework.yml/badge.svg)
 [![Downloads](https://static.pepy.tech/badge/flwr)](https://pepy.tech/project/flwr)
+[![Docker Hub](https://img.shields.io/badge/Docker%20Hub-flwr-blue)](https://hub.docker.com/u/flwr)
 [![Slack](https://img.shields.io/badge/Chat-Slack-red)](https://flower.ai/join-slack)
 
 Flower (`flwr`) is a framework for building federated learning systems. The
@@ -152,6 +153,7 @@ Flower Baselines is a collection of community-contributed projects that reproduc
 - [FedNova](https://github.com/adap/flower/tree/main/baselines/fednova)
 - [HeteroFL](https://github.com/adap/flower/tree/main/baselines/heterofl)
 - [FedAvgM](https://github.com/adap/flower/tree/main/baselines/fedavgm)
+- [FedRep](https://github.com/adap/flower/tree/main/baselines/fedrep)
 - [FedStar](https://github.com/adap/flower/tree/main/baselines/fedstar)
 - [FedWav2vec2](https://github.com/adap/flower/tree/main/baselines/fedwav2vec2)
 - [FjORD](https://github.com/adap/flower/tree/main/baselines/fjord)