sqlspec 0.21.1__py3-none-any.whl → 0.22.0__py3-none-any.whl

sqlspec/storage/registry.py

@@ -14,7 +14,6 @@ from mypy_extensions import mypyc_attr
 
 from sqlspec.exceptions import ImproperConfigurationError, MissingDependencyError
 from sqlspec.protocols import ObjectStoreProtocol
-from sqlspec.storage.capabilities import StorageCapabilities
 from sqlspec.typing import FSSPEC_INSTALLED, OBSTORE_INSTALLED
 
 __all__ = ("StorageRegistry", "storage_registry")
@@ -22,34 +21,52 @@ __all__ = ("StorageRegistry", "storage_registry")
 logger = logging.getLogger(__name__)
 
 
+def _is_local_uri(uri: str) -> bool:
+    """Check if URI represents a local filesystem path."""
+    if "://" in uri and not uri.startswith("file://"):
+        return False
+    windows_drive_min_length = 3
+    return (
+        Path(uri).exists()
+        or Path(uri).is_absolute()
+        or uri.startswith(("~", ".", "/"))
+        or (len(uri) >= windows_drive_min_length and uri[1:3] == ":\\")
+        or "/" in uri
+    )
+
+
 SCHEME_REGEX: Final = re.compile(r"([a-zA-Z0-9+.-]+)://")
-FILE_PROTOCOL: Final[str] = "file"
-S3_PROTOCOL: Final[str] = "s3"
-GCS_PROTOCOL: Final[str] = "gs"
-AZURE_PROTOCOL: Final[str] = "az"
+
+
 FSSPEC_ONLY_SCHEMES: Final[frozenset[str]] = frozenset({"http", "https", "ftp", "sftp", "ssh"})
 
 
 @mypyc_attr(allow_interpreted_subclasses=True)
 class StorageRegistry:
-    """Storage registry with URI-first access and automatic backend selection.
+    """Global storage registry for named backend configurations.
 
-    Provides URI-first access pattern with automatic backend selection.
-    Named aliases support complex configurations.
+    Allows registering named storage backends that can be accessed from anywhere
+    in your application. Backends are automatically selected based on URI scheme
+    unless explicitly overridden.
 
     Examples:
-        backend = registry.get("s3://my-bucket/file.parquet")
-        backend = registry.get("file:///tmp/data.csv")
-        backend = registry.get("gs://bucket/data.json")
-
-        registry.register_alias(
-            "production-s3",
-            uri="s3://prod-bucket/data",
-            base_path="sqlspec",
-            aws_access_key_id="...",
-            aws_secret_access_key="..."
-        )
-        backend = registry.get("production-s3")
+        # Direct URI access to storage containers
+        backend = registry.get("s3://my-bucket")
+        backend = registry.get("file:///tmp/data")
+        backend = registry.get("gs://my-gcs-bucket")
+
+        # Named store pattern for environment-specific backends
+        # Development
+        registry.register_alias("my_app_store", "file:///tmp/dev_data")
+
+        # Production
+        registry.register_alias("my_app_store", "s3://prod-bucket/data")
+
+        # Access from anywhere in your app
+        store = registry.get("my_app_store")  # Works in both environments
+
+        # Force specific backend when multiple options available
+        backend = registry.get("s3://bucket", backend="fsspec")  # Force fsspec over obstore
     """
 
     __slots__ = ("_alias_configs", "_aliases", "_cache", "_instances")
@@ -60,44 +77,47 @@ class StorageRegistry:
         self._instances: dict[Union[str, tuple[str, tuple[tuple[str, Any], ...]]], ObjectStoreProtocol] = {}
         self._cache: dict[str, tuple[str, type[ObjectStoreProtocol]]] = {}
 
+    def _make_hashable(self, obj: Any) -> Any:
+        """Convert nested dict/list structures to hashable tuples."""
+        if isinstance(obj, dict):
+            return tuple(sorted((k, self._make_hashable(v)) for k, v in obj.items()))
+        if isinstance(obj, list):
+            return tuple(self._make_hashable(item) for item in obj)
+        if isinstance(obj, set):
+            return tuple(sorted(self._make_hashable(item) for item in obj))
+        return obj
+
     def register_alias(
-        self,
-        alias: str,
-        uri: str,
-        *,
-        backend: Optional[type[ObjectStoreProtocol]] = None,
-        base_path: str = "",
-        config: Optional[dict[str, Any]] = None,
-        **kwargs: Any,
+        self, alias: str, uri: str, *, backend: Optional[str] = None, base_path: str = "", **kwargs: Any
     ) -> None:
         """Register a named alias for a storage configuration.
 
         Args:
