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

flwr/simulation/run_simulation.py

@@ -26,7 +26,7 @@ import traceback
 from logging import DEBUG, ERROR, INFO, WARNING
 from pathlib import Path
 from queue import Empty, Queue
-from typing import Any, Optional
+from typing import Any, cast
 
 from flwr.cli.config_utils import load_and_validate
 from flwr.cli.utils import get_sha256_hash
@@ -51,7 +51,9 @@ 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
+from flwr.supercore.constant import FLWR_IN_MEMORY_DB_NAME, NOOP_FEDERATION
+from flwr.supercore.object_store import ObjectStoreFactory
+from flwr.superlink.federation import NoOpFederationManager
 
 
 def _replace_keys(d: Any, match: str, target: str) -> Any:
@@ -99,12 +101,7 @@ def run_simulation_from_cli() -> None:
     _check_ray_support(args.backend)
 
     # Load JSON config
-    backend_config_dict = json.loads(args.backend_config)
-
-    if backend_config_dict:
-        # Backend config internally operates with `_` not with `-`
-        backend_config_dict = _replace_keys(backend_config_dict, match="-", target="_")
-        log(DEBUG, "backend_config_dict: %s", backend_config_dict)
+    backend_config = json.loads(args.backend_config)
 
     run_id = (
         generate_rand_int_from_bytes(RUN_ID_NUM_BYTES)
@@ -142,6 +139,7 @@ def run_simulation_from_cli() -> None:
 
     # Create run
     run = Run.create_empty(run_id)
+    run.federation = NOOP_FEDERATION
     run.override_config = override_config
 
     # Create Context
@@ -158,7 +156,7 @@ def run_simulation_from_cli() -> None:
         client_app_attr=client_app_attr,
         num_supernodes=args.num_supernodes,
         backend_name=args.backend,
-        backend_config=backend_config_dict,
+        backend_config=backend_config,
         app_dir=args.app,
         run=run,
         enable_tf_gpu_growth=args.enable_tf_gpu_growth,
@@ -176,7 +174,7 @@ def run_simulation(
     client_app: ClientApp,
     num_supernodes: int,
     backend_name: str = "ray",
-    backend_config: Optional[BackendConfig] = None,
+    backend_config: BackendConfig | None = None,
     enable_tf_gpu_growth: bool = False,
     verbose_logging: bool = False,
 ) -> None:
@@ -249,8 +247,8 @@ def run_simulation(
 
 # pylint: disable=too-many-arguments,too-many-positional-arguments
 def run_serverapp_th(
-    server_app_attr: Optional[str],
-    server_app: Optional[ServerApp],
+    server_app_attr: str | None,
+    server_app: ServerApp | None,
     server_app_context: Context,
     grid: Grid,
     app_dir: str,
@@ -267,8 +265,8 @@ def run_serverapp_th(
         exception_event: threading.Event,
         _grid: Grid,
         _server_app_dir: str,
-        _server_app_attr: Optional[str],
-        _server_app: Optional[ServerApp],
+        _server_app_attr: str | None,
+        _server_app: ServerApp | None,
         _ctx_queue: "Queue[Context]",
     ) -> None:
         """Run SeverApp, after check if GPU memory growth has to be set.
@@ -328,16 +326,18 @@ def _main_loop(
     enable_tf_gpu_growth: bool,
     run: Run,
     exit_event: EventType,
-    flwr_dir: Optional[str] = None,
-    client_app: Optional[ClientApp] = None,
-    client_app_attr: Optional[str] = None,
-    server_app: Optional[ServerApp] = None,
-    server_app_attr: Optional[str] = None,
-    server_app_context: Optional[Context] = None,
+    flwr_dir: str | None = None,
+    client_app: ClientApp | None = None,
+    client_app_attr: str | None = None,
+    server_app: ServerApp | None = None,
+    server_app_attr: str | None = None,
+    server_app_context: Context | None = None,
 ) -> Context:
     """Start ServerApp on a separate thread, then launch Simulation Engine."""
     # Initialize StateFactory
-    state_factory = LinkStateFactory(FLWR_IN_MEMORY_DB_NAME)
+    state_factory = LinkStateFactory(
+        FLWR_IN_MEMORY_DB_NAME, NoOpFederationManager(), ObjectStoreFactory()
+    )
 
     f_stop = threading.Event()
     # A Threading event to indicate if an exception was raised in the ServerApp thread
@@ -428,16 +428,16 @@ def _main_loop(
 def _run_simulation(
     num_supernodes: int,
     exit_event: EventType,
-    client_app: Optional[ClientApp] = None,
-    server_app: Optional[ServerApp] = None,
+    client_app: ClientApp | None = None,
+    server_app: ServerApp | None = None,
     backend_name: str = "ray",
-    backend_config: Optional[BackendConfig] = None,
-    client_app_attr: Optional[str] = None,
-    server_app_attr: Optional[str] = None,
-    server_app_context: Optional[Context] = None,
+    backend_config: BackendConfig | None = None,
+    client_app_attr: str | None = None,
+    server_app_attr: str | None = None,
+    server_app_context: Context | None = None,
     app_dir: str = "",
-    flwr_dir: Optional[str] = None,
-    run: Optional[Run] = None,
+    flwr_dir: str | None = None,
+    run: Run | None = None,
     enable_tf_gpu_growth: bool = False,
     verbose_logging: bool = False,
     is_app: bool = False,
@@ -445,29 +445,28 @@ def _run_simulation(
     """Launch the Simulation Engine."""
     if backend_config is None:
         backend_config = {}
+    elif backend_config:
+        # Backend config internally operates with `_` not with `-`
+        backend_config = cast(
+            BackendConfig, _replace_keys(backend_config, match="-", target="_")
+        )
+        log(DEBUG, "backend_config: %s", backend_config)
 
-    if "init_args" not in backend_config:
-        backend_config["init_args"] = {}
-
+    # Set default init_args if not passed
+    backend_config.setdefault("init_args", {})
     # Set default client_resources if not passed
-    if "client_resources" not in backend_config:
-        backend_config["client_resources"] = {"num_cpus": 2, "num_gpus": 0}
-
+    backend_config.setdefault("client_resources", {"num_cpus": 2, "num_gpus": 0})
     # Initialization of backend config to enable GPU growth globally when set
-    if "actor" not in backend_config:
-        backend_config["actor"] = {"tensorflow": 0}
+    backend_config.setdefault("actor", {"tensorflow": 0})
 
     # Set logging level
     logger = logging.getLogger("flwr")
     if verbose_logging:
         update_console_handler(level=DEBUG, timestamps=True, colored=True)
     else:
-        backend_config["init_args"]["logging_level"] = backend_config["init_args"].get(
-            "logging_level", WARNING
-        )
-        backend_config["init_args"]["log_to_driver"] = backend_config["init_args"].get(
-            "log_to_driver", True
-        )
+        init_args = backend_config["init_args"]
+        init_args.setdefault("logging_level", WARNING)
+        init_args.setdefault("log_to_driver", True)
 
     if enable_tf_gpu_growth:
         # Check that Backend config has also enabled using GPU growth
@@ -483,6 +482,7 @@ def _run_simulation(
     if run is None:
         run_id = generate_rand_int_from_bytes(RUN_ID_NUM_BYTES)
         run = Run.create_empty(run_id=run_id)
+        run.federation = NOOP_FEDERATION
 
     args = (
         num_supernodes,

flwr/simulation/simulationio_connection.py

@@ -16,7 +16,7 @@
 
 
 from logging import DEBUG, WARNING
-from typing import Optional, cast
+from typing import cast
 
 import grpc
 
@@ -43,12 +43,12 @@ class SimulationIoConnection:
     def __init__(  # pylint: disable=too-many-arguments
         self,
         simulationio_service_address: str = SIMULATIONIO_API_DEFAULT_CLIENT_ADDRESS,
-        root_certificates: Optional[bytes] = None,
+        root_certificates: bytes | None = None,
     ) -> None:
         self._addr = simulationio_service_address
         self._cert = root_certificates
-        self._grpc_stub: Optional[SimulationIoStub] = None
-        self._channel: Optional[grpc.Channel] = None
+        self._grpc_stub: SimulationIoStub | None = None
+        self._channel: grpc.Channel | None = None
         self._retry_invoker = _make_simple_grpc_retry_invoker()
 
     @property

flwr/supercore/cli/flower_superexec.py

@@ -17,7 +17,7 @@
 
 import argparse
 from logging import INFO
-from typing import Any, Optional
+from typing import Any
 
 import yaml
 
@@ -54,7 +54,7 @@ except ImportError:
 
     def get_ee_plugin_and_stub_class(  # pylint: disable=unused-argument
         plugin_type: str,
-    ) -> Optional[tuple[type[ExecPlugin], type[object]]]:
+    ) -> tuple[type[ExecPlugin], type[object]] | None:
         """Get the EE plugin class and stub class based on the plugin type."""
         return None
 
@@ -75,7 +75,6 @@ def flower_superexec() -> None:
     # Log the first message after parsing arguments in case of `--help`
     log(INFO, "Starting Flower SuperExec")
 
-    # Trigger telemetry event
     event(EventType.RUN_SUPEREXEC_ENTER, {"plugin_type": args.plugin_type})
 
     # Load plugin config from YAML file if provided
@@ -83,7 +82,7 @@ def flower_superexec() -> 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)
+                yaml_config: dict[str, Any] | None = 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]

flwr/supercore/constant.py

@@ -17,6 +17,8 @@
 
 from __future__ import annotations
 
+from flwr.common.constant import FLWR_DIR
+
 # Top-level key in YAML config for exec plugin settings
 EXEC_PLUGIN_SECTION = "exec_plugin"
 
@@ -24,9 +26,40 @@ EXEC_PLUGIN_SECTION = "exec_plugin"
 FLWR_IN_MEMORY_DB_NAME = ":flwr-in-memory:"
 
 # Constants for Hub
-APP_ID_PATTERN = r"^@(?P<user>[^/]+)/(?P<app>[^/]+)$"
+APP_ID_PATTERN = r"^@[A-Za-z0-9_.-]+/[A-Za-z0-9_.-]+$"
+APP_VERSION_PATTERN = r"^\d+\.\d+\.\d+$"
 PLATFORM_API_URL = "https://api.flower.ai/v1"
 
+# Specification for app publishing
+APP_PUBLISH_INCLUDE_PATTERNS = (
+    "**/*.py",
+    "**/*.toml",
+    "**/*.md",
+)
+APP_PUBLISH_EXCLUDE_PATTERNS = FAB_EXCLUDE_PATTERNS = (
+    f"{FLWR_DIR}/**",  # Exclude the .flwr directory
+    "**/__pycache__/**",
+)
+MAX_TOTAL_BYTES = 10 * 1024 * 1024  # 10 MB
+MAX_FILE_BYTES = 1 * 1024 * 1024  # 1 MB
+MAX_FILE_COUNT = 1000
+MAX_DIR_DEPTH = 10  # relative depth (number of parts in relpath)
+UTF8 = "utf-8"
+MIME_MAP = {
+    ".py": "text/x-python; charset=utf-8",
+    ".md": "text/markdown; charset=utf-8",
+    ".toml": "application/toml; charset=utf-8",
+}
+
+# Constants for federations
+NOOP_FEDERATION = "default"
+
+# Constants for exit handling
+FORCE_EXIT_TIMEOUT_SECONDS = 5  # Used in `flwr_exit` function
+
+# Constants for message processing timing
+MESSAGE_TIME_ENTRY_MAX_AGE_SECONDS = 3600
+
 
 class NodeStatus:
     """Event log writer types."""

flwr/supercore/corestate/corestate.py

@@ -16,14 +16,20 @@
 
 
 from abc import ABC, abstractmethod
-from typing import Optional
+
+from ..object_store import ObjectStore
 
 
 class CoreState(ABC):
     """Abstract base class for core state."""
 
+    @property
+    @abstractmethod
+    def object_store(self) -> ObjectStore:
+        """Return the ObjectStore instance used by this CoreState."""
+
     @abstractmethod
-    def create_token(self, run_id: int) -> Optional[str]:
+    def create_token(self, run_id: int) -> str | None:
         """Create a token for the given run ID.
 
         Parameters
@@ -66,7 +72,7 @@ class CoreState(ABC):
         """
 
     @abstractmethod
-    def get_run_id_by_token(self, token: str) -> Optional[int]:
+    def get_run_id_by_token(self, token: str) -> int | None:
         """Get the run ID associated with a given token.
 
         Parameters
@@ -79,3 +85,18 @@ class CoreState(ABC):
         Optional[int]
             The run ID if the token is valid, otherwise None.
         """
+
+    @abstractmethod
+    def acknowledge_app_heartbeat(self, token: str) -> bool:
+        """Acknowledge an app heartbeat with the provided token.
+
+        Parameters
+        ----------
+        token : str
+            The token associated with the app.
+
+        Returns
+        -------
+        bool
+            True if the heartbeat is acknowledged successfully, False otherwise.
+        """

flwr/supercore/corestate/in_memory_corestate.py

@@ -0,0 +1,138 @@
+# 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.
+# ==============================================================================
+"""In-memory CoreState implementation."""
+
+
+import secrets
+from dataclasses import dataclass
+from threading import Lock
+
+from flwr.common import now
+from flwr.common.constant import (
+    FLWR_APP_TOKEN_LENGTH,
+    HEARTBEAT_DEFAULT_INTERVAL,
+    HEARTBEAT_PATIENCE,
+)
+
+from ..object_store import ObjectStore
+from .corestate import CoreState
+
+
+@dataclass
+class TokenRecord:
+    """Record containing token and heartbeat information."""
+
+    token: str
+    active_until: float
+
+
+class InMemoryCoreState(CoreState):
+    """In-memory CoreState implementation."""
+
+    def __init__(self, object_store: ObjectStore) -> None:
+        self._object_store = object_store
+        # Store run ID to token mapping and token to run ID mapping
+        self.token_store: dict[int, TokenRecord] = {}
+        self.token_to_run_id: dict[str, int] = {}
+        self.lock_token_store = Lock()
+
+    @property
+    def object_store(self) -> ObjectStore:
+        """Return the ObjectStore instance used by this CoreState."""
+        return self._object_store
+
+    def create_token(self, run_id: int) -> str | None:
+        """Create a token for the given run ID."""
+        token = secrets.token_hex(FLWR_APP_TOKEN_LENGTH)  # Generate a random token
+        with self.lock_token_store:
+            if run_id in self.token_store:
+                return None  # Token already created for this run ID
+
+            self.token_store[run_id] = TokenRecord(
+                token=token, active_until=now().timestamp() + HEARTBEAT_DEFAULT_INTERVAL
+            )
+            self.token_to_run_id[token] = run_id
+        return token
+
+    def verify_token(self, run_id: int, token: str) -> bool:
+        """Verify a token for the given run ID."""
+        self._cleanup_expired_tokens()
+        with self.lock_token_store:
+            record = self.token_store.get(run_id)
+            return record is not None and record.token == token
+
+    def delete_token(self, run_id: int) -> None:
+        """Delete the token for the given run ID."""
+        with self.lock_token_store:
+            record = self.token_store.pop(run_id, None)
+            if record is not None:
+                self.token_to_run_id.pop(record.token, None)
+
+    def get_run_id_by_token(self, token: str) -> int | None:
+        """Get the run ID associated with a given token."""
+        self._cleanup_expired_tokens()
+        with self.lock_token_store:
+            return self.token_to_run_id.get(token)
+
+    def acknowledge_app_heartbeat(self, token: str) -> bool:
+        """Acknowledge an app heartbeat with the provided token."""
+        # Clean up expired tokens
+        self._cleanup_expired_tokens()
+
+        with self.lock_token_store:
+            # Return False if token is not found
+            if token not in self.token_to_run_id:
+                return False
+
+            # Get the run_id and update heartbeat info
+            run_id = self.token_to_run_id[token]
+            record = self.token_store[run_id]
+            current = now().timestamp()
+            record.active_until = (
+                current + HEARTBEAT_PATIENCE * HEARTBEAT_DEFAULT_INTERVAL
+            )
+            return True
+
+    def _cleanup_expired_tokens(self) -> None:
+        """Remove expired tokens and perform additional cleanup.
+
+        This method is called before token operations to ensure integrity.
+        Subclasses can override `_on_tokens_expired` to add custom cleanup logic.
+        """
+        with self.lock_token_store:
+            current = now().timestamp()
+            expired_records: list[tuple[int, float]] = []
+            for run_id, record in list(self.token_store.items()):
+                if record.active_until < current:
+                    expired_records.append((run_id, record.active_until))
+                    # Remove from both stores
+                    del self.token_store[run_id]
+                    self.token_to_run_id.pop(record.token, None)
+
+            # Hook for subclasses
+            if expired_records:
+                self._on_tokens_expired(expired_records)
+
+    def _on_tokens_expired(self, expired_records: list[tuple[int, float]]) -> None:
+        """Handle cleanup of expired tokens.
+
+        Override in subclasses to add custom cleanup logic.
+
+        Parameters
+        ----------
+        expired_records : list[tuple[int, float]]
+            List of tuples containing (run_id, active_until timestamp)
+            for expired tokens.
+        """

flwr/supercore/corestate/sqlite_corestate.py

@@ -0,0 +1,157 @@
+# 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.
+# ==============================================================================
+"""SQLite-based CoreState implementation."""
+
+
+import secrets
+import sqlite3
+from typing import cast
+
+from flwr.common import now
+from flwr.common.constant import (
+    FLWR_APP_TOKEN_LENGTH,
+    HEARTBEAT_DEFAULT_INTERVAL,
+    HEARTBEAT_PATIENCE,
+)
+from flwr.supercore.sqlite_mixin import SqliteMixin
+from flwr.supercore.utils import int64_to_uint64, uint64_to_int64
+
+from ..object_store import ObjectStore
+from .corestate import CoreState
+
+SQL_CREATE_TABLE_TOKEN_STORE = """
+CREATE TABLE IF NOT EXISTS token_store (
+    run_id                  INTEGER PRIMARY KEY,
+    token                   TEXT UNIQUE NOT NULL,
+    active_until            REAL
+);
+"""
+
+
+class SqliteCoreState(CoreState, SqliteMixin):
+    """SQLite-based CoreState implementation."""
+
+    def __init__(self, database_path: str, object_store: ObjectStore) -> None:
+        super().__init__(database_path)
+        self._object_store = object_store
+
+    @property
+    def object_store(self) -> ObjectStore:
+        """Return the ObjectStore instance used by this CoreState."""
+        return self._object_store
+
+    def get_sql_statements(self) -> tuple[str, ...]:
+        """Return SQL statements needed for CoreState tables."""
+        return (SQL_CREATE_TABLE_TOKEN_STORE,)
+
+    def create_token(self, run_id: int) -> str | None:
+        """Create a token for the given run ID."""
+        token = secrets.token_hex(FLWR_APP_TOKEN_LENGTH)  # Generate a random token
+        current = now().timestamp()
+        active_until = current + HEARTBEAT_DEFAULT_INTERVAL
+        query = """
+            INSERT INTO token_store (run_id, token, active_until)
+            VALUES (:run_id, :token, :active_until);
+        """
+        data = {
+            "run_id": uint64_to_int64(run_id),
+            "token": token,
+            "active_until": active_until,
+        }
+        try:
+            self.query(query, data)
+        except sqlite3.IntegrityError:
+            return None  # Token already created for this run ID
+        return token
+
+    def verify_token(self, run_id: int, token: str) -> bool:
+        """Verify a token for the given run ID."""
+        self._cleanup_expired_tokens()
+        query = "SELECT token FROM token_store WHERE run_id = :run_id;"
+        data = {"run_id": uint64_to_int64(run_id)}
+        rows = self.query(query, data)
+        if not rows:
+            return False
+        return cast(str, rows[0]["token"]) == token
+
+    def delete_token(self, run_id: int) -> None:
+        """Delete the token for the given run ID."""
+        query = "DELETE FROM token_store WHERE run_id = :run_id;"
+        data = {"run_id": uint64_to_int64(run_id)}
+        self.query(query, data)
+
+    def get_run_id_by_token(self, token: str) -> int | None:
+        """Get the run ID associated with a given token."""
+        self._cleanup_expired_tokens()
+        query = "SELECT run_id FROM token_store WHERE token = :token;"
+        data = {"token": token}
+        rows = self.query(query, data)
+        if not rows:
+            return None
+        return int64_to_uint64(rows[0]["run_id"])
+
+    def acknowledge_app_heartbeat(self, token: str) -> bool:
+        """Acknowledge an app heartbeat with the provided token."""
+        # Clean up expired tokens
+        self._cleanup_expired_tokens()
+
+        # Update the active_until field
+        current = now().timestamp()
+        active_until = current + HEARTBEAT_PATIENCE * HEARTBEAT_DEFAULT_INTERVAL
+        query = """
+            UPDATE token_store
+            SET active_until = :active_until
+            WHERE token = :token
+            RETURNING run_id;
+        """
+        data = {"active_until": active_until, "token": token}
+        rows = self.query(query, data)
+        return len(rows) > 0
+
+    def _cleanup_expired_tokens(self) -> None:
+        """Remove expired tokens and perform additional cleanup.
+
+        This method is called before token operations to ensure integrity.
+        Subclasses can override `_on_tokens_expired` to add custom cleanup logic.
+        """
+        current = now().timestamp()
+
+        with self.conn:
+            # Delete expired tokens and get their run_ids and active_until timestamps
+            query = """
+                DELETE FROM token_store
+                WHERE active_until < :current
+                RETURNING run_id, active_until;
+            """
+            rows = self.conn.execute(query, {"current": current}).fetchall()
+            expired_records = [
+                (int64_to_uint64(row["run_id"]), row["active_until"]) for row in rows
+            ]
+
+            # Hook for subclasses
+            if expired_records:
+                self._on_tokens_expired(expired_records)
+
+    def _on_tokens_expired(self, expired_records: list[tuple[int, float]]) -> None:
+        """Handle cleanup of expired tokens.
+
+        Override in subclasses to add custom cleanup logic.
+
+        Parameters
+        ----------
+        expired_records : list[tuple[int, float]]
+            List of tuples containing (run_id, active_until timestamp)
+            for expired tokens.
+        """

flwr/supercore/ffs/disk_ffs.py

@@ -18,7 +18,6 @@
 import hashlib
 import json
 from pathlib import Path
-from typing import Optional
 
 from .ffs import Ffs
 
@@ -59,7 +58,7 @@ class DiskFfs(Ffs):  # pylint: disable=R0904
 
         return content_hash
 
-    def get(self, key: str) -> Optional[tuple[bytes, dict[str, str]]]:
+    def get(self, key: str) -> tuple[bytes, dict[str, str]] | None:
         """Return tuple containing the object content and metadata.
 
         Parameters

flwr/supercore/ffs/ffs.py

@@ -16,7 +16,6 @@
 
 
 import abc
-from typing import Optional
 
 
 class Ffs(abc.ABC):  # pylint: disable=R0904
@@ -40,7 +39,7 @@ class Ffs(abc.ABC):  # pylint: disable=R0904
         """
 
     @abc.abstractmethod
-    def get(self, key: str) -> Optional[tuple[bytes, dict[str, str]]]:
+    def get(self, key: str) -> tuple[bytes, dict[str, str]] | None:
         """Return tuple containing the object content and metadata.
 
         Parameters