flwr-nightly 1.26.0.dev20260119__py3-none-any.whl → 1.26.0.dev20260120__py3-none-any.whl

flwr/cli/config_migration.py

@@ -57,8 +57,11 @@ CLI_NOTICE = (
 )
 
 
-def _is_legacy_usage(superlink: str, args: list[str]) -> bool:
+def _is_legacy_usage(superlink: str | None, args: list[str]) -> bool:
     """Check if legacy usage is detected in the given arguments."""
+    if superlink is None:
+        return False
+
     # If one and only one extra argument is given, assume legacy usage
     if len(args) == 1:
         return True
@@ -75,26 +78,34 @@ def _is_legacy_usage(superlink: str, args: list[str]) -> bool:
     return False
 
 
-def _check_is_migratable(app: Path) -> None:
-    """Check if the given app path contains legacy TOML configuration."""
+def _is_migratable(app: Path) -> tuple[bool, str | None]:
+    """Check if the given app path contains legacy TOML configuration.
+
+    Parameters
+    ----------
+    app : Path
+        Path to the Flower App.
+
+    Returns
+    -------
+    tuple[bool, str | None]
+        Returns (True, None) if migratable, else (False, reason).
+    """
     toml_path = app / "pyproject.toml"
     if not toml_path.exists():
-        raise FileNotFoundError(f"No pyproject.toml found in '{app}'")
+        return False, f"No pyproject.toml found in '{app}'"
     config, errors, _ = load_and_validate(toml_path, check_module=False)
     if config is None:
-        raise ValueError(f"Failed to load TOML configuration: {toml_path}")
+        return False, f"Failed to load TOML configuration: {toml_path}"
     if errors:
-        raise ValueError(
-            f"Invalid TOML configuration found in '{toml_path}':\n"
-            + "\n".join(f"- {err}" for err in errors)
-        )
+        err_msg = f"Invalid TOML configuration found in '{toml_path}':\n"
+        err_msg += "\n".join(f"- {err}" for err in errors)
+        return False, err_msg
     try:
         _ = config["tool"]["flwr"]["federations"]
-        return
+        return True, None
     except KeyError:
