flwr-nightly 1.11.0.dev20240823__py3-none-any.whl → 1.11.1.dev20240912__py3-none-any.whl

flwr/server/superlink/state/in_memory_state.py

@@ -45,7 +45,7 @@ class InMemoryState(State):  # pylint: disable=R0902,R0904
         self.task_ins_store: Dict[UUID, TaskIns] = {}
         self.task_res_store: Dict[UUID, TaskRes] = {}
 
-        self.client_public_keys: Set[bytes] = set()
+        self.node_public_keys: Set[bytes] = set()
         self.server_public_key: Optional[bytes] = None
         self.server_private_key: Optional[bytes] = None
 
@@ -237,7 +237,7 @@ class InMemoryState(State):  # pylint: disable=R0902,R0904
             return node_id
 
     def delete_node(self, node_id: int, public_key: Optional[bytes] = None) -> None:
-        """Delete a client node."""
+        """Delete a node."""
         with self.lock:
             if node_id not in self.node_ids:
                 raise ValueError(f"Node {node_id} not found")
@@ -254,7 +254,7 @@ class InMemoryState(State):  # pylint: disable=R0902,R0904
             del self.node_ids[node_id]
 
     def get_nodes(self, run_id: int) -> Set[int]:
-        """Return all available client nodes.
+        """Return all available nodes.
 
         Constraints
         -----------
@@ -271,9 +271,9 @@ class InMemoryState(State):  # pylint: disable=R0902,R0904
                 if online_until > current_time
             }
 
