sqlspec 0.21.0__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/data_transformation.py

@@ -0,0 +1,120 @@
+"""Data transformation utilities for SQLSpec.
+
+Provides functions for transforming data structures, particularly for
+field name conversion when mapping database results to schema objects.
+Used primarily for msgspec field name conversion with rename configurations.
+"""
+
+from typing import Any, Callable, Union
+
+__all__ = ("transform_dict_keys",)
+
+
+def _safe_convert_key(key: Any, converter: Callable[[str], str]) -> Any:
+    """Safely convert a key using the converter function.
+
+    Args:
+        key: Key to convert (may not be a string).
+        converter: Function to convert string keys.
+
+    Returns:
+        Converted key if conversion succeeds, original key otherwise.
+    """
+    if not isinstance(key, str):
+        return key
+
+    try:
+        return converter(key)
+    except (TypeError, ValueError, AttributeError):
+        # If conversion fails, return the original key
+        return key
+
+
+def transform_dict_keys(data: Union[dict, list, Any], converter: Callable[[str], str]) -> Union[dict, list, Any]:
+    """Transform dictionary keys using the provided converter function.
+
+    Recursively transforms all dictionary keys in a data structure using
+    the provided converter function. Handles nested dictionaries, lists
+    of dictionaries, and preserves non-dict values unchanged.
+
+    Args:
+        data: The data structure to transform. Can be a dict, list, or any other type.
+        converter: Function to convert string keys (e.g., camelize, kebabize).
+
+    Returns:
+        The transformed data structure with converted keys. Non-dict values
+        are returned unchanged.
+
+    Examples:
+        Transform snake_case keys to camelCase:
+
+        >>> from sqlspec.utils.text import camelize
+        >>> data = {"user_id": 123, "created_at": "2024-01-01"}
+        >>> transform_dict_keys(data, camelize)
+        {"userId": 123, "createdAt": "2024-01-01"}
+
+        Transform nested structures:
+
+        >>> nested = {
+        ...     "user_data": {"first_name": "John", "last_name": "Doe"},
+        ...     "order_items": [
+        ...         {"item_id": 1, "item_name": "Product A"},
+        ...         {"item_id": 2, "item_name": "Product B"},
+        ...     ],
+        ... }
+        >>> transform_dict_keys(nested, camelize)
+        {
+            "userData": {
+                "firstName": "John",
+                "lastName": "Doe"
+            },
+            "orderItems": [
+                {"itemId": 1, "itemName": "Product A"},
+                {"itemId": 2, "itemName": "Product B"}
+            ]
+        }
+    """
+    if isinstance(data, dict):
+        return _transform_dict(data, converter)
+    if isinstance(data, list):
+        return _transform_list(data, converter)
+    return data
+
+
+def _transform_dict(data: dict, converter: Callable[[str], str]) -> dict:
+    """Transform a dictionary's keys recursively.
+
+    Args:
+        data: Dictionary to transform.
+        converter: Function to convert string keys.
+
+    Returns:
+        Dictionary with transformed keys and recursively transformed values.
+    """
+    transformed = {}
+
+    for key, value in data.items():
+        # Convert the key using the provided converter function
+        # Use safe conversion that handles edge cases without try-except
+        converted_key = _safe_convert_key(key, converter)
+
+        # Recursively transform the value
+        transformed_value = transform_dict_keys(value, converter)
+
+        transformed[converted_key] = transformed_value
+
+    return transformed
+
+
+def _transform_list(data: list, converter: Callable[[str], str]) -> list:
+    """Transform a list's elements recursively.
+
+    Args:
+        data: List to transform.
+        converter: Function to convert string keys in nested structures.
+
+    Returns:
+        List with recursively transformed elements.
+    """
+    # Use list comprehension for better performance and avoid try-except in loop
+    return [transform_dict_keys(item, converter) for item in data]

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/utils/text.py

