flwr 1.21.0__py3-none-any.whl → 1.23.0__py3-none-any.whl

flwr/simulation/ray_transport/ray_actor.py

@@ -24,7 +24,7 @@ import ray
 from ray import ObjectRef
 from ray.util.actor_pool import ActorPool
 
-from flwr.client.client_app import ClientApp, ClientAppException, LoadClientAppError
+from flwr.clientapp.client_app import ClientApp, ClientAppException, LoadClientAppError
 from flwr.common import Context, Message
 from flwr.common.logger import log
 

flwr/simulation/ray_transport/ray_client_proxy.py

@@ -21,8 +21,8 @@ from typing import Optional
 
 from flwr import common
 from flwr.client import ClientFnExt
-from flwr.client.client_app import ClientApp
 from flwr.client.run_info_store import DeprecatedRunInfoStore
+from flwr.clientapp.client_app import ClientApp
 from flwr.common import DEFAULT_TTL, Message, Metadata, RecordDict, now
 from flwr.common.constant import (
     NUM_PARTITIONS_KEY,

flwr/simulation/run_simulation.py

@@ -30,7 +30,7 @@ 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.clientapp import ClientApp
 from flwr.common import Context, EventType, RecordDict, event, log, now
 from flwr.common.config import get_fused_config_from_dir, parse_config_args
 from flwr.common.constant import RUN_ID_NUM_BYTES, Status
@@ -51,6 +51,7 @@ from flwr.server.superlink.linkstate.utils import generate_rand_int_from_bytes
 from flwr.simulation.ray_transport.utils import (
     enable_tf_gpu_growth as enable_gpu_growth,
 )
+from flwr.supercore.constant import FLWR_IN_MEMORY_DB_NAME
 
 
 def _replace_keys(d: Any, match: str, target: str) -> Any:
@@ -143,6 +144,15 @@ def run_simulation_from_cli() -> None:
     run = Run.create_empty(run_id)
     run.override_config = override_config
 
+    # Create Context
+    server_app_context = Context(
+        run_id=run_id,
+        node_id=0,
+        node_config=UserConfig(),
+        state=RecordDict(),
+        run_config=fused_config,
+    )
+
     _ = _run_simulation(
         server_app_attr=server_app_attr,
         client_app_attr=client_app_attr,
@@ -153,7 +163,7 @@ def run_simulation_from_cli() -> None:
         run=run,
         enable_tf_gpu_growth=args.enable_tf_gpu_growth,
         verbose_logging=args.verbose,
-        server_app_run_config=fused_config,
+        server_app_context=server_app_context,
         is_app=True,
         exit_event=EventType.CLI_FLOWER_SIMULATION_LEAVE,
     )
@@ -241,13 +251,12 @@ def run_simulation(
 def run_serverapp_th(
     server_app_attr: Optional[str],
     server_app: Optional[ServerApp],
-    server_app_run_config: UserConfig,
+    server_app_context: Context,
     grid: Grid,
     app_dir: str,
     f_stop: threading.Event,
     has_exception: threading.Event,
     enable_tf_gpu_growth: bool,
-    run_id: int,
     ctx_queue: "Queue[Context]",
 ) -> threading.Thread:
     """Run SeverApp in a thread."""
@@ -258,7 +267,6 @@ def run_serverapp_th(
         exception_event: threading.Event,
         _grid: Grid,
         _server_app_dir: str,
-        _server_app_run_config: UserConfig,
         _server_app_attr: Optional[str],
         _server_app: Optional[ServerApp],
         _ctx_queue: "Queue[Context]",
@@ -272,19 +280,10 @@ def run_serverapp_th(
                 log(INFO, "Enabling GPU growth for Tensorflow on the server thread.")
                 enable_gpu_growth()
 
-            # Initialize Context
-            context = Context(
-                run_id=run_id,
-                node_id=0,
-                node_config={},
-                state=RecordDict(),
-                run_config=_server_app_run_config,
-            )
-
             # Run ServerApp
             updated_context = _run(
                 grid=_grid,
-                context=context,
+                context=server_app_context,
                 server_app_dir=_server_app_dir,
                 server_app_attr=_server_app_attr,
                 loaded_server_app=_server_app,
@@ -310,7 +309,6 @@ def run_serverapp_th(
             has_exception,
             grid,
             app_dir,
-            server_app_run_config,
             server_app_attr,
             server_app,
             ctx_queue,
@@ -335,24 +333,26 @@ def _main_loop(
     client_app_attr: Optional[str] = None,
     server_app: Optional[ServerApp] = None,
     server_app_attr: Optional[str] = None,
-    server_app_run_config: Optional[UserConfig] = None,
+    server_app_context: Optional[Context] = None,
 ) -> Context:
     """Start ServerApp on a separate thread, then launch Simulation Engine."""
     # Initialize StateFactory
-    state_factory = LinkStateFactory(":flwr-in-memory-state:")
+    state_factory = LinkStateFactory(FLWR_IN_MEMORY_DB_NAME)
 
     f_stop = threading.Event()
     # 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
-    updated_context = Context(
-        run_id=run.run_id,
-        node_id=0,
-        node_config=UserConfig(),
-        state=RecordDict(),
-        run_config=UserConfig(),
-    )
+    if server_app_context is None:
+        server_app_context = Context(
+            run_id=run.run_id,
+            node_id=0,
+            node_config=UserConfig(),
+            state=RecordDict(),
+            run_config=UserConfig(),
+        )
+    updated_context = server_app_context
     try:
         # Register run
         log(DEBUG, "Pre-registering run with id %s", run.run_id)
@@ -361,9 +361,6 @@ def _main_loop(
         run.running_at = run.starting_at
         state_factory.state().run_ids[run.run_id] = RunRecord(run=run)  # type: ignore
 
-        if server_app_run_config is None:
-            server_app_run_config = {}
-
         # Initialize Grid
         grid = InMemoryGrid(state_factory=state_factory)
         grid.set_run(run_id=run.run_id)
@@ -373,13 +370,12 @@ def _main_loop(
         serverapp_th = run_serverapp_th(
             server_app_attr=server_app_attr,
             server_app=server_app,
-            server_app_run_config=server_app_run_config,
+            server_app_context=server_app_context,
             grid=grid,
             app_dir=app_dir,
             f_stop=f_stop,
             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,
         )
 
@@ -438,7 +434,7 @@ def _run_simulation(
     backend_config: Optional[BackendConfig] = None,
     client_app_attr: Optional[str] = None,
     server_app_attr: Optional[str] = None,
-    server_app_run_config: Optional[UserConfig] = None,
+    server_app_context: Optional[Context] = None,
     app_dir: str = "",
     flwr_dir: Optional[str] = None,
     run: Optional[Run] = None,
@@ -502,7 +498,7 @@ def _run_simulation(
         client_app_attr,
         server_app,
         server_app_attr,
-        server_app_run_config,
+        server_app_context,
     )
     # Detect if there is an Asyncio event loop already running.
     # If yes, disable logger propagation. In environmnets

flwr/supercore/cli/flower_superexec.py

@@ -17,7 +17,9 @@
 
 import argparse
 from logging import INFO
-from typing import Optional
+from typing import Any, Optional
+
+import yaml
 
 from flwr.common import EventType, event
 from flwr.common.constant import ExecPluginType
@@ -26,6 +28,7 @@ from flwr.common.logger import log
 from flwr.proto.clientappio_pb2_grpc import ClientAppIoStub
 from flwr.proto.serverappio_pb2_grpc import ServerAppIoStub
 from flwr.proto.simulationio_pb2_grpc import SimulationIoStub
+from flwr.supercore.constant import EXEC_PLUGIN_SECTION
 from flwr.supercore.grpc_health import add_args_health
 from flwr.supercore.superexec.plugin import (
     ClientAppExecPlugin,
@@ -36,6 +39,7 @@ from flwr.supercore.superexec.plugin import (
 from flwr.supercore.superexec.run_superexec import run_superexec
 
 try:
+    from flwr.ee import add_ee_args_superexec
     from flwr.ee.constant import ExecEePluginType
     from flwr.ee.exec_plugin import get_ee_plugin_and_stub_class
 except ImportError:
@@ -54,6 +58,10 @@ except ImportError:
         """Get the EE plugin class and stub class based on the plugin type."""
         return None
 
+    # pylint: disable-next=unused-argument
+    def add_ee_args_superexec(parser: argparse.ArgumentParser) -> None:
+        """Add EE-specific arguments to the parser."""
+
 
 def flower_superexec() -> None:
     """Run `flower-superexec` command."""
@@ -70,12 +78,28 @@ def flower_superexec() -> None:
     # Trigger telemetry event
     event(EventType.RUN_SUPEREXEC_ENTER, {"plugin_type": args.plugin_type})
 
+    # Load plugin config from YAML file if provided
+    plugin_config = None
+    if plugin_config_path := getattr(args, "plugin_config", None):
+        try:
+            with open(plugin_config_path, encoding="utf-8") as file:
+                yaml_config: Optional[dict[str, Any]] = yaml.safe_load(file)
+                if yaml_config is None or EXEC_PLUGIN_SECTION not in yaml_config:
+                    raise ValueError(f"Missing '{EXEC_PLUGIN_SECTION}' section.")
+                plugin_config = yaml_config[EXEC_PLUGIN_SECTION]
+        except (FileNotFoundError, yaml.YAMLError, ValueError) as e:
+            flwr_exit(
+                ExitCode.SUPEREXEC_INVALID_PLUGIN_CONFIG,
+                f"Failed to load plugin config from '{plugin_config_path}': {e!r}",
+            )
+
     # Get the plugin class and stub class based on the plugin type
     plugin_class, stub_class = _get_plugin_and_stub_class(args.plugin_type)
     run_superexec(
         plugin_class=plugin_class,
         stub_class=stub_class,  # type: ignore
         appio_api_address=args.appio_api_address,
+        plugin_config=plugin_config,
         flwr_dir=args.flwr_dir,
         parent_pid=args.parent_pid,
         health_server_address=args.health_server_address,
@@ -122,6 +146,7 @@ def _parse_args() -> argparse.ArgumentParser:
         help="The PID of the parent process. When set, the process will terminate "
         "when the parent process exits.",
     )
+    add_ee_args_superexec(parser)
     add_args_health(parser)
     return parser
 

flwr/supercore/constant.py

@@ -0,0 +1,41 @@
+# Copyright 2025 Flower Labs GmbH. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Constants for Flower infrastructure."""
+
+
+from __future__ import annotations
+
+# Top-level key in YAML config for exec plugin settings
+EXEC_PLUGIN_SECTION = "exec_plugin"
+
+# Flower in-memory Python-based database name
+FLWR_IN_MEMORY_DB_NAME = ":flwr-in-memory:"
+
+# Constants for Hub
+APP_ID_PATTERN = r"^@(?P<user>[^/]+)/(?P<app>[^/]+)$"
+PLATFORM_API_URL = "https://api.flower.ai/v1"
+
+
+class NodeStatus:
+    """Event log writer types."""
+
+    REGISTERED = "registered"
+    ONLINE = "online"
+    OFFLINE = "offline"
+    UNREGISTERED = "unregistered"
+
+    def __new__(cls) -> NodeStatus:
+        """Prevent instantiation."""
+        raise TypeError(f"{cls.__name__} cannot be instantiated.")

flwr/supercore/object_store/in_memory_object_store.py

@@ -48,9 +48,6 @@ class InMemoryObjectStore(ObjectStore):
         self.verify = verify
         self.store: dict[str, ObjectEntry] = {}
         self.lock_store = threading.RLock()
-        # Mapping the Object ID of a message to the list of descendant object IDs
-        self.msg_descendant_objects_mapping: dict[str, list[str]] = {}
-        self.lock_msg_mapping = threading.RLock()
         # Mapping each run ID to a set of object IDs that are used in that run
         self.run_objects_mapping: dict[int, set[str]] = {}
 
@@ -215,7 +212,6 @@ class InMemoryObjectStore(ObjectStore):
         """Clear the store."""
         with self.lock_store:
             self.store.clear()
-            self.msg_descendant_objects_mapping.clear()
             self.run_objects_mapping.clear()
 
     def __contains__(self, object_id: str) -> bool:

flwr/supercore/object_store/object_store_factory.py

@@ -19,15 +19,27 @@ from logging import DEBUG
 from typing import Optional
 
 from flwr.common.logger import log
+from flwr.supercore.constant import FLWR_IN_MEMORY_DB_NAME
 
 from .in_memory_object_store import InMemoryObjectStore
 from .object_store import ObjectStore
+from .sqlite_object_store import SqliteObjectStore
 
 
 class ObjectStoreFactory:
-    """Factory class that creates ObjectStore instances."""
+    """Factory class that creates ObjectStore instances.
 
-    def __init__(self) -> None:
+    Parameters
+    ----------
+    database : str (default: FLWR_IN_MEMORY_DB_NAME)
+        A string representing the path to the database file that will be opened.
+        Note that passing ":memory:" will open a connection to a database that is
+        in RAM, instead of on disk. And FLWR_IN_MEMORY_DB_NAME will create an
+        Python-based in-memory ObjectStore.
+    """
+
+    def __init__(self, database: str = FLWR_IN_MEMORY_DB_NAME) -> None:
+        self.database = database
         self.store_instance: Optional[ObjectStore] = None
 
     def store(self) -> ObjectStore:
@@ -38,7 +50,15 @@ class ObjectStoreFactory:
         ObjectStore
             An ObjectStore instance for storing objects by object_id.
         """
-        if self.store_instance is None:
-            self.store_instance = InMemoryObjectStore()
-        log(DEBUG, "Using InMemoryObjectStore")
-        return self.store_instance
+        # InMemoryObjectStore
+        if self.database == FLWR_IN_MEMORY_DB_NAME:
+            if self.store_instance is None:
+                self.store_instance = InMemoryObjectStore()
+            log(DEBUG, "Using InMemoryObjectStore")
+            return self.store_instance
+
+        # SqliteObjectStore
+        store = SqliteObjectStore(self.database)
+        store.initialize()
+        log(DEBUG, "Using SqliteObjectStore")
+        return store

flwr/supercore/object_store/sqlite_object_store.py

@@ -0,0 +1,252 @@
+# Copyright 2025 Flower Labs GmbH. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Flower SQLite ObjectStore implementation."""
+
+
+from typing import Optional, cast
+
+from flwr.common.inflatable import (
+    get_object_id,
+    is_valid_sha256_hash,
+    iterate_object_tree,
+)
+from flwr.common.inflatable_utils import validate_object_content
+from flwr.proto.message_pb2 import ObjectTree  # pylint: disable=E0611
+from flwr.supercore.sqlite_mixin import SqliteMixin
+from flwr.supercore.utils import uint64_to_int64
+
+from .object_store import NoObjectInStoreError, ObjectStore
+
+SQL_CREATE_OBJECTS = """
+CREATE TABLE IF NOT EXISTS objects (
+    object_id               TEXT PRIMARY KEY,
+    content                 BLOB,
+    is_available            INTEGER NOT NULL CHECK (is_available IN (0,1)),
+    ref_count               INTEGER NOT NULL
+);
+"""
+SQL_CREATE_OBJECT_CHILDREN = """
+CREATE TABLE IF NOT EXISTS object_children (
+    parent_id               TEXT NOT NULL,
+    child_id                TEXT NOT NULL,
+    FOREIGN KEY (parent_id) REFERENCES objects(object_id) ON DELETE CASCADE,
+    FOREIGN KEY (child_id)  REFERENCES objects(object_id) ON DELETE CASCADE,
+    PRIMARY KEY (parent_id, child_id)
+);
+"""
+SQL_CREATE_RUN_OBJECTS = """
+CREATE TABLE IF NOT EXISTS run_objects (
+    run_id                  INTEGER NOT NULL,
+    object_id               TEXT NOT NULL,
+    FOREIGN KEY (object_id) REFERENCES objects(object_id) ON DELETE CASCADE,
+    PRIMARY KEY (run_id, object_id)
+);
+"""
+
+
+class SqliteObjectStore(ObjectStore, SqliteMixin):
+    """SQLite-based implementation of the ObjectStore interface."""
+
+    def __init__(self, database_path: str, verify: bool = True) -> None:
+        super().__init__(database_path)
+        self.verify = verify
+
+    def initialize(self, log_queries: bool = False) -> list[tuple[str]]:
+        """Connect to the DB, enable FK support, and create tables if needed."""
+        return self._ensure_initialized(
+            SQL_CREATE_OBJECTS,
+            SQL_CREATE_OBJECT_CHILDREN,
+            SQL_CREATE_RUN_OBJECTS,
+            log_queries=log_queries,
+        )
+
+    def preregister(self, run_id: int, object_tree: ObjectTree) -> list[str]:
+        """Identify and preregister missing objects in the `ObjectStore`."""
+        new_objects = []
+        for tree_node in iterate_object_tree(object_tree):
+            obj_id = tree_node.object_id
+            if not is_valid_sha256_hash(obj_id):
+                raise ValueError(f"Invalid object ID format: {obj_id}")
+
+            child_ids = [child.object_id for child in tree_node.children]
+            with self.conn:
+                row = self.conn.execute(
+                    "SELECT object_id, is_available FROM objects WHERE object_id=?",
+                    (obj_id,),
+                ).fetchone()
+                if row is None:
+                    # Insert new object
+                    self.conn.execute(
+                        "INSERT INTO objects"
+                        "(object_id, content, is_available, ref_count) "
+                        "VALUES (?, ?, ?, ?)",
+                        (obj_id, b"", 0, 0),
+                    )
+                    for cid in child_ids:
+                        self.conn.execute(
+                            "INSERT INTO object_children(parent_id, child_id) "
+                            "VALUES (?, ?)",
+                            (obj_id, cid),
+                        )
+                        self.conn.execute(
+                            "UPDATE objects SET ref_count = ref_count + 1 "
+                            "WHERE object_id = ?",
+                            (cid,),
+                        )
+                    new_objects.append(obj_id)
+                else:
+                    # Add to the list of new objects if not available
+                    if not row["is_available"]:
+                        new_objects.append(obj_id)
+
+                # Ensure run mapping
+                self.conn.execute(
+                    "INSERT OR IGNORE INTO run_objects(run_id, object_id) "
+                    "VALUES (?, ?)",
+                    (uint64_to_int64(run_id), obj_id),
+                )
+        return new_objects
+
+    def get_object_tree(self, object_id: str) -> ObjectTree:
+        """Get the object tree for a given object ID."""
+        with self.conn:
+            row = self.conn.execute(
+                "SELECT object_id FROM objects WHERE object_id=?", (object_id,)
+            ).fetchone()
+            if not row:
+                raise NoObjectInStoreError(f"Object {object_id} not found.")
+            children = self.query(
+                "SELECT child_id FROM object_children WHERE parent_id=?", (object_id,)
+            )
+
+            # Build the object trees of all children
+            try:
+                child_trees = [self.get_object_tree(ch["child_id"]) for ch in children]
+            except NoObjectInStoreError as e:
+                # Raise an error if any child object is missing
+                # This indicates an integrity issue
+                raise NoObjectInStoreError(
+                    f"Object tree for object ID '{object_id}' contains missing "
+                    "children. This may indicate a corrupted object store."
+                ) from e
+
+            # Create and return the ObjectTree for the current object
+            return ObjectTree(object_id=object_id, children=child_trees)
+
+    def put(self, object_id: str, object_content: bytes) -> None:
+        """Put an object into the store."""
+        if self.verify:
+            # Verify object_id and object_content match
+            object_id_from_content = get_object_id(object_content)
+            if object_id != object_id_from_content:
+                raise ValueError(f"Object ID {object_id} does not match content hash")
+
+            # Validate object content
+            validate_object_content(content=object_content)
+
+        with self.conn:
+            # Only allow adding the object if it has been preregistered
+            row = self.conn.execute(
+                "SELECT is_available FROM objects WHERE object_id=?", (object_id,)
+            ).fetchone()
+            if row is None:
+                raise NoObjectInStoreError(
+                    f"Object with ID '{object_id}' was not pre-registered."
+                )
+
+            # Return if object is already present in the store
+            if row["is_available"]:
+                return
+
+            # Update the object entry in the store
+            self.conn.execute(
+                "UPDATE objects SET content=?, is_available=1 WHERE object_id=?",
+                (object_content, object_id),
+            )
+
+    def get(self, object_id: str) -> Optional[bytes]:
+        """Get an object from the store."""
+        rows = self.query("SELECT content FROM objects WHERE object_id=?", (object_id,))
+        return rows[0]["content"] if rows else None
+
+    def delete(self, object_id: str) -> None:
+        """Delete an object and its unreferenced descendants from the store."""
+        with self.conn:
+            row = self.conn.execute(
+                "SELECT ref_count FROM objects WHERE object_id=?", (object_id,)
+            ).fetchone()
+
+            # If the object is not in the store, nothing to delete
+            if row is None:
+                return
+
+            # Skip deletion if there are still references
+            if row["ref_count"] > 0:
+                return
+
+            # Deleting will cascade via FK, but we need to decrement children first
+            children = self.conn.execute(
+                "SELECT child_id FROM object_children WHERE parent_id=?", (object_id,)
+            ).fetchall()
+            child_ids = [child["child_id"] for child in children]
+
+            if child_ids:
+                placeholders = ", ".join("?" for _ in child_ids)
+                query = f"""
+                    UPDATE objects SET ref_count = ref_count - 1
+                    WHERE object_id IN ({placeholders})
+                """
+                self.conn.execute(query, child_ids)
+
+            self.conn.execute("DELETE FROM objects WHERE object_id=?", (object_id,))
+
+            # Recursively clean children
+            for child_id in child_ids:
+                self.delete(child_id)
+
+    def delete_objects_in_run(self, run_id: int) -> None:
+        """Delete all objects that were registered in a specific run."""
+        run_id_sint = uint64_to_int64(run_id)
+        with self.conn:
+            objs = self.conn.execute(
+                "SELECT object_id FROM run_objects WHERE run_id=?", (run_id_sint,)
+            ).fetchall()
+            for obj in objs:
+                object_id = obj["object_id"]
+                row = self.conn.execute(
+                    "SELECT ref_count FROM objects WHERE object_id=?", (object_id,)
+                ).fetchone()
+                if row and row["ref_count"] == 0:
+                    self.delete(object_id)
+            self.conn.execute("DELETE FROM run_objects WHERE run_id=?", (run_id_sint,))
+
+    def clear(self) -> None:
+        """Clear the store."""
+        with self.conn:
+            self.conn.execute("DELETE FROM object_children;")
+            self.conn.execute("DELETE FROM run_objects;")
+            self.conn.execute("DELETE FROM objects;")
+
+    def __contains__(self, object_id: str) -> bool:
+        """Check if an object_id is in the store."""
+        row = self.conn.execute(
+            "SELECT 1 FROM objects WHERE object_id=?", (object_id,)
+        ).fetchone()
+        return row is not None
+
+    def __len__(self) -> int:
+        """Return the number of objects in the store."""
+        row = self.conn.execute("SELECT COUNT(*) AS cnt FROM objects;").fetchone()
+        return cast(int, row["cnt"])

flwr/{client/clientapp → supercore/primitives}/__init__.py

@@ -12,4 +12,4 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ==============================================================================
-"""Flower AppIO service."""
+"""Cryptographic primitives for the Flower infrastructure."""