flwr-nightly 1.14.0.dev20241216__py3-none-any.whl → 1.15.0.dev20250112__py3-none-any.whl

flwr/server/superlink/linkstate/sqlite_linkstate.py

@@ -72,14 +72,14 @@ CREATE TABLE IF NOT EXISTS node(
 
 SQL_CREATE_TABLE_CREDENTIAL = """
 CREATE TABLE IF NOT EXISTS credential(
-    private_key BLOB PRIMARY KEY,
-    public_key BLOB
+    private_key     BLOB PRIMARY KEY,
+    public_key      BLOB
 );
 """
 
 SQL_CREATE_TABLE_PUBLIC_KEY = """
 CREATE TABLE IF NOT EXISTS public_key(
-    public_key BLOB UNIQUE
+    public_key      BLOB PRIMARY KEY
 );
 """
 
@@ -635,9 +635,7 @@ class SqliteLinkState(LinkState):  # pylint: disable=R0904
 
         return {UUID(row["task_id"]) for row in rows}
 
-    def create_node(
-        self, ping_interval: float, public_key: Optional[bytes] = None
-    ) -> int:
+    def create_node(self, ping_interval: float) -> int:
         """Create, store in the link state, and return `node_id`."""
         # Sample a random uint64 as node_id
         uint64_node_id = generate_rand_int_from_bytes(NODE_ID_NUM_BYTES)
@@ -645,13 +643,6 @@ class SqliteLinkState(LinkState):  # pylint: disable=R0904
         # 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})
-
-        if len(row) > 0:
-            log(ERROR, "Unexpected node registration failure.")
-            return 0
-
         query = (
             "INSERT INTO node "
             "(node_id, online_until, ping_interval, public_key) "
@@ -665,7 +656,7 @@ class SqliteLinkState(LinkState):  # pylint: disable=R0904
                     sint64_node_id,
                     time.time() + ping_interval,
                     ping_interval,
-                    public_key,
+                    b"",  # Initialize with an empty public key
                 ),
             )
         except sqlite3.IntegrityError:
@@ -675,7 +666,7 @@ class SqliteLinkState(LinkState):  # pylint: disable=R0904
         # 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:
+    def delete_node(self, node_id: int) -> None:
         """Delete a node."""
         # Convert the uint64 value to sint64 for SQLite
         sint64_node_id = convert_uint64_to_sint64(node_id)
@@ -683,10 +674,6 @@ class SqliteLinkState(LinkState):  # pylint: disable=R0904
         query = "DELETE FROM node WHERE node_id = ?"
         params = (sint64_node_id,)
 
-        if public_key is not None:
-            query += " AND public_key = ?"
-            params += (public_key,)  # type: ignore
-
         if self.conn is None:
             raise AttributeError("LinkState is not initialized.")
 
@@ -694,7 +681,7 @@ class SqliteLinkState(LinkState):  # pylint: disable=R0904
             with self.conn:
                 rows = self.conn.execute(query, params)
                 if rows.rowcount < 1:
-                    raise ValueError("Public key or node_id not found")
+                    raise ValueError(f"Node {node_id} not found")
         except KeyError as exc:
             log(ERROR, {"query": query, "data": params, "exception": exc})
 
@@ -722,6 +709,41 @@ class SqliteLinkState(LinkState):  # pylint: disable=R0904
         result: set[int] = {convert_sint64_to_uint64(row["node_id"]) for row in rows}
         return result
 