-            alias: Unique alias name for the configuration
-            uri: Storage URI (e.g., "s3://bucket", "file:///path")
-            backend: Backend class to use (auto-detected from URI if not provided)
+            alias: Unique alias name (e.g., "my_app_store", "user_uploads")
+            uri: Storage URI (e.g., "s3://bucket", "file:///path", "gs://bucket")
+            backend: Force specific backend ("local", "fsspec", "obstore") instead of auto-detection
             base_path: Base path to prepend to all operations
-            config: Additional configuration dict
             **kwargs: Backend-specific configuration options
         """
-        if backend is None:
-            backend = self._determine_backend_class(uri)
+        backend_cls = self._get_backend_class(backend) if backend else self._determine_backend_class(uri)
 
-        config = config or {}
-        config.update(kwargs)
-        backend_config = dict(config)
+        backend_config = dict(kwargs)
         if base_path:
             backend_config["base_path"] = base_path
-        self._alias_configs[alias] = (backend, uri, backend_config)
+        self._alias_configs[alias] = (backend_cls, uri, backend_config)
+
         test_config = dict(backend_config)
         test_config["uri"] = uri
         self._aliases[alias] = test_config
 
-    def get(self, uri_or_alias: Union[str, Path], **kwargs: Any) -> ObjectStoreProtocol:
+    def get(
+        self, uri_or_alias: Union[str, Path], *, backend: Optional[str] = None, **kwargs: Any
+    ) -> ObjectStoreProtocol:
         """Get backend instance using URI-first routing with automatic backend selection.
 
         Args:
-            uri_or_alias: URI to resolve directly OR named alias
+            uri_or_alias: URI to resolve directly OR named alias (e.g., "my_app_store")
+            backend: Force specific backend ("local", "fsspec", "obstore") instead of auto-selection
             **kwargs: Additional backend-specific configuration options
 
         Returns:
@@ -113,24 +133,20 @@ class StorageRegistry:
         if isinstance(uri_or_alias, Path):
             uri_or_alias = f"file://{uri_or_alias.resolve()}"
 
-        cache_key = (uri_or_alias, tuple(sorted(kwargs.items()))) if kwargs else uri_or_alias
+        cache_key = (uri_or_alias, self._make_hashable(kwargs)) if kwargs else uri_or_alias
         if cache_key in self._instances:
             return self._instances[cache_key]
         scheme = self._get_scheme(uri_or_alias)
-        if not scheme and (
-            Path(uri_or_alias).exists()
-            or Path(uri_or_alias).is_absolute()
-            or uri_or_alias.startswith(("~", "."))
-            or ":\\" in uri_or_alias
-            or "/" in uri_or_alias
-        ):
+        if not scheme and _is_local_uri(uri_or_alias):
             scheme = "file"
             uri_or_alias = f"file://{uri_or_alias}"
 
         if scheme:
-            instance = self._resolve_from_uri(uri_or_alias, **kwargs)
+            instance = self._resolve_from_uri(uri_or_alias, backend_override=backend, **kwargs)
         elif uri_or_alias in self._alias_configs:
             backend_cls, stored_uri, config = self._alias_configs[uri_or_alias]
+            if backend:
+                backend_cls = self._get_backend_class(backend)
             instance = backend_cls(stored_uri, **{**config, **kwargs})
         else:
             msg = f"Unknown storage alias or invalid URI: '{uri_or_alias}'"
@@ -138,36 +154,66 @@ class StorageRegistry:
         self._instances[cache_key] = instance
         return instance
 
-    def _resolve_from_uri(self, uri: str, **kwargs: Any) -> ObjectStoreProtocol:
-        """Resolve backend from URI, trying ObStore first, then FSSpec."""
+    def _resolve_from_uri(
+        self, uri: str, *, backend_override: Optional[str] = None, **kwargs: Any
+    ) -> ObjectStoreProtocol:
+        """Resolve backend from URI with optional backend override."""
+        if backend_override:
+            return self._create_backend(backend_override, uri, **kwargs)
         scheme = self._get_scheme(uri)