@@ -19,25 +19,7 @@ _SNAKE_CASE_HYPHEN_SPACE = re.compile(r"[.\s@-]+", re.UNICODE)
 _SNAKE_CASE_REMOVE_NON_WORD = re.compile(r"[^\w]+", re.UNICODE)
 _SNAKE_CASE_MULTIPLE_UNDERSCORES = re.compile(r"__+", re.UNICODE)
 
-__all__ = ("camelize", "check_email", "slugify", "snake_case")
-
-
-def check_email(email: str) -> str:
-    """Validate an email address.
-
-    Args:
-        email: The email to validate.
-
-    Raises:
-        ValueError: If the email is invalid.
-
-    Returns:
-        The validated email.
-    """
-    if "@" not in email:
-        msg = "Invalid email!"
-        raise ValueError(msg)
-    return email.lower()
+__all__ = ("camelize", "kebabize", "pascalize", "slugify", "snake_case")
 
 
 def slugify(value: str, allow_unicode: bool = False, separator: Optional[str] = None) -> str:
@@ -80,6 +62,32 @@ def camelize(string: str) -> str:
     return "".join(word if index == 0 else word.capitalize() for index, word in enumerate(string.split("_")))
 
 
+@lru_cache(maxsize=100)
+def kebabize(string: str) -> str:
+    """Convert a string to kebab-case.
+
+    Args:
+        string: The string to convert.
+
+    Returns:
+        The kebab-case version of the string.
+    """
+    return "-".join(word.lower() for word in string.split("_") if word)
+
+
+@lru_cache(maxsize=100)
+def pascalize(string: str) -> str:
+    """Convert a string to PascalCase.
+
+    Args:
+        string: The string to convert.
+
+    Returns:
+        The PascalCase version of the string.
+    """
+    return "".join(word.capitalize() for word in string.split("_") if word)
+
+
 @lru_cache(maxsize=100)
 def snake_case(string: str) -> str:
     """Convert a string to snake_case.

sqlspec/utils/type_guards.py

@@ -6,6 +6,7 @@ understand type narrowing, replacing defensive hasattr() and duck typing pattern
 
 from collections.abc import Sequence
 from collections.abc import Set as AbstractSet
+from functools import lru_cache
 from typing import TYPE_CHECKING, Any, Optional, Union, cast
 
 from sqlspec.typing import (
@@ -59,6 +60,7 @@ __all__ = (
     "extract_dataclass_items",
     "get_initial_expression",
     "get_literal_parent",
+    "get_msgspec_rename_config",
     "get_node_expressions",
     "get_node_this",
     "get_param_style_and_name",
@@ -429,6 +431,78 @@ def is_msgspec_struct_without_field(obj: Any, field_name: str) -> "TypeGuard[Str
     return False
 
 
+@lru_cache(maxsize=500)
+def _detect_rename_pattern(field_name: str, encode_name: str) -> "Optional[str]":
+    """Detect the rename pattern by comparing field name transformations.
+
+    Args:
+        field_name: Original field name (e.g., "user_id")
+        encode_name: Encoded field name (e.g., "userId")
+
+    Returns:
+        The detected rename pattern ("camel", "kebab", "pascal") or None
+    """
+    from sqlspec.utils.text import camelize, kebabize, pascalize
+
+    # Test camelCase conversion
+    if encode_name == camelize(field_name) and encode_name != field_name:
+        return "camel"
+
+    if encode_name == kebabize(field_name) and encode_name != field_name:
+        return "kebab"
+
+    if encode_name == pascalize(field_name) and encode_name != field_name:
+        return "pascal"
+    return None
+
+
+def get_msgspec_rename_config(schema_type: type) -> "Optional[str]":
+    """Extract msgspec rename configuration from a struct type.
+
+    Analyzes field name transformations to detect the rename pattern used by msgspec.
+    Since msgspec doesn't store the original rename parameter directly, we infer it
+    by comparing field names with their encode_name values.
+
+    Args:
+        schema_type: The msgspec struct type to inspect.
+
+    Returns:
+        The rename configuration value ("camel", "kebab", "pascal", etc.) if detected,
+        None if no rename configuration exists or if not a msgspec struct.
+
+    Examples:
+        >>> class User(msgspec.Struct, rename="camel"):
+        ...     user_id: int
+        >>> get_msgspec_rename_config(User)
+        "camel"
+
+        >>> class Product(msgspec.Struct):
+        ...     product_id: int
+        >>> get_msgspec_rename_config(Product)
+        None
+    """
+    if not MSGSPEC_INSTALLED:
+        return None
+
+    if not is_msgspec_struct(schema_type):
+        return None
+
+    from msgspec import structs
+
+    fields = structs.fields(schema_type)  # type: ignore[arg-type]
+    if not fields:
+        return None
+
+    # Check if any field name differs from its encode_name
+    for field in fields:
+        if field.name != field.encode_name:
+            # Detect the rename pattern by comparing transformations
+            return _detect_rename_pattern(field.name, field.encode_name)
+
+    # If all field names match their encode_name, no rename is applied
+    return None
+
+
 def is_attrs_instance(obj: Any) -> "TypeGuard[AttrsInstanceStub]":
     """Check if a value is an attrs class instance.
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlspec
-Version: 0.21.0
+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.0.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
@@ -93,7 +93,7 @@ sqlspec/driver/_async.py,sha256=aS5AwY5IYqnVT8ldDLDwz2AMDN94CI9hfsOz-1k-Nus,1899
 sqlspec/driver/_common.py,sha256=Fi5NCy5_OVlRKDzUpGsLJn3zDmrsVSsXggMRndIMM1E,23879
 sqlspec/driver/_sync.py,sha256=wCBV9QfAH8BPjrrVCQc2eM90ai5-FYbKDd81L5sZMS0,18767
 sqlspec/driver/mixins/__init__.py,sha256=gN4pQyJXxNy0xi91dcMJGA7DQ7TbjGjQI24SSpZc6Go,248