+    def set_node_public_key(self, node_id: int, public_key: bytes) -> None:
+        """Set `public_key` for the specified `node_id`."""
+        # Convert the uint64 value to sint64 for SQLite
+        sint64_node_id = convert_uint64_to_sint64(node_id)
+
+        # Check if the node exists in the `node` table
+        query = "SELECT 1 FROM node WHERE node_id = ?"
+        if not self.query(query, (sint64_node_id,)):
+            raise ValueError(f"Node {node_id} not found")
+
+        # Check if the public key is already in use in the `node` table
+        query = "SELECT 1 FROM node WHERE public_key = ?"
+        if self.query(query, (public_key,)):
+            raise ValueError("Public key already in use")
+
+        # Update the `node` table to set the public key for the given node ID
+        query = "UPDATE node SET public_key = ? WHERE node_id = ?"
+        self.query(query, (public_key, sint64_node_id))
+
+    def get_node_public_key(self, node_id: int) -> Optional[bytes]:
+        """Get `public_key` for the specified `node_id`."""
+        # Convert the uint64 value to sint64 for SQLite
+        sint64_node_id = convert_uint64_to_sint64(node_id)
+
+        # Query the public key for the given node_id
+        query = "SELECT public_key FROM node WHERE node_id = ?"
+        rows = self.query(query, (sint64_node_id,))
+
+        # If no result is found, return None
+        if not rows:
+            raise ValueError(f"Node {node_id} not found")
+
+        # Return the public key if it is not empty, otherwise return None
+        return rows[0]["public_key"] or None
+
     def get_node_id(self, node_public_key: bytes) -> Optional[int]:
         """Retrieve stored `node_id` filtered by `node_public_keys`."""
         query = "SELECT node_id FROM node WHERE public_key = :public_key;"
@@ -761,8 +783,6 @@ class SqliteLinkState(LinkState):  # pylint: disable=R0904
                 "federation_options, pending_at, starting_at, running_at, finished_at, "
                 "sub_status, details) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);"
             )