+
+        # For local files, prefer LocalStore first
+        if scheme in {None, "file"}:
+            return self._create_backend("local", uri, **kwargs)
+
+        # Try ObStore first if available and appropriate
         if scheme not in FSSPEC_ONLY_SCHEMES and OBSTORE_INSTALLED:
             try:
                 return self._create_backend("obstore", uri, **kwargs)
             except (ValueError, ImportError, NotImplementedError):
                 pass
+
+        # Try FSSpec if available
         if FSSPEC_INSTALLED:
             try:
                 return self._create_backend("fsspec", uri, **kwargs)
             except (ValueError, ImportError, NotImplementedError):
                 pass
-        msg = "obstore"
-        raise MissingDependencyError(msg, "fsspec")
+
+        # For cloud schemes without backends, provide helpful error
+        msg = f"No backend available for URI scheme '{scheme}'. Install obstore or fsspec for cloud storage support."
+        raise MissingDependencyError(msg)
 
     def _determine_backend_class(self, uri: str) -> type[ObjectStoreProtocol]:
         """Determine the backend class for a URI based on availability."""
         scheme = self._get_scheme(uri)
+
+        # For local files, always use LocalStore
+        if scheme in {None, "file"}:
+            return self._get_backend_class("local")
+
+        # FSSpec-only schemes require FSSpec
         if scheme in FSSPEC_ONLY_SCHEMES and FSSPEC_INSTALLED:
             return self._get_backend_class("fsspec")
+
+        # Prefer ObStore for cloud storage if available
         if OBSTORE_INSTALLED:
             return self._get_backend_class("obstore")
+
+        # Fall back to FSSpec if available
         if FSSPEC_INSTALLED:
             return self._get_backend_class("fsspec")
-        msg = f"No backend available for URI scheme '{scheme}'. Install obstore or fsspec."
+
+        # For cloud schemes without backends, provide helpful error
+        msg = f"No backend available for URI scheme '{scheme}'. Install obstore or fsspec for cloud storage support."
         raise MissingDependencyError(msg)
 
     def _get_backend_class(self, backend_type: str) -> type[ObjectStoreProtocol]:
         """Get backend class by type name."""
+        if backend_type == "local":
+            from sqlspec.storage.backends.local import LocalStore
+
+            return cast("type[ObjectStoreProtocol]", LocalStore)
         if backend_type == "obstore":
             from sqlspec.storage.backends.obstore import ObStoreBackend
 
@@ -176,7 +222,7 @@ class StorageRegistry:
             from sqlspec.storage.backends.fsspec import FSSpecBackend
 
             return cast("type[ObjectStoreProtocol]", FSSpecBackend)
-        msg = f"Unknown backend type: {backend_type}. Supported types: 'obstore', 'fsspec'"
+        msg = f"Unknown backend type: {backend_type}. Supported types: 'local', 'obstore', 'fsspec'"
         raise ValueError(msg)
 
     def _create_backend(self, backend_type: str, uri: str, **kwargs: Any) -> ObjectStoreProtocol:
@@ -220,20 +266,5 @@ class StorageRegistry:
         self._alias_configs.clear()
         self._aliases.clear()
 
-    def get_backend_capabilities(self, uri_or_alias: Union[str, Path]) -> "StorageCapabilities":
-        """Get capabilities for a backend without creating an instance."""
-        if isinstance(uri_or_alias, Path):
-            uri_or_alias = f"file://{uri_or_alias.resolve()}"
-        if "://" in uri_or_alias:
-            backend_cls = self._determine_backend_class(uri_or_alias)
-        elif uri_or_alias in self._alias_configs:
-            backend_cls, _, _ = self._alias_configs[uri_or_alias]
-        else:
-            msg = f"Unknown storage alias or invalid URI: '{uri_or_alias}'"
-            raise ImproperConfigurationError(msg)
-        if hasattr(backend_cls, "capabilities"):
-            return backend_cls.capabilities
-        return StorageCapabilities()
-
 
 storage_registry = StorageRegistry()

sqlspec/utils/sync_tools.py

@@ -29,6 +29,13 @@ ParamSpecT = ParamSpec("ParamSpecT")
 T = TypeVar("T")
 
 