-    def get_node_id(self, client_public_key: bytes) -> Optional[int]:
-        """Retrieve stored `node_id` filtered by `client_public_keys`."""
-        return self.public_key_to_node_id.get(client_public_key)
+    def get_node_id(self, node_public_key: bytes) -> Optional[int]:
+        """Retrieve stored `node_id` filtered by `node_public_keys`."""
+        return self.public_key_to_node_id.get(node_public_key)
 
     def create_run(
         self,
@@ -318,19 +318,19 @@ class InMemoryState(State):  # pylint: disable=R0902,R0904
         """Retrieve `server_public_key` in urlsafe bytes."""
         return self.server_public_key
 
-    def store_client_public_keys(self, public_keys: Set[bytes]) -> None:
-        """Store a set of `client_public_keys` in state."""
+    def store_node_public_keys(self, public_keys: Set[bytes]) -> None:
+        """Store a set of `node_public_keys` in state."""
         with self.lock:
-            self.client_public_keys = public_keys
+            self.node_public_keys = public_keys
 
-    def store_client_public_key(self, public_key: bytes) -> None:
-        """Store a `client_public_key` in state."""
+    def store_node_public_key(self, public_key: bytes) -> None:
+        """Store a `node_public_key` in state."""
         with self.lock:
-            self.client_public_keys.add(public_key)
+            self.node_public_keys.add(public_key)
 
-    def get_client_public_keys(self) -> Set[bytes]:
-        """Retrieve all currently stored `client_public_keys` as a set."""
-        return self.client_public_keys
+    def get_node_public_keys(self) -> Set[bytes]:
+        """Retrieve all currently stored `node_public_keys` as a set."""
+        return self.node_public_keys
 
     def get_run(self, run_id: int) -> Optional[Run]:
         """Retrieve information about the run with the specified `run_id`."""

flwr/server/superlink/state/sqlite_state.py

@@ -569,7 +569,7 @@ class SqliteState(State):  # pylint: disable=R0904
         return node_id
 
     def delete_node(self, node_id: int, public_key: Optional[bytes] = None) -> None:
-        """Delete a client node."""
+        """Delete a node."""
         query = "DELETE FROM node WHERE node_id = ?"
         params = (node_id,)
 
@@ -607,10 +607,10 @@ class SqliteState(State):  # pylint: disable=R0904
         result: Set[int] = {row["node_id"] for row in rows}
         return result
 
-    def get_node_id(self, client_public_key: bytes) -> Optional[int]:
-        """Retrieve stored `node_id` filtered by `client_public_keys`."""
+    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;"
-        row = self.query(query, {"public_key": client_public_key})
+        row = self.query(query, {"public_key": node_public_key})
         if len(row) > 0:
             node_id: int = row[0]["node_id"]
             return node_id
@@ -684,19 +684,19 @@ class SqliteState(State):  # pylint: disable=R0904
             public_key = None
         return public_key
 
-    def store_client_public_keys(self, public_keys: Set[bytes]) -> None:
-        """Store a set of `client_public_keys` in state."""
+    def store_node_public_keys(self, public_keys: Set[bytes]) -> None:
+        """Store a set of `node_public_keys` in state."""
         query = "INSERT INTO public_key (public_key) VALUES (?)"
         data = [(key,) for key in public_keys]
         self.query(query, data)
 
-    def store_client_public_key(self, public_key: bytes) -> None:
-        """Store a `client_public_key` in state."""
+    def store_node_public_key(self, public_key: bytes) -> None:
+        """Store a `node_public_key` in state."""
         query = "INSERT INTO public_key (public_key) VALUES (:public_key)"
         self.query(query, {"public_key": public_key})
 
-    def get_client_public_keys(self) -> Set[bytes]:
-        """Retrieve all currently stored `client_public_keys` as a set."""
+    def get_node_public_keys(self) -> Set[bytes]:
+        """Retrieve all currently stored `node_public_keys` as a set."""
         query = "SELECT public_key FROM public_key"
         rows = self.query(query)
         result: Set[bytes] = {row["public_key"] for row in rows}

flwr/server/superlink/state/state.py

@@ -153,8 +153,8 @@ class State(abc.ABC):  # pylint: disable=R0904
         """
 
     @abc.abstractmethod
-    def get_node_id(self, client_public_key: bytes) -> Optional[int]:
-        """Retrieve stored `node_id` filtered by `client_public_keys`."""
+    def get_node_id(self, node_public_key: bytes) -> Optional[int]:
+        """Retrieve stored `node_id` filtered by `node_public_keys`."""
 
     @abc.abstractmethod
     def create_run(
@@ -199,16 +199,16 @@ class State(abc.ABC):  # pylint: disable=R0904
         """Retrieve `server_public_key` in urlsafe bytes."""
 
     @abc.abstractmethod
-    def store_client_public_keys(self, public_keys: Set[bytes]) -> None:
-        """Store a set of `client_public_keys` in state."""
+    def store_node_public_keys(self, public_keys: Set[bytes]) -> None:
+        """Store a set of `node_public_keys` in state."""
 
     @abc.abstractmethod
-    def store_client_public_key(self, public_key: bytes) -> None:
-        """Store a `client_public_key` in state."""
+    def store_node_public_key(self, public_key: bytes) -> None:
+        """Store a `node_public_key` in state."""
 
     @abc.abstractmethod
-    def get_client_public_keys(self) -> Set[bytes]:
-        """Retrieve all currently stored `client_public_keys` as a set."""
+    def get_node_public_keys(self) -> Set[bytes]:
+        """Retrieve all currently stored `node_public_keys` as a set."""
 
     @abc.abstractmethod
     def acknowledge_ping(self, node_id: int, ping_interval: float) -> bool:

flwr/simulation/ray_transport/ray_actor.py

@@ -124,14 +124,14 @@ def pool_size_from_resources(client_resources: Dict[str, Union[int, float]]) ->
             WARNING,
             "The ActorPool is empty. The system (CPUs=%s, GPUs=%s) "
             "does not meet the criteria to host at least one client with resources:"
-            " %s. Lowering the `client_resources` could help.",
+            " %s. Lowering these resources could help.",
             num_cpus,
             num_gpus,
             client_resources,
         )
         raise ValueError(
             "ActorPool is empty. Stopping Simulation. "
-            "Check 'client_resources' passed to `start_simulation`"
+            "Check `num_cpus` and/or `num_gpus` passed to the simulation engine"
         )
 
     return total_num_actors

flwr/simulation/run_simulation.py

@@ -109,6 +109,11 @@ def run_simulation_from_cli() -> None:
     """Run Simulation Engine from the CLI."""
     args = _parse_args_run_simulation().parse_args()
 
+    event(
+        EventType.CLI_FLOWER_SIMULATION_ENTER,
+        event_details={"backend": args.backend, "num-supernodes": args.num_supernodes},
+    )
+
     # Add warnings for deprecated server_app and client_app arguments
     if args.server_app:
         warn_deprecated_feature(
@@ -177,7 +182,9 @@ def run_simulation_from_cli() -> None:
         client_app_attr = app_components["clientapp"]
         server_app_attr = app_components["serverapp"]
 
-        override_config = parse_config_args([args.run_config])
+        override_config = parse_config_args(
+            [args.run_config] if args.run_config else args.run_config
+        )
         fused_config = get_fused_config_from_dir(app_path, override_config)
         app_dir = args.app
         is_app = True
@@ -209,9 +216,11 @@ def run_simulation_from_cli() -> None:
         app_dir=app_dir,
         run=run,
         enable_tf_gpu_growth=args.enable_tf_gpu_growth,
+        delay_start=args.delay_start,
         verbose_logging=args.verbose,
         server_app_run_config=fused_config,
         is_app=is_app,
+        exit_event=EventType.CLI_FLOWER_SIMULATION_LEAVE,
     )
 
 
@@ -265,6 +274,11 @@ def run_simulation(
         When disabled, only INFO, WARNING and ERROR log messages will be shown. If
         enabled, DEBUG-level logs will be displayed.
     """
+    event(
+        EventType.PYTHON_API_RUN_SIMULATION_ENTER,
+        event_details={"backend": backend_name, "num-supernodes": num_supernodes},
+    )
+
     if enable_tf_gpu_growth:
         warn_deprecated_feature_with_example(
             "Passing `enable_tf_gpu_growth=True` is deprecated.",
@@ -282,6 +296,7 @@ def run_simulation(
         backend_config=backend_config,
         enable_tf_gpu_growth=enable_tf_gpu_growth,
         verbose_logging=verbose_logging,
+        exit_event=EventType.PYTHON_API_RUN_SIMULATION_LEAVE,
     )
 
 
@@ -295,7 +310,6 @@ def run_serverapp_th(
     f_stop: threading.Event,
     has_exception: threading.Event,
     enable_tf_gpu_growth: bool,
-    delay_launch: int = 3,
 ) -> threading.Thread:
     """Run SeverApp in a thread."""
 
@@ -351,7 +365,6 @@ def run_serverapp_th(
             server_app,
         ),
     )
-    sleep(delay_launch)
     serverapp_th.start()
     return serverapp_th
 
@@ -365,6 +378,8 @@ def _main_loop(
     is_app: bool,
     enable_tf_gpu_growth: bool,
     run: Run,
+    exit_event: EventType,
+    delay_start: int,
     flwr_dir: Optional[str] = None,
     client_app: Optional[ClientApp] = None,
     client_app_attr: Optional[str] = None,
@@ -372,7 +387,7 @@ def _main_loop(
     server_app_attr: Optional[str] = None,
     server_app_run_config: Optional[UserConfig] = None,
 ) -> None:
-    """Launch SuperLink with Simulation Engine, then ServerApp on a separate thread."""
+    """Start ServerApp on a separate thread, then launch Simulation Engine."""
     # Initialize StateFactory
     state_factory = StateFactory(":flwr-in-memory-state:")
 
@@ -380,6 +395,7 @@ def _main_loop(
     # A Threading event to indicate if an exception was raised in the ServerApp thread
     server_app_thread_has_exception = threading.Event()
     serverapp_th = None
+    success = True
     try:
         # Register run
         log(DEBUG, "Pre-registering run with id %s", run.run_id)
@@ -403,8 +419,10 @@ def _main_loop(
             enable_tf_gpu_growth=enable_tf_gpu_growth,
         )
 
-        # SuperLink with Simulation Engine
-        event(EventType.RUN_SUPERLINK_ENTER)
+        # Buffer time so the `ServerApp` in separate thread is ready
+        log(DEBUG, "Buffer time delay: %ds", delay_start)
+        sleep(delay_start)
+        # Start Simulation Engine
         vce.start_vce(
             num_supernodes=num_supernodes,
             client_app_attr=client_app_attr,
@@ -422,13 +440,13 @@ def _main_loop(
     except Exception as ex:
         log(ERROR, "An exception occurred !! %s", ex)
         log(ERROR, traceback.format_exc())
+        success = False
         raise RuntimeError("An error was encountered. Ending simulation.") from ex
 
     finally:
         # Trigger stop event
         f_stop.set()
-
-        event(EventType.RUN_SUPERLINK_LEAVE)
+        event(exit_event, event_details={"success": success})
         if serverapp_th:
             serverapp_th.join()
             if server_app_thread_has_exception.is_set():
@@ -440,6 +458,7 @@ def _main_loop(
 # pylint: disable=too-many-arguments,too-many-locals
 def _run_simulation(
     num_supernodes: int,
+    exit_event: EventType,
     client_app: Optional[ClientApp] = None,
     server_app: Optional[ServerApp] = None,
     backend_name: str = "ray",
@@ -451,6 +470,7 @@ def _run_simulation(
     flwr_dir: Optional[str] = None,
     run: Optional[Run] = None,
     enable_tf_gpu_growth: bool = False,
+    delay_start: int = 5,
     verbose_logging: bool = False,
     is_app: bool = False,
 ) -> None:
@@ -506,6 +526,8 @@ def _run_simulation(
         is_app,
         enable_tf_gpu_growth,
         run,
+        exit_event,
+        delay_start,
         flwr_dir,
         client_app,
         client_app_attr,
@@ -593,6 +615,13 @@ def _parse_args_run_simulation() -> argparse.ArgumentParser:
         "Read more about how `tf.config.experimental.set_memory_growth()` works in "
         "the TensorFlow documentation: https://www.tensorflow.org/api/stable.",
     )
+    parser.add_argument(
+        "--delay-start",
+        type=int,
+        default=3,
+        help="Buffer time (in seconds) to delay the start the simulation engine after "
+        "the `ServerApp`, which runs in a separate thread, has been launched.",
+    )
     parser.add_argument(
         "--verbose",
         action="store_true",

flwr/superexec/__init__.py

@@ -13,9 +13,3 @@
 # limitations under the License.
 # ==============================================================================
 """Flower SuperExec service."""
-
-from .app import run_superexec as run_superexec
-
-__all__ = [
-    "run_superexec",
-]

flwr/superexec/app.py

@@ -25,7 +25,7 @@ import grpc
 from flwr.common import EventType, event, log
 from flwr.common.address import parse_address
 from flwr.common.config import parse_config_args
-from flwr.common.constant import SUPEREXEC_DEFAULT_ADDRESS
+from flwr.common.constant import EXEC_API_DEFAULT_ADDRESS
 from flwr.common.exit_handlers import register_exit_handlers
 from flwr.common.object_ref import load_app, validate
 
@@ -56,7 +56,9 @@ def run_superexec() -> None:
         address=address,
         executor=_load_executor(args),
         certificates=certificates,
-        config=parse_config_args([args.executor_config]),
+        config=parse_config_args(
+            [args.executor_config] if args.executor_config else args.executor_config
+        ),
     )
 
     grpc_servers = [superexec_server]
@@ -79,7 +81,7 @@ def _parse_args_run_superexec() -> argparse.ArgumentParser:
     parser.add_argument(
         "--address",
         help="SuperExec (gRPC) server address (IPv4, IPv6, or a domain name)",
-        default=SUPEREXEC_DEFAULT_ADDRESS,
+        default=EXEC_API_DEFAULT_ADDRESS,
     )
     parser.add_argument(
         "--executor",

flwr/superexec/deployment.py

@@ -23,13 +23,13 @@ from typing import Optional
 from typing_extensions import override
 
 from flwr.cli.install import install_from_fab
+from flwr.common.constant import DRIVER_API_DEFAULT_ADDRESS
 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.server.driver.grpc_driver import DEFAULT_SERVER_ADDRESS_DRIVER
 
 from .executor import Executor, RunTracker
 
@@ -50,7 +50,7 @@ class DeploymentEngine(Executor):
 
     def __init__(
         self,
-        superlink: str = DEFAULT_SERVER_ADDRESS_DRIVER,
+        superlink: str = DRIVER_API_DEFAULT_ADDRESS,
         root_certificates: Optional[str] = None,
         flwr_dir: Optional[str] = None,
     ) -> None:

{flwr_nightly-1.11.0.dev20240823.dist-info → flwr_nightly-1.11.1.dev20240912.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: flwr-nightly
-Version: 1.11.0.dev20240823
+Version: 1.11.1.dev20240912
 Summary: Flower: A Friendly Federated Learning Framework
 Home-page: https://flower.ai
 License: Apache-2.0
@@ -195,8 +195,8 @@ Other [examples](https://github.com/adap/flower/tree/main/examples):
 - [PyTorch: From Centralized to Federated](https://github.com/adap/flower/tree/main/examples/pytorch-from-centralized-to-federated)
 - [Vertical FL](https://github.com/adap/flower/tree/main/examples/vertical-fl)
 - [Federated Finetuning of OpenAI's Whisper](https://github.com/adap/flower/tree/main/examples/whisper-federated-finetuning)
-- [Federated Finetuning of Large Language Model](https://github.com/adap/flower/tree/main/examples/llm-flowertune)
-- [Federated Finetuning of a Vision Transformer](https://github.com/adap/flower/tree/main/examples/vit-finetune)
+- [Federated Finetuning of Large Language Model](https://github.com/adap/flower/tree/main/examples/flowertune-llm)
+- [Federated Finetuning of a Vision Transformer](https://github.com/adap/flower/tree/main/examples/flowertune-vit)
 - [Advanced Flower with TensorFlow/Keras](https://github.com/adap/flower/tree/main/examples/advanced-tensorflow)
 - [Advanced Flower with PyTorch](https://github.com/adap/flower/tree/main/examples/advanced-pytorch)
 - Single-Machine Simulation of Federated Learning Systems ([PyTorch](https://github.com/adap/flower/tree/main/examples/simulation-pytorch)) ([Tensorflow](https://github.com/adap/flower/tree/main/examples/simulation-tensorflow))