-            if fab_hash:
-                fab_id, fab_version = "", ""
             override_config_json = json.dumps(override_config)
             data = [
                 sint64_run_id,
@@ -820,6 +840,12 @@ class SqliteLinkState(LinkState):  # pylint: disable=R0904
             public_key = None
         return public_key
 
+    def clear_supernode_auth_keys_and_credentials(self) -> None:
+        """Clear stored `node_public_keys` and credentials in the link state if any."""
+        queries = ["DELETE FROM public_key;", "DELETE FROM credential;"]
+        for query in queries:
+            self.query(query)
+
     def store_node_public_keys(self, public_keys: set[bytes]) -> None:
         """Store a set of `node_public_keys` in the link state."""
         query = "INSERT INTO public_key (public_key) VALUES (?)"
@@ -978,17 +1004,16 @@ class SqliteLinkState(LinkState):  # pylint: disable=R0904
         """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, sint64_node_id)
-            )
-            return True
-        except sqlite3.IntegrityError:
-            log(ERROR, "`node_id` does not exist.")
+        # Check if the node exists in the `node` table
+        query = "SELECT 1 FROM node WHERE node_id = ?"
+        if not self.query(query, (sint64_node_id,)):
             return False
 
+        # Update `online_until` and `ping_interval` for the given `node_id`
+        query = "UPDATE node SET online_until = ?, ping_interval = ? WHERE node_id = ?"
+        self.query(query, (time.time() + ping_interval, ping_interval, sint64_node_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/server/superlink/simulation/simulationio_grpc.py

@@ -21,6 +21,7 @@ from typing import Optional
 import grpc
 
 from flwr.common import GRPC_MAX_MESSAGE_LENGTH
+from flwr.common.grpc import generic_create_grpc_server
 from flwr.common.logger import log
 from flwr.proto.simulationio_pb2_grpc import (  # pylint: disable=E0611
     add_SimulationIoServicer_to_server,
@@ -28,7 +29,6 @@ from flwr.proto.simulationio_pb2_grpc import (  # pylint: disable=E0611
 from flwr.server.superlink.ffs.ffs_factory import FfsFactory
 from flwr.server.superlink.linkstate import LinkStateFactory
 
-from ..fleet.grpc_bidi.grpc_server import generic_create_grpc_server
 from .simulationio_servicer import SimulationIoServicer
 
 

flwr/server/superlink/simulation/simulationio_servicer.py

@@ -54,6 +54,7 @@ from flwr.proto.simulationio_pb2 import (  # pylint: disable=E0611
 )
 from flwr.server.superlink.ffs.ffs_factory import FfsFactory
 from flwr.server.superlink.linkstate import LinkStateFactory
+from flwr.server.superlink.utils import abort_if
 
 
 class SimulationIoServicer(simulationio_pb2_grpc.SimulationIoServicer):
@@ -110,6 +111,15 @@ class SimulationIoServicer(simulationio_pb2_grpc.SimulationIoServicer):
         """Push Simulation process outputs."""
         log(DEBUG, "SimultionIoServicer.PushSimulationOutputs")
         state = self.state_factory.state()
+
+        # Abort if the run is not running
+        abort_if(
+            request.run_id,
+            [Status.PENDING, Status.STARTING, Status.FINISHED],
+            state,
+            context,
+        )
+
         state.set_serverapp_context(request.run_id, context_from_proto(request.context))
         return PushSimulationOutputsResponse()
 
@@ -120,6 +130,9 @@ class SimulationIoServicer(simulationio_pb2_grpc.SimulationIoServicer):
         log(DEBUG, "SimultionIoServicer.UpdateRunStatus")
         state = self.state_factory.state()
 
+        # Abort if the run is finished
+        abort_if(request.run_id, [Status.FINISHED], state, context)
+
         # Update the run status
         state.update_run_status(
             run_id=request.run_id, new_status=run_status_from_proto(request.run_status)

flwr/simulation/app.py

@@ -24,7 +24,8 @@ from typing import Optional
 
 from flwr.cli.config_utils import get_fab_metadata
 from flwr.cli.install import install_from_fab
-from flwr.common import EventType
+from flwr.cli.utils import get_sha256_hash
+from flwr.common import EventType, event
 from flwr.common.args import add_args_flwr_app_common
 from flwr.common.config import (
     get_flwr_dir,
@@ -48,6 +49,7 @@ from flwr.common.logger import (
 from flwr.common.serde import (
     configs_record_from_proto,
     context_from_proto,
+    context_to_proto,
     fab_from_proto,
     run_from_proto,
     run_status_to_proto,
@@ -201,8 +203,17 @@ def run_simulation_process(  # pylint: disable=R0914, disable=W0212, disable=R09
             verbose: bool = fed_opt.get("verbose", False)
             enable_tf_gpu_growth: bool = fed_opt.get("enable_tf_gpu_growth", False)
 
+            event(
+                EventType.FLWR_SIMULATION_RUN_ENTER,
+                event_details={
+                    "backend": "ray",
+                    "num-supernodes": num_supernodes,
+                    "run-id-hash": get_sha256_hash(run.run_id),
+                },
+            )
+
             # Launch the simulation
-            _run_simulation(
+            updated_context = _run_simulation(
                 server_app_attr=server_app_attr,
                 client_app_attr=client_app_attr,
                 num_supernodes=num_supernodes,
@@ -213,11 +224,11 @@ def run_simulation_process(  # pylint: disable=R0914, disable=W0212, disable=R09
                 verbose_logging=verbose,
                 server_app_run_config=fused_config,
                 is_app=True,
-                exit_event=EventType.CLI_FLOWER_SIMULATION_LEAVE,
+                exit_event=EventType.FLWR_SIMULATION_RUN_LEAVE,
             )
 
             # Send resulting context
-            context_proto = None  # context_to_proto(updated_context)
+            context_proto = context_to_proto(updated_context)
             out_req = PushSimulationOutputsRequest(
                 run_id=run.run_id, context=context_proto
             )

flwr/simulation/run_simulation.py

@@ -24,9 +24,11 @@ import threading
 import traceback
 from logging import DEBUG, ERROR, INFO, WARNING
 from pathlib import Path
+from queue import Empty, Queue
 from typing import Any, Optional
 
 from flwr.cli.config_utils import load_and_validate
+from flwr.cli.utils import get_sha256_hash
 from flwr.client import ClientApp
 from flwr.common import Context, EventType, RecordSet, event, log, now
 from flwr.common.config import get_fused_config_from_dir, parse_config_args
@@ -126,7 +128,7 @@ def run_simulation_from_cli() -> None:
     run = Run.create_empty(run_id)
     run.override_config = override_config
 
-    _run_simulation(
+    _ = _run_simulation(
         server_app_attr=server_app_attr,
         client_app_attr=client_app_attr,
         num_supernodes=args.num_supernodes,
@@ -206,7 +208,7 @@ def run_simulation(
             "\n\tflwr.simulation.run_simulationt(...)",
         )
 
-    _run_simulation(
+    _ = _run_simulation(
         num_supernodes=num_supernodes,
         client_app=client_app,
         server_app=server_app,
@@ -229,6 +231,7 @@ def run_serverapp_th(
     has_exception: threading.Event,
     enable_tf_gpu_growth: bool,
     run_id: int,
+    ctx_queue: "Queue[Context]",
 ) -> threading.Thread:
     """Run SeverApp in a thread."""
 
@@ -241,6 +244,7 @@ def run_serverapp_th(
         _server_app_run_config: UserConfig,
         _server_app_attr: Optional[str],
         _server_app: Optional[ServerApp],
+        _ctx_queue: "Queue[Context]",
     ) -> None:
         """Run SeverApp, after check if GPU memory growth has to be set.
 
@@ -261,13 +265,14 @@ def run_serverapp_th(
             )
 
             # Run ServerApp
-            _run(
+            updated_context = _run(
                 driver=_driver,
                 context=context,
                 server_app_dir=_server_app_dir,
                 server_app_attr=_server_app_attr,
                 loaded_server_app=_server_app,
             )
+            _ctx_queue.put(updated_context)
         except Exception as ex:  # pylint: disable=broad-exception-caught
             log(ERROR, "ServerApp thread raised an exception: %s", ex)
             log(ERROR, traceback.format_exc())
@@ -291,6 +296,7 @@ def run_serverapp_th(
             server_app_run_config,
             server_app_attr,
             server_app,
+            ctx_queue,
         ),
     )
     serverapp_th.start()
@@ -313,7 +319,7 @@ def _main_loop(
     server_app: Optional[ServerApp] = None,
     server_app_attr: Optional[str] = None,
     server_app_run_config: Optional[UserConfig] = None,
-) -> None:
+) -> Context:
     """Start ServerApp on a separate thread, then launch Simulation Engine."""
     # Initialize StateFactory
     state_factory = LinkStateFactory(":flwr-in-memory-state:")
