flwr-nightly 1.21.0.dev20250818__py3-none-any.whl → 1.21.0.dev20250820__py3-none-any.whl

flwr/simulation/app.py

@@ -16,7 +16,6 @@
 
 
 import argparse
-import gc
 from logging import DEBUG, ERROR, INFO
 from queue import Queue
 from typing import Optional
@@ -71,7 +70,7 @@ from flwr.proto.simulationio_pb2_grpc import SimulationIoStub
 from flwr.server.superlink.fleet.vce.backend.backend import BackendConfig
 from flwr.simulation.run_simulation import _run_simulation
 from flwr.simulation.simulationio_connection import SimulationIoConnection
-from flwr.supercore.app_utils import simple_get_token, start_parent_process_monitor
+from flwr.supercore.app_utils import start_parent_process_monitor
 from flwr.supercore.superexec.plugin import SimulationExecPlugin
 from flwr.supercore.superexec.run_superexec import run_with_deprecation_warning
 
@@ -114,7 +113,6 @@ def flwr_simulation() -> None:
     run_simulation_process(
         simulationio_api_address=args.simulationio_api_address,
         log_queue=log_queue,
-        run_once=(args.token is not None) or args.run_once,
         token=args.token,
         flwr_dir_=args.flwr_dir,
         certificates=None,
@@ -128,8 +126,7 @@ def flwr_simulation() -> None:
 def run_simulation_process(  # pylint: disable=R0913, R0914, R0915, R0917, W0212
     simulationio_api_address: str,
     log_queue: Queue[Optional[str]],
-    run_once: bool,
-    token: Optional[str] = None,
+    token: str,
     flwr_dir_: Optional[str] = None,
     certificates: Optional[bytes] = None,
     parent_pid: Optional[int] = None,
@@ -150,168 +147,144 @@ def run_simulation_process(  # pylint: disable=R0913, R0914, R0915, R0917, W0212
     heartbeat_sender = None
     run_status = None
 
-    while True:
+    try:
+        # Pull SimulationInputs from LinkState
+        req = PullAppInputsRequest(token=token)
+        res: PullAppInputsResponse = conn._stub.PullAppInputs(req)
+        context = context_from_proto(res.context)
+        run = run_from_proto(res.run)
+        fab = fab_from_proto(res.fab)
+
+        # Start log uploader for this run
+        log_uploader = start_log_uploader(
+            log_queue=log_queue,
+            node_id=context.node_id,
+            run_id=run.run_id,
+            stub=conn._stub,
+        )
 
-        try:
-            # If token is not set, loop until token is received from SuperNode
-            if token is None:
-                log(DEBUG, "[flwr-simulation] Request token")
-                token = simple_get_token(conn._stub)
-
-            # Pull SimulationInputs from LinkState
-            req = PullAppInputsRequest(token=token)
-            res: PullAppInputsResponse = conn._stub.PullAppInputs(req)
-            context = context_from_proto(res.context)
-            run = run_from_proto(res.run)
-            fab = fab_from_proto(res.fab)
-
-            # Start log uploader for this run
-            log_uploader = start_log_uploader(
-                log_queue=log_queue,
-                node_id=context.node_id,
-                run_id=run.run_id,
-                stub=conn._stub,
-            )
+        log(DEBUG, "Simulation process starts FAB installation.")
+        install_from_fab(fab.content, flwr_dir=flwr_dir, skip_prompt=True)
 
-            log(DEBUG, "Simulation process starts FAB installation.")
-            install_from_fab(fab.content, flwr_dir=flwr_dir, skip_prompt=True)
+        fab_id, fab_version = get_fab_metadata(fab.content)
 
-            fab_id, fab_version = get_fab_metadata(fab.content)
+        app_path = get_project_dir(fab_id, fab_version, fab.hash_str, flwr_dir)
+        config = get_project_config(app_path)
 
-            app_path = get_project_dir(fab_id, fab_version, fab.hash_str, flwr_dir)
-            config = get_project_config(app_path)
+        # Get ClientApp and SeverApp components
+        app_components = config["tool"]["flwr"]["app"]["components"]
+        client_app_attr = app_components["clientapp"]
+        server_app_attr = app_components["serverapp"]
+        fused_config = get_fused_config_from_dir(app_path, run.override_config)
 
-            # Get ClientApp and SeverApp components
-            app_components = config["tool"]["flwr"]["app"]["components"]
-            client_app_attr = app_components["clientapp"]
-            server_app_attr = app_components["serverapp"]
-            fused_config = get_fused_config_from_dir(app_path, run.override_config)
+        # Update run_config in context
+        context.run_config = fused_config
 
-            # Update run_config in context
-            context.run_config = fused_config
+        log(
+            DEBUG,
+            "Flower will load ServerApp `%s` in %s",
+            server_app_attr,
+            app_path,
+        )
+        log(
+            DEBUG,
+            "Flower will load ClientApp `%s` in %s",
+            client_app_attr,
+            app_path,
+        )
 
-            log(
-                DEBUG,
-                "Flower will load ServerApp `%s` in %s",
-                server_app_attr,
-                app_path,
-            )
-            log(
-                DEBUG,
-                "Flower will load ClientApp `%s` in %s",
-                client_app_attr,
-                app_path,
-            )
+        # Change status to Running
+        run_status_proto = run_status_to_proto(RunStatus(Status.RUNNING, "", ""))
+        conn._stub.UpdateRunStatus(
+            UpdateRunStatusRequest(run_id=run.run_id, run_status=run_status_proto)
+        )
 
-            # Change status to Running
-            run_status_proto = run_status_to_proto(RunStatus(Status.RUNNING, "", ""))
-            conn._stub.UpdateRunStatus(
-                UpdateRunStatusRequest(run_id=run.run_id, run_status=run_status_proto)
-            )
+        # Pull Federation Options
+        fed_opt_res: GetFederationOptionsResponse = conn._stub.GetFederationOptions(
+            GetFederationOptionsRequest(run_id=run.run_id)
+        )
+        federation_options = config_record_from_proto(fed_opt_res.federation_options)
+
+        # Unflatten underlying dict
+        fed_opt = unflatten_dict({**federation_options})
+
+        # Extract configs values of interest
+        num_supernodes = fed_opt.get("num-supernodes")
+        if num_supernodes is None:
+            raise ValueError("Federation options expects `num-supernodes` to be set.")
+        backend_config: BackendConfig = fed_opt.get("backend", {})
+        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),
+            },
+        )
 