+class NoValue:
+    """Sentinel class for missing values."""
+
+
+NO_VALUE = NoValue()
+
+
 class CapacityLimiter:
     """Limits the number of concurrent operations using a semaphore."""
 
@@ -240,11 +247,7 @@ def with_ensure_async_(
     return obj
 
 
-class NoValue:
-    """Sentinel class for missing values."""
-
-
-async def get_next(iterable: Any, default: Any = NoValue, *args: Any) -> Any:  # pragma: no cover
+async def get_next(iterable: Any, default: Any = NO_VALUE, *args: Any) -> Any:  # pragma: no cover
     """Return the next item from an async iterator.
 
     Args:

{sqlspec-0.21.1.dist-info → sqlspec-0.22.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlspec
-Version: 0.21.1
+Version: 0.22.0
 Summary: SQL Experiments in Python
 Project-URL: Discord, https://discord.gg/litestar
 Project-URL: Issue, https://github.com/litestar-org/sqlspec/issues/

{sqlspec-0.21.1.dist-info → sqlspec-0.22.0.dist-info}/RECORD

@@ -4,12 +4,12 @@ sqlspec/__metadata__.py,sha256=IUw6MCTy1oeUJ1jAVYbuJLkOWbiAWorZ5W-E-SAD9N4,395
 sqlspec/_serialization.py,sha256=6U5-smk2h2yl0i6am2prtOLJTdu4NJQdcLlSfSUMaUQ,2590
 sqlspec/_sql.py,sha256=j9WljOgCme4jTfL6NegEWOhK-Rr3JEmhtbneh8ZN1bQ,45221
 sqlspec/_typing.py,sha256=jv-7QHGLrJLfnP86bR-Xcmj3PDoddNZEKDz_vYRBiAU,22684
-sqlspec/base.py,sha256=p3qX3nq1qPuLz6AEVizbZ4xpWhMoDXNc7zkPK9ecJac,25467
+sqlspec/base.py,sha256=koDh1AecwCAkntSqSda6J_cpMOLonXiV6hh3GCCXf_s,25459
 sqlspec/cli.py,sha256=Fe5Wbnrb_fkE9qm4gbBEXx3d0Q7VR-S-1t76ouAx2mg,20120
 sqlspec/config.py,sha256=PQKKLXst_uMvqvTSQib6qMZfJd-g3Kqqlp7XLn9kA8A,21640
 sqlspec/exceptions.py,sha256=zBnzQOfYAgqX04GoaC9Io6ardzinldkEuZ3YtR5vr9U,6071
-sqlspec/loader.py,sha256=R_lcI8Jg3Jh9jUDFvQyKbBzx20vKH50BKYt8gvTKq7c,23400
-sqlspec/protocols.py,sha256=Of6uJyxvawExCEyR3u7jbxOckUcwG0HHOEXmfHyev40,13106
+sqlspec/loader.py,sha256=4Gl4LcdVwEB6-4F-KiCnlI3nzyG3LVOFvRMAQNC64qE,23748
+sqlspec/protocols.py,sha256=jSO2OeZvywqkaIvLRFDkQajJvDlErCICipToUH3Mvoo,12996
 sqlspec/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sqlspec/typing.py,sha256=yj8D8O-pkfUVZDfVHEgQaB95-5alwgQbp_sqNJOVhvQ,6301
 sqlspec/adapters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -112,13 +112,13 @@ sqlspec/migrations/loaders.py,sha256=wildbpkyHrE--HXspChPOajSHSBUrfG0e6xQ2buze_4
 sqlspec/migrations/runner.py,sha256=y6fyZi02n8MseKR8XFWXUEOOYQNG_w_DikHVxH9p20M,10730
 sqlspec/migrations/tracker.py,sha256=hfrZGz8M70SfFniw4aXVtHNg4p8EPFm67vthjfUMUys,6843
 sqlspec/migrations/utils.py,sha256=Ft5mS1GFiRPLhfUTfPU4ZnEgOkXDnmEHjeeWwfZDcv4,3737
-sqlspec/storage/__init__.py,sha256=xWSsq5QXrY7wCsjQYPldfdlm8UEJ-kojU-tWsoldSy0,645
-sqlspec/storage/capabilities.py,sha256=vyousxls9jISsykgoybpNHlGWN6Hq_pKcsZ5DmKGWvU,3045
-sqlspec/storage/registry.py,sha256=4duy0uOupl0X5VNhwUeQMMWPsraKWyIdjDrKFsFcVG0,9424
-sqlspec/storage/backends/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sqlspec/storage/__init__.py,sha256=IX7xLuymGdQKOBQL1sNEA-bzZRJGjncUbQbs6ZToDDE,395
+sqlspec/storage/registry.py,sha256=yJZrLDu1vr86C6En3MlzCPOjUNYkvA5Ow-AKrLEDvpI,10754
+sqlspec/storage/backends/__init__.py,sha256=3oSqwEQ_trU2QoxtUTX-5IFeOvo7WGcESY6gIfcmSaE,24
 sqlspec/storage/backends/base.py,sha256=KS2JRZILoH_R_xsfKtYkqQ5a1r5OOBDSE5KbibTmhGY,5730
-sqlspec/storage/backends/fsspec.py,sha256=8AX8ULwlApMd6WtHDVJBomdvk5UjPtfMf78TJ86gTC8,15994
-sqlspec/storage/backends/obstore.py,sha256=v9moaiSVKbpl9MOrb9AAhhSXfQb1ifammrT8WeV1xcw,19735
+sqlspec/storage/backends/fsspec.py,sha256=5X3QhoaAddzMqkeTHs8M5RINj3mrHcnaIVWb8VhC4lQ,13582
+sqlspec/storage/backends/local.py,sha256=vsFnttNesNYjsY_l-KoH6rld51L3E6mxeODtMJawFPQ,12793
+sqlspec/storage/backends/obstore.py,sha256=4RUZAMCF16h1IQ4dEib-0j8TLnhPf0Jhy2lmRJSe7Kw,20512
 sqlspec/utils/__init__.py,sha256=cNFX26-bLyZTyTfujUitfDkUy1CeG_d-EIr8kZ0z4W8,474
 sqlspec/utils/correlation.py,sha256=2jvkAY3nkU3UxNU_9pbBR6cz3A1Q1cGG9IaWSSOIb1Q,4195
 sqlspec/utils/data_transformation.py,sha256=U37zyxR4f5PxsxKdC7QzcMyJxfqpsXUxgH_ch5l3PbY,3951
@@ -128,12 +128,12 @@ sqlspec/utils/logging.py,sha256=zAM7rHJ-KsmAj1yjvU9QFoiwf4Q2hKTere2J62FlllI,3664
 sqlspec/utils/module_loader.py,sha256=rO4ht-fUSJ3Us7L_7fb_G9bdMCoUSABGUA0pc3ouh9Y,2995
 sqlspec/utils/serializers.py,sha256=GXsTkJbWAhRS7xDMk6WBouZwPeG4sI_brLdMBlIetNg,318
 sqlspec/utils/singleton.py,sha256=-j-s6LS0pP_wTEUYIyK2wSdoeIE_tn7O7B-j7_aODRQ,1252
-sqlspec/utils/sync_tools.py,sha256=ksfxsvFb1hLrDlxzwdW44OvYgRB0Fr5JDqxswfHwoOs,8744
+sqlspec/utils/sync_tools.py,sha256=ONdhmx1Dq0_c6ReRaTlXzz6dVmAwz6CybCvsTUAVu1g,8768
 sqlspec/utils/text.py,sha256=ZqaXCVuUbdj_110pdTYjmAxfV3ZtR7J6EixuNazQLFY,3333
 sqlspec/utils/type_guards.py,sha256=ktXwBQLLqOvk1W2wJcmk3bUprrsegs8nAZ879qDe0AU,32880
-sqlspec-0.21.1.dist-info/METADATA,sha256=diZWPfeC58LVHYhjp1WTNH1JOPqkrJZLq3ZwdS5nKVU,23548
-sqlspec-0.21.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-sqlspec-0.21.1.dist-info/entry_points.txt,sha256=G-ZqY1Nuuw3Iys7nXw23f6ILenk_Lt47VdK2mhJCWHg,53
-sqlspec-0.21.1.dist-info/licenses/LICENSE,sha256=MdujfZ6l5HuLz4mElxlu049itenOR3gnhN1_Nd3nVcM,1078
-sqlspec-0.21.1.dist-info/licenses/NOTICE,sha256=Lyir8ozXWov7CyYS4huVaOCNrtgL17P-bNV-5daLntQ,1634
-sqlspec-0.21.1.dist-info/RECORD,,
+sqlspec-0.22.0.dist-info/METADATA,sha256=DZJrWaO7T5jLPe2GlL6M_MmKveqCb-oU1Awx3CDm6J0,23548
+sqlspec-0.22.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+sqlspec-0.22.0.dist-info/entry_points.txt,sha256=G-ZqY1Nuuw3Iys7nXw23f6ILenk_Lt47VdK2mhJCWHg,53
+sqlspec-0.22.0.dist-info/licenses/LICENSE,sha256=MdujfZ6l5HuLz4mElxlu049itenOR3gnhN1_Nd3nVcM,1078
+sqlspec-0.22.0.dist-info/licenses/NOTICE,sha256=Lyir8ozXWov7CyYS4huVaOCNrtgL17P-bNV-5daLntQ,1634
+sqlspec-0.22.0.dist-info/RECORD,,

sqlspec/storage/capabilities.py

@@ -1,102 +0,0 @@
-"""Storage backend capability system.
-
-This module provides a centralized way to track and query storage backend capabilities.
-"""
-
-from dataclasses import dataclass
-from typing import ClassVar
-
-from mypy_extensions import mypyc_attr
-
-__all__ = ("HasStorageCapabilities", "StorageCapabilities")
-
-
-@dataclass
-class StorageCapabilities:
-    """Tracks capabilities of a storage backend."""
-
-    supports_read: bool = True
-    supports_write: bool = True
-    supports_delete: bool = True
-    supports_list: bool = True
-    supports_exists: bool = True
-    supports_copy: bool = True
-    supports_move: bool = True
-    supports_metadata: bool = True
-
-    supports_arrow: bool = False
-    supports_streaming: bool = False
-    supports_async: bool = False
-    supports_batch_operations: bool = False
-    supports_multipart_upload: bool = False
-    supports_compression: bool = False
-
-    supports_s3_select: bool = False
-    supports_gcs_compose: bool = False
-    supports_azure_snapshots: bool = False
-
-    is_remote: bool = True
-    is_cloud_native: bool = False
-    has_low_latency: bool = False
-
-    @classmethod
-    def local_filesystem(cls) -> "StorageCapabilities":
-        """Capabilities for local filesystem backend."""
-        return cls(
-            is_remote=False, has_low_latency=True, supports_arrow=True, supports_streaming=True, supports_async=True
-        )
-
-    @classmethod
-    def s3_compatible(cls) -> "StorageCapabilities":
-        """Capabilities for S3-compatible backends."""
-        return cls(
-            is_cloud_native=True,
-            supports_multipart_upload=True,
-            supports_s3_select=True,
-            supports_arrow=True,
-            supports_streaming=True,
-            supports_async=True,
-        )
-
-    @classmethod
-    def gcs(cls) -> "StorageCapabilities":
-        """Capabilities for Google Cloud Storage."""
-        return cls(
-            is_cloud_native=True,
-            supports_multipart_upload=True,
-            supports_gcs_compose=True,
-            supports_arrow=True,
-            supports_streaming=True,
-            supports_async=True,
-        )
-
-    @classmethod
-    def azure_blob(cls) -> "StorageCapabilities":
-        """Capabilities for Azure Blob Storage."""
-        return cls(
-            is_cloud_native=True,
-            supports_multipart_upload=True,
-            supports_azure_snapshots=True,
-            supports_arrow=True,
-            supports_streaming=True,
-            supports_async=True,
-        )
-
-
-@mypyc_attr(allow_interpreted_subclasses=True)
-class HasStorageCapabilities:
-    """Mixin for storage backends that expose their capabilities."""
-
-    __slots__ = ()
-
-    capabilities: ClassVar[StorageCapabilities]
-
-    @classmethod
-    def has_capability(cls, capability: str) -> bool:
-        """Check if backend has a specific capability."""
-        return getattr(cls.capabilities, capability, False)
-
-    @classmethod
-    def get_capabilities(cls) -> StorageCapabilities:
-        """Get all capabilities for this backend."""
-        return cls.capabilities