-        raise ValueError(
-            f"No '[tool.flwr.federations]' section found in '{toml_path}'"
-        ) from None
+        return False, f"No '[tool.flwr.federations]' section found in '{toml_path}'"
 
 
 def _migrate_pyproject_toml_to_flower_config(
@@ -161,23 +172,81 @@ def _comment_out_legacy_toml_config(app: Path) -> None:
 
 
 def migrate(
-    app: Path,
-    toml_federation: str | None,
+    superlink: str | None,
+    args: list[str],
+    ignore_legacy_usage: bool = False,
 ) -> None:
-    """Migrate legacy TOML configuration to Flower config."""
+    """Migrate legacy TOML configuration to Flower config.
+
+    Migrates SuperLink connection settings from `[tool.flwr.federations]` in
+    pyproject.toml to the new Flower config format when legacy usage is detected
+    or the migration is applicable.
+
+    `flwr run` should call `migrate(superlink, [], ignore_legacy_usage=True)` to skip
+    legacy usage check. Other CLI commands should call `migrate(superlink, ctx.args)`.
+
+    Parameters
+    ----------
+    superlink : str | None
+        Value of the `[SUPERLINK]` argument provided to the CLI command.
+    args : list[str]
+        Additional arguments. In legacy usage, this is the TOML federation name.
+    ignore_legacy_usage : bool (default: False)
+        Set to `True` only for `flwr run` command to skip legacy usage check.
+
+    Raises
+    ------
+    click.UsageError
+        If more than one extra argument is provided.
+    click.ClickException
+        If legacy usage detected but migration fails.
+
+    Examples
+    --------
+    The following usages will trigger migration if applicable:
+    - `flwr <CMD> . my-federation`
+    - `flwr <CMD> ./my-app`
+    - `flwr <CMD>`
+
+    The following usages will NOT trigger migration:
+    - `flwr <CMD> named-conn`
+
+    Notes
+    -----
+    This function will NOT return when legacy usage is detected to force the user
+    to adapt to the new usage pattern after migration.
+    """
     # Initialize Flower config
     init_flwr_config()
 
-    # Print migration notice
-    typer.echo(CLI_NOTICE)
+    # Trigger the same typer error when detecting unexpected extra args
+    if len(args) > 1:
+        raise click.UsageError(f"Got unexpected extra arguments ({' '.join(args[1:])})")
 
-    # Check if migration is applicable
+    # Determine app path for migration
+    app = Path(superlink) if superlink else Path(".")
     app = app.resolve()
-    try:
-        _check_is_migratable(app)
-    except (FileNotFoundError, ValueError) as e:
-        raise click.ClickException(f"Cannot migrate configuration:\n{e}") from e
 
+    # Check if migration is applicable and if legacy usage is detected
+    is_migratable, reason = _is_migratable(app)
+    is_legacy = _is_legacy_usage(superlink, args) if not ignore_legacy_usage else False
+
+    # Print notice once if legacy usage detected or migration is applicable
+    if is_legacy or is_migratable:
+        typer.echo(CLI_NOTICE)
+
+    if not is_migratable:
+        # Raise error if legacy usage is detected but migration is not applicable
+        if is_legacy:
+            raise click.ClickException(
+                f"Cannot migrate configuration:\n{reason}. \nThis is expected if the "
+                "migration has been previously carried out. Use `--help` after your "
+                "command to see the new usage pattern."
+            )
+        return  # Nothing to migrate
+
+    # Perform migration
+    toml_federation = args[0] if len(args) == 1 else None
     try:
         migrated_conns, default_conn = _migrate_pyproject_toml_to_flower_config(
             app, toml_federation
@@ -197,30 +266,13 @@ def migrate(
             typer.secho(" (default)", fg=typer.colors.WHITE, nl=False)
         typer.echo()
 
-    # print usage
-    typer.secho("\nYou should now use the Flower CLI as follows:")
-    ctx = click.get_current_context()
-    typer.secho(ctx.get_usage() + "\n", bold=True)
-
     _comment_out_legacy_toml_config(app)
 
+    if is_legacy:
+        # print usage
+        typer.secho("\nYou should now use the Flower CLI as follows:")
+        ctx = click.get_current_context()
+        typer.secho(ctx.get_usage() + "\n", bold=True)
 
-def migrate_if_legacy_usage(
-    superlink: str,
-    args: list[str],
-) -> bool:
-    """Migrate legacy TOML configuration to Flower config if legacy usage is
-    detected."""
-    # Trigger the same typer error when detecting unexpected extra args
-    if len(args) > 1:
-        raise click.UsageError(f"Got unexpected extra arguments ({' '.join(args[1:])})")
-
-    # Skip migration if no legacy usage is detected
-    if not _is_legacy_usage(superlink, args):
-        return False
-
-    migrate(
-        app=Path(superlink),
-        toml_federation=args[0] if len(args) == 1 else None,
-    )
-    return True
+        # Abort if legacy usage is detected to force user to adapt to new usage
+        raise typer.Exit(code=1)

flwr/cli/flower_config.py

@@ -217,17 +217,17 @@ def serialize_superlink_connection(connection: SuperLinkConnection) -> dict[str,
     """
     # pylint: disable=protected-access
     conn_dict: dict[str, Any] = {
-        SuperLinkConnectionTomlKey.ADDRESS: connection._address,
-        SuperLinkConnectionTomlKey.ROOT_CERTIFICATES: connection._root_certificates,
+        SuperLinkConnectionTomlKey.ADDRESS: connection.address,
+        SuperLinkConnectionTomlKey.ROOT_CERTIFICATES: connection.root_certificates,
         SuperLinkConnectionTomlKey.INSECURE: connection._insecure,
         SuperLinkConnectionTomlKey.ENABLE_ACCOUNT_AUTH: connection._enable_account_auth,
-        SuperLinkConnectionTomlKey.FEDERATION: connection._federation,
+        SuperLinkConnectionTomlKey.FEDERATION: connection.federation,
     }
     # Remove None values
     conn_dict = {k: v for k, v in conn_dict.items() if v is not None}
 
-    if connection._options is not None:
-        options_dict = _serialize_simulation_options(connection._options)
+    if connection.options is not None:
+        options_dict = _serialize_simulation_options(connection.options)
         conn_dict[SuperLinkConnectionTomlKey.OPTIONS] = options_dict
 
     return conn_dict

flwr/cli/typing.py

@@ -93,15 +93,34 @@ class SuperLinkSimulationOptions:
 
 @dataclass
 class SuperLinkConnection:
-    """SuperLink connection configuration for CLI commands."""
+    """SuperLink connection configuration for CLI commands.
+
+    Attributes
+    ----------
+    name : str
+         The name of the connection configuration.
+    address : str
+        The address of the SuperLink (Control API).
+    root_certificates : str
+         The absolute path to the root CA certificate file.
+    insecure : bool (default: False)
+         Whether to use an insecure channel. If True, the
+         connection will not use TLS encryption.
+    enable_account_auth : bool (default: False)
+         Whether to enable account authentication.
+    federation : str
+         The name of the federation to interface with.
+    options : SuperLinkSimulationOptions
+         Configuration options for the simulation runtime.
+    """
 
     name: str
-    _address: str | None = None
-    _root_certificates: str | None = None
+    address: str | None = None
+    root_certificates: str | None = None
     _insecure: bool | None = None
     _enable_account_auth: bool | None = None
-    _federation: str | None = None
-    _options: SuperLinkSimulationOptions | None = None
+    federation: str | None = None
+    options: SuperLinkSimulationOptions | None = None
 
     # pylint: disable=too-many-arguments,too-many-positional-arguments
     def __init__(
@@ -115,84 +134,52 @@ class SuperLinkConnection:
         options: SuperLinkSimulationOptions | None = None,
     ) -> None:
         self.name = name
-        self._address = address
-        self._root_certificates = root_certificates
+        self.address = address
+        self.root_certificates = root_certificates
         self._insecure = insecure
         self._enable_account_auth = enable_account_auth
-        self._federation = federation
-        self._options = options
+        self.federation = federation
+        self.options = options
 
         self.__post_init__()
 
-    @property
-    def address(self) -> str:
-        """Return the address."""
-        if self._address is None:
-            raise ValueError(_ERROR_MSG_FMT % SuperLinkConnectionTomlKey.ADDRESS)
-        return self._address
-
-    @property
-    def root_certificates(self) -> str:
-        """Return the root certificates."""
-        if self._root_certificates is None:
-            raise ValueError(
-                _ERROR_MSG_FMT % SuperLinkConnectionTomlKey.ROOT_CERTIFICATES
-            )
-        return self._root_certificates
-
     @property
     def insecure(self) -> bool:
-        """Return the insecure flag."""
+        """Return the insecure flag or its default (False) if unset."""
         if self._insecure is None:
-            raise ValueError(_ERROR_MSG_FMT % SuperLinkConnectionTomlKey.INSECURE)
+            return False
         return self._insecure
 
     @property
     def enable_account_auth(self) -> bool:
-        """Return the enable_account_auth flag."""
+        """Return the enable_account_auth flag or its default (False) if unset."""
         if self._enable_account_auth is None:
-            raise ValueError(
-                _ERROR_MSG_FMT % SuperLinkConnectionTomlKey.ENABLE_ACCOUNT_AUTH
-            )
+            return False
         return self._enable_account_auth
 
-    @property
-    def federation(self) -> str:
-        """Return the federation."""
-        if self._federation is None:
-            raise ValueError(_ERROR_MSG_FMT % SuperLinkConnectionTomlKey.FEDERATION)
-        return self._federation
-
-    @property
-    def options(self) -> SuperLinkSimulationOptions:
-        """Return the simulation options."""
-        if self._options is None:
-            raise ValueError(_ERROR_MSG_FMT % SuperLinkConnectionTomlKey.OPTIONS)
-        return self._options
-
     def __post_init__(self) -> None:
         """Validate SuperLink connection configuration."""
         err_prefix = f"Invalid value for key '%s' in connection '{self.name}': "
-        if self._address is not None and not isinstance(self._address, str):
+        if self.address is not None and not isinstance(self.address, str):
             raise ValueError(
                 err_prefix % SuperLinkConnectionTomlKey.ADDRESS
-                + f"expected str, but got {type(self._address).__name__}."
+                + f"expected str, but got {type(self.address).__name__}."
             )
-        if self._root_certificates is not None and not isinstance(
-            self._root_certificates, str
+        if self.root_certificates is not None and not isinstance(
+            self.root_certificates, str
         ):
             raise ValueError(
                 err_prefix % SuperLinkConnectionTomlKey.ROOT_CERTIFICATES
-                + f"expected str, but got {type(self._root_certificates).__name__}."
+                + f"expected str, but got {type(self.root_certificates).__name__}."
             )
 
         # Ensure root certificates path is absolute
-        if self._root_certificates is not None:
-            if not Path(self._root_certificates).is_absolute():
+        if self.root_certificates is not None:
+            if not Path(self.root_certificates).is_absolute():
                 raise ValueError(
                     err_prefix % SuperLinkConnectionTomlKey.ROOT_CERTIFICATES
                     + "expected absolute path, but got relative path "
-                    f"'{self._root_certificates}'."
+                    f"'{self.root_certificates}'."
                 )
 
         if self._insecure is not None and not isinstance(self._insecure, bool):
@@ -208,14 +195,14 @@ class SuperLinkConnection:
                 + f"expected bool, but got {type(self._enable_account_auth).__name__}."
             )
 
-        if self._federation is not None and not isinstance(self._federation, str):
+        if self.federation is not None and not isinstance(self.federation, str):
             raise ValueError(
                 err_prefix % SuperLinkConnectionTomlKey.FEDERATION
-                + f"expected str, but got {type(self._federation).__name__}."
+                + f"expected str, but got {type(self.federation).__name__}."
             )
 
         # The connection needs to have either an address or options (or both).
-        if self._address is None and self._options is None:
+        if self.address is None and self.options is None:
             raise ValueError(
                 "Invalid SuperLink connection format: "
                 f"'{SuperLinkConnectionTomlKey.ADDRESS}' and/or "

flwr/cli/utils.py

@@ -486,7 +486,7 @@ def init_channel_from_connection(
 
     # Create the gRPC channel
     channel = create_channel(
-        server_address=connection.address,
+        server_address=connection.address,  # type: ignore
         insecure=connection.insecure,
         root_certificates=root_certificates_bytes,
         max_message_length=GRPC_MAX_MESSAGE_LENGTH,

flwr/supercore/sql_mixin.py

@@ -0,0 +1,253 @@
+# 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.
+# 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.
+# ==============================================================================
+"""Mixin providing common SQL connection and initialization logic via SQLAlchemy."""
+
+
+import re
+from abc import ABC
+from collections.abc import Sequence
+from logging import DEBUG, ERROR
+from pathlib import Path
+from typing import Any
+
+from sqlalchemy import Engine, MetaData, create_engine, event, inspect, text
+from sqlalchemy.engine import Result
+from sqlalchemy.exc import SQLAlchemyError
+from sqlalchemy.orm import Session, sessionmaker
+
+from flwr.common.logger import log
+from flwr.supercore.constant import SQLITE_PRAGMAS
+
+
+def _set_sqlite_pragmas(dbapi_conn: Any, _connection_record: Any) -> None:
+    """Set SQLite pragmas for performance and correctness."""
+    cursor = dbapi_conn.cursor()
+    for pragma, value in SQLITE_PRAGMAS:
+        cursor.execute(f"PRAGMA {pragma} = {value};")
+    cursor.close()
+
+
+def _log_query(  # pylint: disable=W0613,R0913,R0917
+    conn: Any,
+    cursor: Any,
+    statement: str,
+    parameters: Any,
+    context: Any,
+    executemany: bool,
+) -> None:
+    """Log SQL queries via Flower logger."""
+    log(DEBUG, {"query": statement, "params": parameters})
+
+
+class SqlMixin(ABC):
+    """Mixin providing common SQLite connection and initialization logic.
+
+    This mixin uses SQLAlchemy Core API for SQLite database access. It accepts either a
+    database file path or a SQLite URL, automatically converting file paths to SQLite
+    URLs.
+    """
+
+    def __init__(self, database_path: str) -> None:
+        """Initialize the SqlMixin.
+
+        Parameters
+        ----------
+        database_path : str
+            Either a file path or SQLite database URL. Examples:
+            - "path/to/db.db" or "/absolute/path/to/db.db"
+            - ":memory:" for in-memory SQLite
+            - "sqlite:///path/to/db.db" for explicit SQLite URL
+        """
+        # Auto-convert file path to SQLAlchemy SQLite URL if needed
+        if database_path == ":memory:":
+            self.database_url = "sqlite:///:memory:"
+        elif not database_path.startswith("sqlite://"):
+            # Treat as file path, convert to absolute and create SQLite URL
+            abs_path = Path(database_path).resolve()
+            self.database_url = f"sqlite:///{abs_path}"
+        else:
+            # Already a SQLite URL
+            self.database_url = database_path
+
+        self._engine: Engine | None = None
+        self._session_factory: sessionmaker[Session] | None = None
+
+    def session(self) -> Session:
+        """Create a new database session.
+
+        Returns
+        -------
+        Session
+            A new SQLAlchemy session. Use as context manager:
+
+            with self.session() as session:
+                session.execute(text("SELECT ..."))
+                session.commit()
+        """
+        if self._session_factory is None:
+            raise AttributeError("Database not initialized. Call initialize() first.")
+        return self._session_factory()
+
+    def get_metadata(self) -> MetaData | None:
+        """Return the MetaData object for this class.
+
+        Subclasses can override this to provide their SQLAlchemy MetaData.
+        The base implementation returns None.
+
+        Returns
+        -------
+        MetaData | None
+            SQLAlchemy MetaData object for this class.
+        """
+        return None
+
+    def initialize(self, log_queries: bool = False) -> list[str]:
+        """Connect to the DB and create tables if needed.
+
+        This method creates the SQLAlchemy engine and session factory,
+        and creates tables returned by `get_metadata()`.
+
+        Parameters
+        ----------
+        log_queries : bool
+            Log each query which is executed.
+
+        Returns
+        -------
+        list[str]
+            The list of all tables in the DB.
+        """
+        # Create engine with SQLite-specific settings
+        engine_kwargs: dict[str, Any] = {
+            # SQLite needs check_same_thread=False for multi-threaded access
+            "connect_args": {"check_same_thread": False}
+        }
+        self._engine = create_engine(self.database_url, **engine_kwargs)
+
+        # Set SQLite pragmas via event listener for optimal performance and correctness
+        event.listen(self._engine, "connect", _set_sqlite_pragmas)
+
+        if log_queries:
+            # Set up query logging via event listener
+            event.listen(self._engine, "before_cursor_execute", _log_query)
+
+        # Create session factory
+        self._session_factory = sessionmaker(bind=self._engine)
+
+        # Create tables defined in metadata (idempotent - only creates missing tables)
+        if (metadata := self.get_metadata()) is not None:
+            metadata.create_all(self._engine)
+
+        # Get all table names using inspector
+        inspector = inspect(self._engine)
+        return inspector.get_table_names()
+
+    def query(
+        self,
+        query: str,
+        data: Sequence[dict[str, Any]] | dict[str, Any] | None = None,
+    ) -> list[dict[str, Any]]:
+        """Execute a SQL query and return the results as list of dicts.
+
+        TRANSACTION SEMANTICS:
+        ----------------------
+        Each call to query() runs in its own isolated transaction that is
+        automatically committed. This is suitable for single SQL statements.
+
+        For complex operations requiring multiple SQL statements in a single
+        transaction, use session() directly instead:
+
+            with self.session() as session:
+                session.execute(text("UPDATE ..."), {...})
+                session.execute(text("INSERT ..."), {...})
+                session.commit()  # Commits both statements atomically
+
+        Parameters
+        ----------
+        query : str
+            SQL query string with named parameter placeholders.
+            Use :name syntax for parameters: "SELECT * FROM t WHERE a = :a AND b = :b"
+        data : Sequence[dict[str, Any]] | dict[str, Any] | None
+            Query parameters using named parameter syntax:
+            - Single execution: pass dict, e.g., {"a": value1, "b": value2}
+            - Batch execution: pass sequence of dicts, e.g., [{"a": 1}, {"a": 2}]
+
+        Returns
+        -------
+        list[dict[str, Any]]
+            Query results as a list of dictionaries.
+
+        Examples
+        --------
+        # Single query with named parameters (auto-committed transaction)
+        rows = self.query(
+            "SELECT * FROM node WHERE node_id = :id AND status = :status",
+            {"id": node_id, "status": status}
+        )
+
+        # Batch insert with named parameters (auto-committed transaction)
+        rows = self.query(
+            "INSERT INTO node (node_id, status) VALUES (:id, :status)",
+            [{"id": 1, "status": "online"}, {"id": 2, "status": "offline"}]
+        )
+
+        # Multi-statement transaction - use session() directly
+        with self.session() as session:
+            # Both statements succeed or fail together
+            session.execute(text("DELETE FROM old_data WHERE date < :cutoff"), {...})
+            session.execute(text("INSERT INTO archive SELECT * FROM old_data"), {})
+            session.commit()
+        """
+        if self._engine is None:
+            raise AttributeError(
+                "LinkState is not initialized. Call initialize() first."
+            )
+
+        if data is None:
+            data = {}
+
+        # Clean up whitespace to make the logs nicer
+        query = re.sub(r"\s+", " ", query.strip())
+
+        try:
+            with self.session() as session:
+                sql = text(query)
+
+                # Execute query (results live in database cursor)
+                # There is no need to check for batch vs single execution;
+                # SQLAlchemy handles both cases automatically.
+                result: Result[Any] = session.execute(sql, data)
+
+                # Fetch results into Python memory before commit.
+                # mappings() returns dict-like rows (works for SELECT and RETURNING).
+                if result.returns_rows:  # type: ignore
+                    rows = [dict(row) for row in result.mappings()]
+                else:
+                    # For statements without RETURNING (INSERT/UPDATE/DELETE),
+                    # returns_rows is False, so we return empty list.
+                    rows = []
+
+                # Commit transaction (finalizes database changes)
+                # NOTE: This commits after EVERY query() call, making each call
+                # an isolated transaction. For multi-statement transactions,
+                # use session() directly.
+                session.commit()
+
+                # Return the fetched data
+                return rows
+
+        except SQLAlchemyError as exc:
+            log(ERROR, {"query": query, "data": data, "exception": exc})
+            raise

{flwr_nightly-1.26.0.dev20260119.dist-info → flwr_nightly-1.26.0.dev20260120.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: flwr-nightly
-Version: 1.26.0.dev20260119
+Version: 1.26.0.dev20260120
 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

{flwr_nightly-1.26.0.dev20260119.dist-info → flwr_nightly-1.26.0.dev20260120.dist-info}/RECORD

@@ -18,13 +18,13 @@ flwr/cli/build.py,sha256=A9lzUNuGqLNId6PQppSWSlbMACl_LeW5Ispp9DuuX6k,10383
 flwr/cli/cli_account_auth_interceptor.py,sha256=mXgxThpZjU_2Xlae9xT8ewOw60GeE64comDd57asLIY,3680
 flwr/cli/config/__init__.py,sha256=46z6whA3hvKkl9APRs-UG7Ym3K9VOqKx_pYcgelRjtE,788
 flwr/cli/config/ls.py,sha256=ktRga1KWt4IDK5TQNT6ixfP66zcspkf-F2j3CkkpsGo,3665
-flwr/cli/config_migration.py,sha256=5rMAT4f3DpvIS4Hon2O-_elnTPhpyP-mWqaC-pCPQBA,8191
+flwr/cli/config_migration.py,sha256=_Ci20RoS8MPfSPh0qqeAKzN59IHOmAX5Yj6lUW3ac-o,10222
 flwr/cli/config_utils.py,sha256=PiYlb1bAwpxtMH3OQ7V0VeCATfX4gwhULpkfe61SRJI,12832
 flwr/cli/constant.py,sha256=b5WsK_KXg9yDDk2lxEiN7rggsnZYNu1fiBC9NJVnnNs,3291
 flwr/cli/example.py,sha256=SNTorkKPrx1rOryGREUyZu8TcOc1-vFv1zEddaysdY0,2216
 flwr/cli/federation/__init__.py,sha256=okxswL4fAjApI9gV_alU1lRkTUcQRbwlzvtUTLz61fE,793
 flwr/cli/federation/ls.py,sha256=dGNw6quUAbUmqTNIVAPgJ9UgCJddITjKr48ETXQ9LTE,11581
-flwr/cli/flower_config.py,sha256=vD6eUaHE-4iePA-vqRrTqcPkISJkXcAzKxDWFdYYp2I,15787
+flwr/cli/flower_config.py,sha256=RXYIkz3199iXu5eNodExM8KcXAQww4WhtaVOd6y4uZw,15782
 flwr/cli/install.py,sha256=yhgUWd_Psyc18DaoQHEQ5Ji45ZQ-3LclueM9uRxUEPw,10063
 flwr/cli/log.py,sha256=ZWveENLdDC0Dm10YIMcc3qdGV1aO-2YZXyHBhnB6ofI,7848
 flwr/cli/login/__init__.py,sha256=B1SXKU3HCQhWfFDMJhlC7FOl8UsvH4mxysxeBnrfyUE,800
@@ -41,8 +41,8 @@ flwr/cli/supernode/__init__.py,sha256=DBkjoPo2hS2Y-ghJxwLbrAbCQFBgD82_Itl2_892UB
 flwr/cli/supernode/ls.py,sha256=LNx3C9-Vfmw1ffVPDmjmex8TD_e0sTAXEC97aqg4Lqk,8958
 flwr/cli/supernode/register.py,sha256=2aQTT2wEp2pxxuIacC6FQkN8q_QKifZhWjD7LNw1R2A,6527
 flwr/cli/supernode/unregister.py,sha256=PXugcJJrM7cP3HbULjgcO22DciDP2uWN7YNgce4hv5E,4632
-flwr/cli/typing.py,sha256=1aCIvZOjK5BOWSZ7EpyPyYwvsy9NGpr0EaIp_9qXyeg,8469
-flwr/cli/utils.py,sha256=2X-NxhY41rlpdzzUobMmf2jLjEWTZ5BuvyehDllt_cE,23267
+flwr/cli/typing.py,sha256=MaY3NAca2PgmNByogksDKSCoRQLQpXTgO8NO9nLP0yA,8008
+flwr/cli/utils.py,sha256=HA-YGqyvjDazsvrpia2dOBWkpD1Q4GTLWjn1cKY-rRM,23283
 flwr/client/__init__.py,sha256=xwkPJfdeWxIIfmiPE5vnmnY_JbTlErP0Qs9eBP6qRFg,1252
 flwr/client/client.py,sha256=3HAchxvknKG9jYbB7swNyDj-e5vUWDuMKoLvbT7jCVM,7895
 flwr/client/dpfedavg_numpy_client.py,sha256=ELDHyEJcTB-FlLhHC-JXy8HuB3ZFHfT0HL3g1VSWY5w,7451
@@ -355,6 +355,7 @@ flwr/supercore/object_store/sqlite_object_store.py,sha256=oDfqGe6TEr1HT6_ZoxLoi7
 flwr/supercore/primitives/__init__.py,sha256=Tx8GOjnmMo8Y74RsDGrMpfr-E0Nl8dcUDF784_ge6F8,745
 flwr/supercore/primitives/asymmetric.py,sha256=1643niHYj3uEbfPd06VuMHwN3tKVwg0uVyR3RhTdWIU,3778
 flwr/supercore/primitives/asymmetric_ed25519.py,sha256=eIhOTMibQW0FJX4MXdplHdL3HcfCiKuFu2mQ8GQTUz8,5025
+flwr/supercore/sql_mixin.py,sha256=owyflbGoK7WgN9cuUTb_7-41n7AhCglKhCOO9cEOTbo,9423
 flwr/supercore/sqlite_mixin.py,sha256=KrHxJQlJSuTdfc8YlFTft-COzT6FvVtQDWAWkdJ-jGQ,5064
 flwr/supercore/state/__init__.py,sha256=FkKhsNVM4LjlRlOgXTz6twINmw5ohIUKS_OER0BNo_w,724
 flwr/supercore/state/schema/README.md,sha256=-0QrXDhnv30gEYoIUJo7aLUolY0r_t_nC24yk7B2agM,2892
@@ -402,7 +403,7 @@ flwr/supernode/servicer/__init__.py,sha256=lucTzre5WPK7G1YLCfaqg3rbFWdNSb7ZTt-ca
 flwr/supernode/servicer/clientappio/__init__.py,sha256=7Oy62Y_oijqF7Dxi6tpcUQyOpLc_QpIRZ83NvwmB0Yg,813
 flwr/supernode/servicer/clientappio/clientappio_servicer.py,sha256=rRL4CQ0L78jF_p0ct4-JMGREt6wWRy__wy4czF4f54Y,11639
 flwr/supernode/start_client_internal.py,sha256=BYk69UBQ2gQJaDQxXhccUgfOWrb7ShAstrbcMOCZIIs,26173
-flwr_nightly-1.26.0.dev20260119.dist-info/METADATA,sha256=QWoln95HbQwCmpCtN4waDrOah5wr1zjfTDSXBzUZgwI,14398
-flwr_nightly-1.26.0.dev20260119.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-flwr_nightly-1.26.0.dev20260119.dist-info/entry_points.txt,sha256=hxHD2ixb_vJFDOlZV-zB4Ao32_BQlL34ftsDh1GXv14,420
-flwr_nightly-1.26.0.dev20260119.dist-info/RECORD,,
+flwr_nightly-1.26.0.dev20260120.dist-info/METADATA,sha256=OiJyzqVqCMP8f7INcXZAXUn5k_p5E1nc052WUxULZlA,14398
+flwr_nightly-1.26.0.dev20260120.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+flwr_nightly-1.26.0.dev20260120.dist-info/entry_points.txt,sha256=hxHD2ixb_vJFDOlZV-zB4Ao32_BQlL34ftsDh1GXv14,420
+flwr_nightly-1.26.0.dev20260120.dist-info/RECORD,,