-            # Pull Federation Options
-            fed_opt_res: GetFederationOptionsResponse = conn._stub.GetFederationOptions(
-                GetFederationOptionsRequest(run_id=run.run_id)
-            )
-            federation_options = config_record_from_proto(
-                fed_opt_res.federation_options
-            )
+        # Set up heartbeat sender
+        heartbeat_fn = get_grpc_app_heartbeat_fn(
+            conn._stub,
+            run.run_id,
+            failure_message="Heartbeat failed unexpectedly. The SuperLink could "
+            "not find the provided run ID, or the run status is invalid.",
+        )
+        heartbeat_sender = HeartbeatSender(heartbeat_fn)
+        heartbeat_sender.start()
+
+        # Launch the simulation
+        updated_context = _run_simulation(
+            server_app_attr=server_app_attr,
+            client_app_attr=client_app_attr,
+            num_supernodes=num_supernodes,
+            backend_config=backend_config,
+            app_dir=str(app_path),
+            run=run,
+            enable_tf_gpu_growth=enable_tf_gpu_growth,
+            verbose_logging=verbose,
+            server_app_run_config=fused_config,
+            is_app=True,
+            exit_event=EventType.FLWR_SIMULATION_RUN_LEAVE,
+        )
 
-            # Unflatten underlying dict
-            fed_opt = unflatten_dict({**federation_options})
-
-            # Extract configs values of interest
-            num_supernodes = fed_opt.get("num-supernodes")
-            if num_supernodes is None:
-                raise ValueError(
-                    "Federation options expects `num-supernodes` to be set."
-                )
-            backend_config: BackendConfig = fed_opt.get("backend", {})
-            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),
-                },
-            )
+        # Send resulting context
+        context_proto = context_to_proto(updated_context)
+        out_req = PushAppOutputsRequest(
+            token=token, run_id=run.run_id, context=context_proto
+        )
+        _ = conn._stub.PushAppOutputs(out_req)
 
-            # Set up heartbeat sender
-            heartbeat_fn = get_grpc_app_heartbeat_fn(
-                conn._stub,
-                run.run_id,
-                failure_message="Heartbeat failed unexpectedly. The SuperLink could "
-                "not find the provided run ID, or the run status is invalid.",
-            )
-            heartbeat_sender = HeartbeatSender(heartbeat_fn)
-            heartbeat_sender.start()
-
-            # Launch the simulation
-            updated_context = _run_simulation(
-                server_app_attr=server_app_attr,
-                client_app_attr=client_app_attr,
-                num_supernodes=num_supernodes,
-                backend_config=backend_config,
-                app_dir=str(app_path),
-                run=run,
-                enable_tf_gpu_growth=enable_tf_gpu_growth,
-                verbose_logging=verbose,
-                server_app_run_config=fused_config,
-                is_app=True,
-                exit_event=EventType.FLWR_SIMULATION_RUN_LEAVE,
-            )
+        run_status = RunStatus(Status.FINISHED, SubStatus.COMPLETED, "")
 