@@ -323,6 +329,13 @@ def _main_loop(
     server_app_thread_has_exception = threading.Event()
     serverapp_th = None
     success = True
+    updated_context = Context(
+        run_id=run.run_id,
+        node_id=0,
+        node_config=UserConfig(),
+        state=RecordSet(),
+        run_config=UserConfig(),
+    )
     try:
         # Register run
         log(DEBUG, "Pre-registering run with id %s", run.run_id)
@@ -337,6 +350,7 @@ def _main_loop(
         # Initialize Driver
         driver = InMemoryDriver(state_factory=state_factory)
         driver.set_run(run_id=run.run_id)
+        output_context_queue: Queue[Context] = Queue()
 
         # Get and run ServerApp thread
         serverapp_th = run_serverapp_th(
@@ -349,6 +363,7 @@ def _main_loop(
             has_exception=server_app_thread_has_exception,
             enable_tf_gpu_growth=enable_tf_gpu_growth,
             run_id=run.run_id,
+            ctx_queue=output_context_queue,
         )
 
         # Start Simulation Engine
@@ -366,6 +381,11 @@ def _main_loop(
             flwr_dir=flwr_dir,
         )
 
+        updated_context = output_context_queue.get(timeout=3)
+
+    except Empty:
+        log(DEBUG, "Queue timeout. No context received.")
+
     except Exception as ex:
         log(ERROR, "An exception occurred !! %s", ex)
         log(ERROR, traceback.format_exc())
@@ -375,13 +395,20 @@ def _main_loop(
     finally:
         # Trigger stop event
         f_stop.set()
-        event(exit_event, event_details={"success": success})
+        event(
+            exit_event,
+            event_details={
+                "run-id-hash": get_sha256_hash(run.run_id),
+                "success": success,
+            },
+        )
         if serverapp_th:
             serverapp_th.join()
             if server_app_thread_has_exception.is_set():
                 raise RuntimeError("Exception in ServerApp thread")
 
     log(DEBUG, "Stopping Simulation Engine now.")
+    return updated_context
 
 
 # pylint: disable=too-many-arguments,too-many-locals,too-many-positional-arguments
@@ -401,7 +428,7 @@ def _run_simulation(
     enable_tf_gpu_growth: bool = False,
     verbose_logging: bool = False,
     is_app: bool = False,
-) -> None:
+) -> Context:
     """Launch the Simulation Engine."""
     if backend_config is None:
         backend_config = {}
@@ -480,7 +507,8 @@ def _run_simulation(
             # Set logger propagation to False to prevent duplicated log output in Colab.
             logger = set_logger_propagation(logger, False)
 
-        _main_loop(*args)
+        updated_context = _main_loop(*args)
+    return updated_context
 
 
 def _parse_args_run_simulation() -> argparse.ArgumentParser:

flwr/superexec/exec_grpc.py

@@ -23,11 +23,11 @@ import grpc
 
 from flwr.common import GRPC_MAX_MESSAGE_LENGTH
 from flwr.common.auth_plugin import ExecAuthPlugin
+from flwr.common.grpc import generic_create_grpc_server
 from flwr.common.logger import log
 from flwr.common.typing import UserConfig
 from flwr.proto.exec_pb2_grpc import add_ExecServicer_to_server
 from flwr.server.superlink.ffs.ffs_factory import FfsFactory
-from flwr.server.superlink.fleet.grpc_bidi.grpc_server import generic_create_grpc_server
 from flwr.server.superlink.linkstate import LinkStateFactory
 from flwr.superexec.exec_user_auth_interceptor import ExecUserAuthInterceptor
 

flwr/superexec/exec_servicer.py

@@ -181,8 +181,20 @@ class ExecServicer(exec_pb2_grpc.ExecServicer):
                 "ExecServicer initialized without user authentication",
             )
             raise grpc.RpcError()  # This line is unreachable
+
+        # Get login details
+        details = self.auth_plugin.get_login_details()
+
+        # Return empty response if details is None
+        if details is None:
+            return GetLoginDetailsResponse()
+
         return GetLoginDetailsResponse(
-            login_details=self.auth_plugin.get_login_details()
+            auth_type=details.auth_type,
+            device_code=details.device_code,
+            verification_uri_complete=details.verification_uri_complete,
+            expires_in=details.expires_in,
+            interval=details.interval,
         )
 
     def GetAuthTokens(
@@ -196,8 +208,17 @@ class ExecServicer(exec_pb2_grpc.ExecServicer):
                 "ExecServicer initialized without user authentication",
             )
             raise grpc.RpcError()  # This line is unreachable
+
+        # Get auth tokens
+        credentials = self.auth_plugin.get_auth_tokens(request.device_code)
+
+        # Return empty response if credentials is None
+        if credentials is None:
+            return GetAuthTokensResponse()
+
         return GetAuthTokensResponse(
-            auth_tokens=self.auth_plugin.get_auth_tokens(dict(request.auth_details))
+            access_token=credentials.access_token,
+            refresh_token=credentials.refresh_token,
         )
 
 

{flwr_nightly-1.14.0.dev20241216.dist-info → flwr_nightly-1.15.0.dev20250112.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: flwr-nightly
-Version: 1.14.0.dev20241216
+Version: 1.15.0.dev20250112
 Summary: Flower: A Friendly Federated AI Framework
 Home-page: https://flower.ai
 License: Apache-2.0
@@ -43,11 +43,11 @@ Requires-Dist: pyyaml (>=6.0.2,<7.0.0)
 Requires-Dist: ray (==2.10.0) ; (python_version >= "3.9" and python_version < "3.12") and (extra == "simulation")
 Requires-Dist: requests (>=2.31.0,<3.0.0)
 Requires-Dist: rich (>=13.5.0,<14.0.0)
-Requires-Dist: starlette (>=0.31.0,<0.32.0) ; extra == "rest"
+Requires-Dist: starlette (>=0.45.2,<0.46.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 (>=0.12.5,<0.13.0)
-Requires-Dist: uvicorn[standard] (>=0.23.0,<0.24.0) ; extra == "rest"
+Requires-Dist: uvicorn[standard] (>=0.34.0,<0.35.0) ; extra == "rest"
 Project-URL: Documentation, https://flower.ai
 Project-URL: Repository, https://github.com/adap/flower
 Description-Content-Type: text/markdown
@@ -88,7 +88,7 @@ design of Flower is based on a few guiding principles:
 
 - **Framework-agnostic**: Different machine learning frameworks have different
   strengths. Flower can be used with any machine learning framework, for
-  example, [PyTorch](https://pytorch.org), [TensorFlow](https://tensorflow.org), [Hugging Face Transformers](https://huggingface.co/), [PyTorch Lightning](https://pytorchlightning.ai/), [scikit-learn](https://scikit-learn.org/), [JAX](https://jax.readthedocs.io/), [TFLite](https://tensorflow.org/lite/), [MONAI](https://docs.monai.io/en/latest/index.html), [fastai](https://www.fast.ai/), [MLX](https://ml-explore.github.io/mlx/build/html/index.html), [XGBoost](https://xgboost.readthedocs.io/en/stable/), [Pandas](https://pandas.pydata.org/) for federated analytics, or even raw [NumPy](https://numpy.org/)
+  example, [PyTorch](https://pytorch.org), [TensorFlow](https://tensorflow.org), [Hugging Face Transformers](https://huggingface.co/), [PyTorch Lightning](https://pytorchlightning.ai/), [scikit-learn](https://scikit-learn.org/), [JAX](https://jax.readthedocs.io/), [TFLite](https://tensorflow.org/lite/), [MONAI](https://docs.monai.io/en/latest/index.html), [fastai](https://www.fast.ai/), [MLX](https://ml-explore.github.io/mlx/build/html/index.html), [XGBoost](https://xgboost.readthedocs.io/en/stable/), [LeRobot](https://github.com/huggingface/lerobot) for federated robots, [Pandas](https://pandas.pydata.org/) for federated analytics, or even raw [NumPy](https://numpy.org/)
   for users who enjoy computing gradients by hand.
 
 - **Understandable**: Flower is written with maintainability in mind. The
@@ -118,7 +118,7 @@ Flower's goal is to make federated learning accessible to everyone. This series
 
 4. **Custom Clients for Federated Learning**
 
-   [![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/adap/flower/blob/main/doc/source/tutorial-series-customize-the-client-pytorch.ipynb) (or open the [Jupyter Notebook](https://github.com/adap/flower/blob/main/framework/docs/source/tutorial-series-customize-the-client-pytorch.ipynb))
+   [![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/adap/flower/blob/main/framework/docs/source/tutorial-series-customize-the-client-pytorch.ipynb) (or open the [Jupyter Notebook](https://github.com/adap/flower/blob/main/framework/docs/source/tutorial-series-customize-the-client-pytorch.ipynb))
 
 Stay tuned, more tutorials are coming soon. Topics include **Privacy and Security in Federated Learning**, and **Scaling Federated Learning**.