-sqlspec/driver/mixins/_result_tools.py,sha256=fDr1sca6jmeZ8EwTamPhlAh_XnK9moIpWD8Q3ZcEhRM,7103
+sqlspec/driver/mixins/_result_tools.py,sha256=0LquMpoLBJrqkxaAPU4Wvn2JElyqdwRAnRlwGTX-D7w,8603
 sqlspec/driver/mixins/_sql_translator.py,sha256=TACtUUJdx8tJwuq_7g3AR_k0bKokvuJrMEwINyWwdQM,3711
 sqlspec/extensions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sqlspec/extensions/aiosql/__init__.py,sha256=-9cefc9pYPf9vCgALoB-y1DtmcgRjKe2azfl6RIarAA,414
@@ -112,27 +112,28 @@ 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
 sqlspec/utils/deprecation.py,sha256=iy7xzws6Kx0oQpX94smyZzTY6ijdODrdSEFFEXZfp5o,3980
 sqlspec/utils/fixtures.py,sha256=qnPAdkV91dyKOqslm_TH5UZ8mx4koQMwriE5YPn3PgI,9425
 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/text.py,sha256=W97aX77A3NzG795AHjhdX6zqOBDmvLaXLCno2JIugCo,3081
-sqlspec/utils/type_guards.py,sha256=9C4SRebO4JiQrMzcJZFUA0KjSU48G26RmX6lbijyjBg,30476
-sqlspec-0.21.0.dist-info/METADATA,sha256=_mWB33isyFUYPN30oshULbI5KPKA4ztOiY4OoSsnIR8,23548
-sqlspec-0.21.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-sqlspec-0.21.0.dist-info/entry_points.txt,sha256=G-ZqY1Nuuw3Iys7nXw23f6ILenk_Lt47VdK2mhJCWHg,53
-sqlspec-0.21.0.dist-info/licenses/LICENSE,sha256=MdujfZ6l5HuLz4mElxlu049itenOR3gnhN1_Nd3nVcM,1078
-sqlspec-0.21.0.dist-info/licenses/NOTICE,sha256=Lyir8ozXWov7CyYS4huVaOCNrtgL17P-bNV-5daLntQ,1634
-sqlspec-0.21.0.dist-info/RECORD,,
+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.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,,