-            # Send resulting context
-            context_proto = context_to_proto(updated_context)
-            out_req = PushAppOutputsRequest(
-                token=token, run_id=run.run_id, context=context_proto
+    except Exception as ex:  # pylint: disable=broad-exception-caught
+        exc_entity = "Simulation"
+        log(ERROR, "%s raised an exception", exc_entity, exc_info=ex)
+        run_status = RunStatus(Status.FINISHED, SubStatus.FAILED, str(ex))
+
+    finally:
+        # Stop heartbeat sender
+        if heartbeat_sender:
+            heartbeat_sender.stop()
+
+        # Stop log uploader for this run and upload final logs
+        if log_uploader:
+            stop_log_uploader(log_queue, log_uploader)
+
+        # Update run status
+        if run_status:
+            run_status_proto = run_status_to_proto(run_status)
+            conn._stub.UpdateRunStatus(
+                UpdateRunStatusRequest(run_id=run.run_id, run_status=run_status_proto)
             )
-            _ = conn._stub.PushAppOutputs(out_req)
-
-            run_status = RunStatus(Status.FINISHED, SubStatus.COMPLETED, "")
-
-        except Exception as ex:  # pylint: disable=broad-exception-caught
-            exc_entity = "Simulation"
-            log(ERROR, "%s raised an exception", exc_entity, exc_info=ex)
-            run_status = RunStatus(Status.FINISHED, SubStatus.FAILED, str(ex))
-
-        finally:
-            # Stop heartbeat sender
-            if heartbeat_sender:
-                heartbeat_sender.stop()
-                heartbeat_sender = None
-
-            # Stop log uploader for this run and upload final logs
-            if log_uploader:
-                stop_log_uploader(log_queue, log_uploader)
-                log_uploader = None
-
-            # Update run status
-            if run_status:
-                run_status_proto = run_status_to_proto(run_status)
-                conn._stub.UpdateRunStatus(
-                    UpdateRunStatusRequest(
-                        run_id=run.run_id, run_status=run_status_proto
-                    )
-                )
-                run_status = None
-
-            # Clean up the Context if it exists
-            try:
-                del updated_context
-            except NameError:
-                pass
-
-            # Remove the token
-            token = None
-            gc.collect()
-
-        # Stop the loop if `flwr-simulation` is expected to process a single run
-        if run_once:
-            break
+
+        # Clean up the Context if it exists
+        try:
+            del updated_context
+        except NameError:
+            pass
 
 
 def _parse_args_run_flwr_simulation() -> argparse.ArgumentParser:

flwr/supercore/app_utils.py

@@ -19,17 +19,6 @@ import os
 import signal
 import threading
 import time
-from typing import Union
-
-from flwr.proto.appio_pb2 import (  # pylint: disable=E0611
-    ListAppsToLaunchRequest,
-    ListAppsToLaunchResponse,
-    RequestTokenRequest,
-    RequestTokenResponse,
-)
-from flwr.proto.clientappio_pb2_grpc import ClientAppIoStub
-from flwr.proto.serverappio_pb2_grpc import ServerAppIoStub
-from flwr.proto.simulationio_pb2_grpc import SimulationIoStub
 
 if os.name == "nt":
     from ctypes import windll  # type: ignore
@@ -67,23 +56,3 @@ def start_parent_process_monitor(
                 os.kill(os.getpid(), signal.SIGKILL)
 
     threading.Thread(target=monitor, daemon=True).start()
-
-
-def simple_get_token(
-    stub: Union[ClientAppIoStub, ServerAppIoStub, SimulationIoStub]
-) -> str:
-    """Get a token from SuperLink/SuperNode.
-
-    This shall be removed once the SuperExec is fully implemented.
-    """
-    while True:
-        res: ListAppsToLaunchResponse = stub.ListAppsToLaunch(ListAppsToLaunchRequest())
-
-        for run_id in res.run_ids:
-            tk_res: RequestTokenResponse = stub.RequestToken(
-                RequestTokenRequest(run_id=run_id)
-            )
-            if tk_res.token:
-                return tk_res.token
-
-        time.sleep(1)  # Wait before retrying to get run IDs

flwr/supercore/cli/flower_superexec.py

@@ -20,6 +20,7 @@ from logging import INFO
 
 from flwr.common import EventType, event
 from flwr.common.constant import ExecPluginType
+from flwr.common.exit import ExitCode, flwr_exit
 from flwr.common.logger import log
 from flwr.proto.clientappio_pb2_grpc import ClientAppIoStub
 from flwr.proto.serverappio_pb2_grpc import ServerAppIoStub
@@ -36,6 +37,11 @@ from flwr.supercore.superexec.run_superexec import run_superexec
 def flower_superexec() -> None:
     """Run `flower-superexec` command."""
     args = _parse_args().parse_args()
+    if not args.insecure:
+        flwr_exit(
+            ExitCode.COMMON_TLS_NOT_SUPPORTED,
+            "SuperExec does not support TLS yet.",
+        )
 
     # Log the first message after parsing arguments in case of `--help`
     log(INFO, "Starting Flower SuperExec")

flwr/superlink/servicer/control/control_grpc.py

@@ -26,14 +26,12 @@ from flwr.common.event_log_plugin import EventLogWriterPlugin
 from flwr.common.exit import ExitCode, flwr_exit
 from flwr.common.grpc import generic_create_grpc_server
 from flwr.common.logger import log
-from flwr.common.typing import UserConfig
 from flwr.proto.control_pb2_grpc import add_ControlServicer_to_server
 from flwr.server.superlink.linkstate import LinkStateFactory
 from flwr.supercore.ffs import FfsFactory
 from flwr.supercore.license_plugin import LicensePlugin
 from flwr.supercore.object_store import ObjectStoreFactory
 
-from ...executor import Executor
 from .control_event_log_interceptor import ControlEventLogInterceptor
 from .control_license_interceptor import ControlLicenseInterceptor
 from .control_servicer import ControlServicer
@@ -50,19 +48,16 @@ except ImportError:
 # pylint: disable-next=too-many-arguments,too-many-positional-arguments,too-many-locals
 def run_control_api_grpc(
     address: str,
-    executor: Executor,
     state_factory: LinkStateFactory,
     ffs_factory: FfsFactory,
     objectstore_factory: ObjectStoreFactory,
     certificates: Optional[tuple[bytes, bytes, bytes]],
-    config: UserConfig,
+    is_simulation: bool,
     auth_plugin: Optional[ControlAuthPlugin] = None,
     authz_plugin: Optional[ControlAuthzPlugin] = None,
     event_log_plugin: Optional[EventLogWriterPlugin] = None,
 ) -> grpc.Server:
     """Run Control API (gRPC, request-response)."""
-    executor.set_config(config)
-
     license_plugin: Optional[LicensePlugin] = get_license_plugin()
     if license_plugin and not license_plugin.check_license():
         flwr_exit(ExitCode.SUPERLINK_LICENSE_INVALID)
@@ -71,7 +66,7 @@ def run_control_api_grpc(
         linkstate_factory=state_factory,
         ffs_factory=ffs_factory,
         objectstore_factory=objectstore_factory,
-        executor=executor,
+        is_simulation=is_simulation,
         auth_plugin=auth_plugin,
     )
     interceptors: list[grpc.ServerInterceptor] = []
@@ -93,11 +88,11 @@ def run_control_api_grpc(
     )
 
     if auth_plugin is None:
-        log(INFO, "Flower Deployment Engine: Starting Control API on %s", address)
+        log(INFO, "Flower Deployment Runtime: Starting Control API on %s", address)
     else:
         log(
             INFO,
-            "Flower Deployment Engine: Starting Control API with user "
+            "Flower Deployment Runtime: Starting Control API with user "
             "authentication on %s",
             address,
         )

flwr/superlink/servicer/control/control_servicer.py

@@ -15,6 +15,7 @@
 """Control API servicer."""
 
 
+import hashlib
 import time
 from collections.abc import Generator
 from logging import ERROR, INFO
@@ -22,7 +23,8 @@ from typing import Any, Optional, cast
 
 import grpc
 
-from flwr.common import now
+from flwr.cli.config_utils import get_fab_metadata
+from flwr.common import Context, RecordDict, now
 from flwr.common.auth_plugin import ControlAuthPlugin
 from flwr.common.constant import (
     FAB_MAX_SIZE,
@@ -37,7 +39,7 @@ from flwr.common.serde import (
     run_to_proto,
     user_config_from_proto,
 )
-from flwr.common.typing import Run, RunStatus
+from flwr.common.typing import Fab, Run, RunStatus
 from flwr.proto import control_pb2_grpc  # pylint: disable=E0611
 from flwr.proto.control_pb2 import (  # pylint: disable=E0611
     GetAuthTokensRequest,
@@ -57,7 +59,6 @@ from flwr.server.superlink.linkstate import LinkState, LinkStateFactory
 from flwr.supercore.ffs import FfsFactory
 from flwr.supercore.object_store import ObjectStore, ObjectStoreFactory
 
-from ...executor.executor import Executor
 from .control_user_auth_interceptor import shared_account_info
 
 
@@ -69,14 +70,13 @@ class ControlServicer(control_pb2_grpc.ControlServicer):
         linkstate_factory: LinkStateFactory,
         ffs_factory: FfsFactory,
         objectstore_factory: ObjectStoreFactory,
-        executor: Executor,
+        is_simulation: bool,
         auth_plugin: Optional[ControlAuthPlugin] = None,
     ) -> None:
         self.linkstate_factory = linkstate_factory
         self.ffs_factory = ffs_factory
         self.objectstore_factory = objectstore_factory
-        self.executor = executor
-        self.executor.initialize(linkstate_factory, ffs_factory)
+        self.is_simulation = is_simulation
         self.auth_plugin = auth_plugin
 
     def StartRun(
@@ -84,6 +84,8 @@ class ControlServicer(control_pb2_grpc.ControlServicer):
     ) -> StartRunResponse:
         """Create run ID."""
         log(INFO, "ControlServicer.StartRun")
+        state = self.linkstate_factory.state()
+        ffs = self.ffs_factory.ffs()
 
         if len(request.fab.content) > FAB_MAX_SIZE:
             log(
@@ -94,17 +96,53 @@ class ControlServicer(control_pb2_grpc.ControlServicer):
             return StartRunResponse()
 
         flwr_aid = shared_account_info.get().flwr_aid if self.auth_plugin else None
-        run_id = self.executor.start_run(
-            request.fab.content,
-            user_config_from_proto(request.override_config),
-            config_record_from_proto(request.federation_options),
-            flwr_aid,
-        )
+        override_config = user_config_from_proto(request.override_config)
+        federation_options = config_record_from_proto(request.federation_options)
+        fab_file = request.fab.content
+
+        try:
+            # Check that num-supernodes is set
+            if self.is_simulation and "num-supernodes" not in federation_options:
+                raise ValueError(
+                    "Federation options doesn't contain key `num-supernodes`."
+                )
+
+            # Create run
+            fab = Fab(hashlib.sha256(fab_file).hexdigest(), fab_file)
+            fab_hash = ffs.put(fab.content, {})
+            if fab_hash != fab.hash_str:
+                raise RuntimeError(
+                    f"FAB ({fab.hash_str}) hash from request doesn't match contents"
+                )
+            fab_id, fab_version = get_fab_metadata(fab.content)
+
+            run_id = state.create_run(
+                fab_id,
+                fab_version,
+                fab_hash,
+                override_config,
+                federation_options,
+                flwr_aid,
+            )
+
+            # Create an empty context for the Run
+            context = Context(
+                run_id=run_id,
+                node_id=0,
+                node_config={},
+                state=RecordDict(),
+                run_config={},
+            )
+
+            # Register the context at the LinkState
+            state.set_serverapp_context(run_id=run_id, context=context)
 
-        if run_id is None:
-            log(ERROR, "Executor failed to start run")
+        # pylint: disable-next=broad-except
+        except Exception as e:
+            log(ERROR, "Could not start run: %s", str(e))
             return StartRunResponse()
 
+        log(INFO, "Created run %s", str(run_id))
         return StartRunResponse(run_id=run_id)
 
     def StreamLogs(  # pylint: disable=C0103

flwr/supernode/start_client_internal.py

@@ -532,6 +532,6 @@ def run_clientappio_api_grpc(
         max_message_length=GRPC_MAX_MESSAGE_LENGTH,
         certificates=certificates,
     )
-    log(INFO, "Starting Flower ClientAppIo gRPC server on %s", address)
+    log(INFO, "Flower Deployment Runtime: Starting ClientAppIo API on %s", address)
     clientappio_grpc_server.start()
     return clientappio_grpc_server

{flwr_nightly-1.21.0.dev20250818.dist-info → flwr_nightly-1.21.0.dev20250820.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: flwr-nightly
-Version: 1.21.0.dev20250818
+Version: 1.21.0.dev20250820
 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