flwr-nightly 1.26.0.dev20260122__tar.gz → 1.26.0.dev20260123__tar.gz

{flwr_nightly-1.26.0.dev20260122 → flwr_nightly-1.26.0.dev20260123}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: flwr-nightly
-Version: 1.26.0.dev20260122
+Version: 1.26.0.dev20260123
 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
@@ -45,7 +45,7 @@ Requires-Dist: ray (==2.51.1) ; (python_version >= "3.10" and python_version < "
 Requires-Dist: ray (==2.51.1) ; (sys_platform != "win32" and python_version == "3.13") 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.45.2,<0.46.0) ; extra == "rest"
+Requires-Dist: starlette (>=0.47.2,<0.48.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.21.0)

{flwr_nightly-1.26.0.dev20260122 → flwr_nightly-1.26.0.dev20260123}/py/flwr/cli/config_utils.py

@@ -114,57 +114,6 @@ def load(toml_path: Path) -> dict[str, Any] | None:
             return None
 
 
-def process_loaded_project_config(
-    config: dict[str, Any] | None, errors: list[str], warnings: list[str]
-) -> dict[str, Any]:
-    """Process and return the loaded project configuration.
-
-    This function handles errors and warnings from the `load_and_validate` function,
-    exits on critical issues, and returns the validated configuration.
-
-    Parameters
-    ----------
-    config : dict[str, Any] | None
-        The loaded configuration dictionary, or None if loading failed.
-    errors : list[str]
-        List of error messages from validation.
-    warnings : list[str]
-        List of warning messages from validation.
-
-    Returns
-    -------
-    dict[str, Any]
-        The validated configuration dictionary.
-
-    Raises
-    ------
-    typer.Exit
-        If config is None or contains critical errors.
-    """
-    if config is None:
-        typer.secho(
-            "Project configuration could not be loaded.\n"
-            "pyproject.toml is invalid:\n"
-            + "\n".join([f"- {line}" for line in errors]),
-            fg=typer.colors.RED,
-            bold=True,
-            err=True,
-        )
-        raise typer.Exit(code=1)
-
-    if warnings:
-        typer.secho(
-            "Project configuration is missing the following "
-            "recommended properties:\n" + "\n".join([f"- {line}" for line in warnings]),
-            fg=typer.colors.RED,
-            bold=True,
-        )
-
-    typer.secho("Success", fg=typer.colors.GREEN)
-
-    return config
-
-
 def validate_federation_in_project_config(
     federation: str | None,
     config: dict[str, Any],
@@ -229,61 +178,6 @@ def validate_federation_in_project_config(
     return federation, federation_config
 
 
-def validate_certificate_in_federation_config(
-    app: Path, federation_config: dict[str, Any]
-) -> tuple[bool, bytes | None]:
-    """Validate the certificates in the Flower project configuration.
-
-    Accepted configurations:
-      1. TLS enabled and gRPC will load(*) the trusted certificate bundle:
-         - Only `address` is provided. `root-certificates` and `insecure` not set.
-         - `address` is provided and `insecure` set to `false`. `root-certificates` not
-           set.
-         (*)gRPC uses a multi-step fallback mechanism to load the trusted certificate
-            bundle in the following sequence:
-            a. A configured file path (if set via configuration or environment),
-            b. An override callback (if registered via
-               `grpc_set_ssl_roots_override_callback`),
-            c. The OS trust store (if available),
-            d. A bundled default certificate file.
-      2. TLS enabled with self-signed certificates:
-         - `address` and `root-certificates` are provided. `insecure` not set.
-         - `address` and `root-certificates` are provided. `insecure` set to `false`.
-      3. TLS disabled. This is not recommended and should only be used for prototyping:
-         - `address` is provided and `insecure = true`. If `root-certificates` is
-           set, exit with an error.
-    """
-    insecure = get_insecure_flag(federation_config)
-
-    # Process root certificates
-    if root_certificates := federation_config.get("root-certificates"):
-        if insecure:
-            typer.secho(
-                "❌ `root-certificates` were provided but the `insecure` parameter "
-                "is set to `True`.",
-                fg=typer.colors.RED,
-                bold=True,
-                err=True,
-            )
-            raise typer.Exit(code=1)
-
-        # TLS is enabled with self-signed certificates: attempt to read the file
-        try:
-            root_certificates_bytes = (app / root_certificates).read_bytes()
-        except Exception as e:
-            typer.secho(
-                f"❌ Failed to read certificate file `{root_certificates}`: {e}",
-                fg=typer.colors.RED,
-                bold=True,
-                err=True,
-            )
-            raise typer.Exit(code=1) from e
-    else:
-        root_certificates_bytes = None
-
-    return insecure, root_certificates_bytes
-
-
 def load_certificate_in_connection(
     connection: SuperLinkConnection,
 ) -> bytes | None:
@@ -336,32 +230,6 @@ def load_certificate_in_connection(
     return root_certificates_bytes
 
 
-def exit_if_no_address(federation_config: dict[str, Any], cmd: str) -> None:
-    """Exit if the provided federation_config has no "address" key.
-
-    Parameters
-    ----------
-    federation_config : dict[str, Any]
-        The federation configuration dictionary to check.
-    cmd : str
-        The command name to display in the error message.
-
-    Raises
-    ------
-    typer.Exit
-        If 'address' key is not present in federation_config.
-    """
-    if "address" not in federation_config:
-        typer.secho(
-            f"❌ `flwr {cmd}` currently works with a SuperLink. Ensure that the "
-            "correct SuperLink (Control API) address is provided in `pyproject.toml`.",
-            fg=typer.colors.RED,
-            bold=True,
-            err=True,
-        )
-        raise typer.Exit(code=1)
-
-
 def get_insecure_flag(federation_config: dict[str, Any]) -> bool:
     """Extract and validate the `insecure` flag from the federation configuration.
 

{flwr_nightly-1.26.0.dev20260122 → flwr_nightly-1.26.0.dev20260123}/py/flwr/cli/utils.py

@@ -20,7 +20,7 @@ import json
 from collections.abc import Callable, Iterable, Iterator
 from contextlib import contextmanager
 from pathlib import Path
-from typing import Any, cast
+from typing import cast
 
 import click
 import grpc
@@ -50,10 +50,7 @@ from flwr.supercore.credential_store import get_credential_store
 
 from .auth_plugin import CliAuthPlugin, get_cli_plugin_class
 from .cli_account_auth_interceptor import CliAccountAuthInterceptor
-from .config_utils import (
-    load_certificate_in_connection,
-    validate_certificate_in_federation_config,
-)
+from .config_utils import load_certificate_in_connection
 from .constant import AUTHN_TYPE_STORE_KEY
 
 
@@ -197,18 +194,6 @@ def get_authn_type(host: str) -> str:
     return authn_type.decode("utf-8")
 
 
-def load_cli_auth_plugin(
-    root_dir: Path,
-    federation: str,
-    federation_config: dict[str, Any],
-    authn_type: str | None = None,
-) -> CliAuthPlugin:
-    """."""
-    raise RuntimeError(
-        "Deprecated function. Use `load_cli_auth_plugin_from_connection`"
-    )
-
-
 def load_cli_auth_plugin_from_connection(
     host: str, authn_type: str | None = None
 ) -> CliAuthPlugin:
@@ -246,44 +231,6 @@ def load_cli_auth_plugin_from_connection(
         raise typer.Exit(code=1) from None
 
 
-def init_channel(
-    app: Path, federation_config: dict[str, Any], auth_plugin: CliAuthPlugin
-) -> grpc.Channel:
-    """Initialize gRPC channel to the Control API.
-
-    Parameters
-    ----------
-    app : Path
-        Path to the Flower app directory.
-    federation_config : dict[str, Any]
-        Federation configuration dictionary containing address and TLS settings.
-    auth_plugin : CliAuthPlugin
-        Authentication plugin instance for handling credentials.
-
-    Returns
-    -------
-    grpc.Channel
-        Configured gRPC channel with authentication interceptors.
-    """
-    insecure, root_certificates_bytes = validate_certificate_in_federation_config(
-        app, federation_config
-    )
-
-    # Load tokens
-    auth_plugin.load_tokens()
-
-    # Create the gRPC channel
-    channel = create_channel(
-        server_address=federation_config["address"],
-        insecure=insecure,
-        root_certificates=root_certificates_bytes,
-        max_message_length=GRPC_MAX_MESSAGE_LENGTH,
-        interceptors=[CliAccountAuthInterceptor(auth_plugin)],
-    )
-    channel.subscribe(on_channel_state_change)
-    return channel
-
-
 def require_superlink_address(connection: SuperLinkConnection) -> str:
     """Return the SuperLink address or exit if it is not configured."""
     if connection.address is None:

{flwr_nightly-1.26.0.dev20260122 → flwr_nightly-1.26.0.dev20260123}/py/flwr/server/superlink/linkstate/__init__.py

@@ -19,12 +19,10 @@ from .in_memory_linkstate import InMemoryLinkState as InMemoryLinkState
 from .linkstate import LinkState as LinkState
 from .linkstate_factory import LinkStateFactory as LinkStateFactory
 from .sql_linkstate import SqlLinkState as SqlLinkState
-from .sqlite_linkstate import SqliteLinkState as SqliteLinkState
 
 __all__ = [
     "InMemoryLinkState",
     "LinkState",
     "LinkStateFactory",
     "SqlLinkState",
-    "SqliteLinkState",
 ]

{flwr_nightly-1.26.0.dev20260122 → flwr_nightly-1.26.0.dev20260123}/py/flwr/supercore/object_store/object_store_factory.py

@@ -22,7 +22,7 @@ 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
+from .sql_object_store import SqlObjectStore
 
 
 class ObjectStoreFactory:
@@ -56,8 +56,8 @@ class ObjectStoreFactory:
             log(DEBUG, "Using InMemoryObjectStore")
             return self.store_instance
 
-        # SqliteObjectStore
-        store = SqliteObjectStore(self.database)
+        # SqlObjectStore
+        store = SqlObjectStore(self.database)
         store.initialize()
-        log(DEBUG, "Using SqliteObjectStore")
+        log(DEBUG, "Using SqlObjectStore")
         return store

flwr_nightly-1.26.0.dev20260122/py/flwr/supercore/object_store/sqlite_object_store.py → flwr_nightly-1.26.0.dev20260123/py/flwr/supercore/object_store/sql_object_store.py

@@ -1,4 +1,4 @@
-# Copyright 2025 Flower Labs GmbH. All Rights Reserved.
+# Copyright 2026 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.
@@ -12,10 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ==============================================================================
-"""Flower SQLite ObjectStore implementation."""
+"""Flower SQLAlchemy-based ObjectStore implementation."""
 
 
-from typing import cast
+from sqlalchemy import MetaData
 
 from flwr.common.inflatable import (
     get_object_id,
@@ -24,52 +24,23 @@ from flwr.common.inflatable import (
 )
 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.sql_mixin import SqlMixin
+from flwr.supercore.state.schema.objectstore_tables import create_objectstore_metadata
 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."""
+
+class SqlObjectStore(ObjectStore, SqlMixin):
+    """SQLAlchemy-based implementation of the ObjectStore interface."""
 
     def __init__(self, database_path: str, verify: bool = True) -> None:
         super().__init__(database_path)
         self.verify = verify
 
-    def get_sql_statements(self) -> tuple[str, ...]:
-        """Return SQL statements for ObjectStore tables."""
-        return (
-            SQL_CREATE_OBJECTS,
-            SQL_CREATE_OBJECT_CHILDREN,
-            SQL_CREATE_RUN_OBJECTS,
-        )
+    def get_metadata(self) -> MetaData:
+        """Return SQLAlchemy MetaData for ObjectStore tables."""
+        return create_objectstore_metadata()
 
     def preregister(self, run_id: int, object_tree: ObjectTree) -> list[str]:
         """Identify and preregister missing objects in the `ObjectStore`."""
@@ -80,56 +51,64 @@ class SqliteObjectStore(ObjectStore, SqliteMixin):
                 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:
+            with self.session():
+                rows = self.query(
+                    "SELECT object_id, is_available FROM objects "
+                    "WHERE object_id = :object_id",
+                    {"object_id": obj_id},
+                )
+                if not rows:
                     # Insert new object
-                    self.conn.execute(
-                        "INSERT INTO objects"
+                    self.query(
+                        "INSERT INTO objects "
                         "(object_id, content, is_available, ref_count) "
-                        "VALUES (?, ?, ?, ?)",
-                        (obj_id, b"", 0, 0),
+                        "VALUES (:object_id, :content, :is_available, :ref_count)",
+                        {
+                            "object_id": obj_id,
+                            "content": b"",
+                            "is_available": 0,
+                            "ref_count": 0,
+                        },
                     )
                     for cid in child_ids:
-                        self.conn.execute(
-                            "INSERT INTO object_children(parent_id, child_id) "
-                            "VALUES (?, ?)",
-                            (obj_id, cid),
+                        self.query(
+                            "INSERT INTO object_children (parent_id, child_id) "
+                            "VALUES (:parent_id, :child_id)",
+                            {"parent_id": obj_id, "child_id": cid},
                         )
-                        self.conn.execute(
+                        self.query(
                             "UPDATE objects SET ref_count = ref_count + 1 "
-                            "WHERE object_id = ?",
-                            (cid,),
+                            "WHERE object_id = :object_id",
+                            {"object_id": cid},
                         )
                     new_objects.append(obj_id)
                 else:
                     # Add to the list of new objects if not available
-                    if not row["is_available"]:
+                    if not rows[0]["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),
+                self.query(
+                    "INSERT INTO run_objects (run_id, object_id) "
+                    "VALUES (:run_id, :object_id) ON CONFLICT DO NOTHING",
+                    {"run_id": uint64_to_int64(run_id), "object_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:
+        with self.session():
+            rows = self.query(
+                "SELECT object_id FROM objects WHERE object_id = :object_id",
+                {"object_id": object_id},
+            )
+            if not rows:
                 raise NoObjectInStoreError(
                     f"Object {object_id} was not pre-registered."
                 )
             children = self.query(
-                "SELECT child_id FROM object_children WHERE parent_id=?", (object_id,)
+                "SELECT child_id FROM object_children WHERE parent_id = :parent_id",
+                {"parent_id": object_id},
             )
 
             # Build the object trees of all children
@@ -157,61 +136,71 @@ class SqliteObjectStore(ObjectStore, SqliteMixin):
             # Validate object content
             validate_object_content(content=object_content)
 
-        with self.conn:
+        with self.session():
             # 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:
+            rows = self.query(
+                "SELECT is_available FROM objects WHERE object_id = :object_id",
+                {"object_id": object_id},
+            )
+            if not rows:
                 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"]:
+            if rows[0]["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),
+            self.query(
+                "UPDATE objects SET content = :content, is_available = 1 "
+                "WHERE object_id = :object_id",
+                {"content": object_content, "object_id": object_id},
             )
 
     def get(self, object_id: str) -> bytes | None:
         """Get an object from the store."""
-        rows = self.query("SELECT content FROM objects WHERE object_id=?", (object_id,))
+        rows = self.query(
+            "SELECT content FROM objects WHERE object_id = :oid", {"oid": 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()
+        with self.session():
+            rows = self.query(
+                "SELECT ref_count FROM objects WHERE object_id = :object_id",
+                {"object_id": object_id},
+            )
 
             # If the object is not in the store, nothing to delete
-            if row is None:
+            if not rows:
                 return
 
             # Skip deletion if there are still references
-            if row["ref_count"] > 0:
+            if rows[0]["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()
+            children = self.query(
+                "SELECT child_id FROM object_children WHERE parent_id = :parent_id",
+                {"parent_id": object_id},
+            )
             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)
+                placeholders = ", ".join(f":cid{i}" for i in range(len(child_ids)))
+                params = {f"cid{i}": cid for i, cid in enumerate(child_ids)}
+                self.query(
+                    "UPDATE objects SET ref_count = ref_count - 1 "
+                    f"WHERE object_id IN ({placeholders})",
+                    params,
+                )
 
-            self.conn.execute("DELETE FROM objects WHERE object_id=?", (object_id,))
+            self.query(
+                "DELETE FROM objects WHERE object_id = :object_id",
+                {"object_id": object_id},
+            )
 
             # Recursively clean children
             for child_id in child_ids:
@@ -220,34 +209,39 @@ class SqliteObjectStore(ObjectStore, SqliteMixin):
     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()
+        with self.session():
+            objs = self.query(
+                "SELECT object_id FROM run_objects WHERE run_id = :run_id",
+                {"run_id": run_id_sint},
+            )
             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:
+                rows = self.query(
+                    "SELECT ref_count FROM objects WHERE object_id=:object_id",
+                    {"object_id": object_id},
+                )
+                if rows and rows[0]["ref_count"] == 0:
                     self.delete(object_id)
-            self.conn.execute("DELETE FROM run_objects WHERE run_id=?", (run_id_sint,))
+            self.query(
+                "DELETE FROM run_objects WHERE run_id = :run_id",
+                {"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;")
+        with self.session():
+            self.query("DELETE FROM object_children")
+            self.query("DELETE FROM run_objects")
+            self.query("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
+        rows = self.query(
+            "SELECT 1 FROM objects WHERE object_id = :oid", {"oid": object_id}
+        )
+        return len(rows) > 0
 
     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"])
+        rows = self.query("SELECT COUNT(*) AS cnt FROM objects")
+        return int(rows[0]["cnt"])

{flwr_nightly-1.26.0.dev20260122 → flwr_nightly-1.26.0.dev20260123}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "flwr-nightly"
-version = "1.26.0.dev20260122"
+version = "1.26.0.dev20260123"
 description = "Flower: A Friendly Federated AI Framework"
 license = "Apache-2.0"
 authors = ["The Flower Authors <hello@flower.ai>"]
@@ -85,7 +85,7 @@ ray = [
     { version = "==2.51.1", optional = true, python = "==3.13", markers = "sys_platform != 'win32'" },
 ]
 # Optional dependencies (REST transport layer)
-starlette = { version = "^0.45.2", optional = true }
+starlette = { version = "^0.47.2", optional = true }
 uvicorn = { version = "^0.34.0", extras = ["standard"], optional = true }
 
 [tool.poetry.extras]