sqlspec 0.3.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

sqlspec/_typing.py

@@ -5,15 +5,26 @@ This is used to ensure compatibility when one or more of the libraries are insta
 
 from __future__ import annotations
 
+from enum import Enum
 from typing import (
     Any,
     ClassVar,
+    Final,
     Protocol,
+    Union,
     cast,
     runtime_checkable,
 )
 
-from typing_extensions import TypeVar, dataclass_transform
+from typing_extensions import Literal, TypeVar, dataclass_transform
+
+
+@runtime_checkable
+class DataclassProtocol(Protocol):
+    """Protocol for instance checking dataclasses."""
+
+    __dataclass_fields__: ClassVar[dict[str, Any]]
+
 
 T = TypeVar("T")
 T_co = TypeVar("T_co", covariant=True)
@@ -99,11 +110,26 @@ except ImportError:
     UNSET = UnsetType.UNSET  # pyright: ignore[reportConstantRedefinition]
     MSGSPEC_INSTALLED = False  # pyright: ignore[reportConstantRedefinition]
 
+
+class EmptyEnum(Enum):
+    """A sentinel enum used as placeholder."""
+
+    EMPTY = 0
+
+
+EmptyType = Union[Literal[EmptyEnum.EMPTY], UnsetType]
+Empty: Final = EmptyEnum.EMPTY
+
+
 __all__ = (
     "MSGSPEC_INSTALLED",
     "PYDANTIC_INSTALLED",
     "UNSET",
     "BaseModel",
+    "DataclassProtocol",
+    "Empty",
+    "EmptyEnum",
+    "EmptyType",
     "FailFast",
     "Struct",
     "TypeAdapter",

sqlspec/adapters/adbc/config.py

@@ -5,7 +5,7 @@ from dataclasses import dataclass
 from typing import TYPE_CHECKING, TypeVar
 
 from sqlspec.config import GenericDatabaseConfig
-from sqlspec.utils.empty import Empty
+from sqlspec.typing import Empty, EmptyType
 
 if TYPE_CHECKING:
     from collections.abc import Generator
@@ -13,8 +13,6 @@ if TYPE_CHECKING:
 
     from adbc_driver_manager.dbapi import Connection, Cursor
 
-    from sqlspec.utils.empty import EmptyType
-
 __all__ = ("AdbcDatabaseConfig",)
 
 ConnectionT = TypeVar("ConnectionT", bound="Connection")

sqlspec/adapters/aiosqlite/config.py

@@ -6,8 +6,7 @@ from typing import TYPE_CHECKING, Any
 
 from sqlspec.config import GenericDatabaseConfig
 from sqlspec.exceptions import ImproperConfigurationError
-from sqlspec.utils.dataclass import simple_asdict
-from sqlspec.utils.empty import Empty, EmptyType
+from sqlspec.typing import Empty, EmptyType, dataclass_to_dict
 
 if TYPE_CHECKING:
     from collections.abc import AsyncGenerator
@@ -60,7 +59,7 @@ class AiosqliteConfig(GenericDatabaseConfig):
         Returns:
             A string keyed dict of config kwargs for the aiosqlite.connect() function.
         """
-        return simple_asdict(self, exclude_empty=True, convert_nested=False)
+        return dataclass_to_dict(self, exclude_empty=True, convert_nested=False)
 
     async def create_connection(self) -> Connection:
         """Create and return a new database connection.
@@ -79,22 +78,6 @@ class AiosqliteConfig(GenericDatabaseConfig):
             msg = f"Could not configure the Aiosqlite connection. Error: {e!s}"
             raise ImproperConfigurationError(msg) from e
 
-    @asynccontextmanager
-    async def lifespan(self, *args: Any, **kwargs: Any) -> AsyncGenerator[None, None]:
-        """Manage the lifecycle of a database connection.
-
-        Yields:
-            None
-
-        Raises:
-            ImproperConfigurationError: If the connection could not be established.
-        """
-        connection = await self.create_connection()
-        try:
-            yield
-        finally:
-            await connection.close()
-
     @asynccontextmanager
     async def provide_connection(self, *args: Any, **kwargs: Any) -> AsyncGenerator[Connection, None]:
         """Create and provide a database connection.

sqlspec/adapters/asyncmy/config.py

@@ -5,8 +5,7 @@ from dataclasses import dataclass
 from typing import TYPE_CHECKING, TypeVar
 
 from sqlspec.exceptions import ImproperConfigurationError
-from sqlspec.utils.dataclass import simple_asdict
-from sqlspec.utils.empty import Empty, EmptyType
+from sqlspec.typing import Empty, EmptyType, dataclass_to_dict
 
 if TYPE_CHECKING:
     from collections.abc import AsyncGenerator
@@ -101,7 +100,7 @@ class AsyncmyPoolConfig:
         Returns:
             A string keyed dict of config kwargs for the Asyncmy create_pool function.
         """
-        return simple_asdict(self, exclude_empty=True, convert_nested=False)
+        return dataclass_to_dict(self, exclude_empty=True, convert_nested=False)
 
 
 @dataclass
@@ -125,7 +124,7 @@ class AsyncMyConfig:
             A string keyed dict of config kwargs for the Asyncmy create_pool function.
         """
         if self.pool_config:
-            return simple_asdict(self.pool_config, exclude_empty=True, convert_nested=False)
+            return dataclass_to_dict(self.pool_config, exclude_empty=True, convert_nested=False)
         msg = "'pool_config' methods can not be used when a 'pool_instance' is provided."
         raise ImproperConfigurationError(msg)
 
@@ -162,23 +161,6 @@ class AsyncMyConfig:
         """
         return await self.create_pool()
 
-    @asynccontextmanager
-    async def lifespan(self, *args: Any, **kwargs: Any) -> AsyncGenerator[None, None]:
-        """Manage the lifecycle of a database connection pool.
-
-        Yields:
-            None
-
-        Raises:
-            ImproperConfigurationError: If the pool could not be established.
-        """
-        pool = await self.create_pool()
-        try:
-            yield
-        finally:
-            pool.close()
-            await pool.wait_closed()
-
     @asynccontextmanager
     async def provide_connection(self, *args: Any, **kwargs: Any) -> AsyncGenerator[Connection, None]:
         """Create and provide a database connection.

sqlspec/adapters/asyncpg/config.py

@@ -10,8 +10,7 @@ from asyncpg import create_pool as asyncpg_create_pool
 from sqlspec._serialization import decode_json, encode_json
 from sqlspec.config import GenericDatabaseConfig, GenericPoolConfig
 from sqlspec.exceptions import ImproperConfigurationError
-from sqlspec.utils.dataclass import simple_asdict
-from sqlspec.utils.empty import Empty, EmptyType
+from sqlspec.typing import Empty, EmptyType, dataclass_to_dict
 
 if TYPE_CHECKING:
     from asyncio import AbstractEventLoop
@@ -98,7 +97,7 @@ class AsyncPgConfig(GenericDatabaseConfig):
             function.
         """
         if self.pool_config:
-            return simple_asdict(self.pool_config, exclude_empty=True, convert_nested=False)
+            return dataclass_to_dict(self.pool_config, exclude_empty=True, convert_nested=False)
         msg = "'pool_config' methods can not be used when a 'pool_instance' is provided."
         raise ImproperConfigurationError(msg)
 
@@ -124,16 +123,7 @@ class AsyncPgConfig(GenericDatabaseConfig):
             )
         return self.pool_instance
 
-    @asynccontextmanager
-    async def lifespan(self, *args: Any, **kwargs) -> AsyncGenerator[None, None]:
-        db_pool = await self.create_pool()
-        try:
-            yield
-        finally:
-            db_pool.terminate()
-            await db_pool.close()
-
-    def provide_pool(self, *args: Any, **kwargs) -> Awaitable[Pool]:
+    def provide_pool(self, *args: Any, **kwargs: Any) -> Awaitable[Pool]:
         """Create a pool instance.
 
         Returns:

sqlspec/adapters/duckdb/config.py

@@ -2,19 +2,66 @@ from __future__ import annotations
 
 from contextlib import contextmanager
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, cast
 
 from sqlspec.config import GenericDatabaseConfig
 from sqlspec.exceptions import ImproperConfigurationError
-from sqlspec.utils.dataclass import simple_asdict
-from sqlspec.utils.empty import Empty, EmptyType
+from sqlspec.typing import Empty, EmptyType, dataclass_to_dict
 
 if TYPE_CHECKING:
-    from collections.abc import Generator
+    from collections.abc import Generator, Sequence
 
     from duckdb import DuckDBPyConnection
 
-__all__ = ("DuckDBConfig",)
+__all__ = ("DuckDBConfig", "ExtensionConfig")
+
+
+@dataclass
+class ExtensionConfig:
+    """Configuration for a DuckDB extension.
+
+    This class provides configuration options for DuckDB extensions, including installation
+    and post-install configuration settings.
+
+    Args:
+        name: The name of the extension to install
+        config: Optional configuration settings to apply after installation
+        force_install: Whether to force reinstall if already present
+        repository: Optional repository name to install from
+        repository_url: Optional repository URL to install from
+        version: Optional version of the extension to install
+    """
+
+    name: str
+    config: dict[str, Any] | None = None
+    force_install: bool = False
+    repository: str | None = None
+    repository_url: str | None = None
+    version: str | None = None
+
+    @classmethod
+    def from_dict(cls, name: str, config: dict[str, Any] | bool | None = None) -> ExtensionConfig:
+        """Create an ExtensionConfig from a configuration dictionary.
+
+        Args:
+            name: The name of the extension
+            config: Configuration dictionary that may contain settings
+
+        Returns:
+            A new ExtensionConfig instance
+        """
+        if config is None:
+            return cls(name=name)
+
+        if not isinstance(config, dict):
+            config = {"force_install": bool(config)}
+
+        install_args = {
+            key: config.pop(key)
+            for key in ["force_install", "repository", "repository_url", "version", "config", "name"]
+            if key in config
+        }
+        return cls(name=name, **install_args)
 
 
 @dataclass
@@ -39,6 +86,73 @@ class DuckDBConfig(GenericDatabaseConfig):
     For details see: https://duckdb.org/docs/api/python/overview#connection-options
     """
 
+    extensions: Sequence[ExtensionConfig] | EmptyType = Empty
+    """A sequence of extension configurations to install and configure upon connection creation."""
+
+    def __post_init__(self) -> None:
+        """Post-initialization validation and processing.
+
+        This method handles merging extension configurations from both the extensions field
+        and the config dictionary, if present. The config['extensions'] field can be either:
+        - A dictionary mapping extension names to their configurations
+        - A list of extension names (which will be installed with force_install=True)
+
+        Raises:
+            ImproperConfigurationError: If there are duplicate extension configurations.
+        """
+        if self.config is Empty:
+            self.config = {}
+
+        if self.extensions is Empty:
+            self.extensions = []
+        # this is purely for mypy
+        assert isinstance(self.config, dict)  # noqa: S101
+        assert isinstance(self.extensions, list)  # noqa: S101
+
+        _e = self.config.pop("extensions", {})
+        if not isinstance(_e, (dict, list, tuple)):
+            msg = "When configuring extensions in the 'config' dictionary, the value must be a dictionary or sequence of extension names"
+            raise ImproperConfigurationError(msg)
+        if not isinstance(_e, dict):
+            _e = {str(ext): {"force_install": False} for ext in _e}
+
+        if len(set(_e.keys()).intersection({ext.name for ext in self.extensions})) > 0:
+            msg = "Configuring the same extension in both 'extensions' and as a key in 'config['extensions']' is not allowed"
+            raise ImproperConfigurationError(msg)
+
+        self.extensions.extend([ExtensionConfig.from_dict(name, ext_config) for name, ext_config in _e.items()])
+
+    def _configure_extensions(self, connection: DuckDBPyConnection) -> None:
+        """Configure extensions for the connection.
+
+        Args:
+            connection: The DuckDB connection to configure extensions for.
+
+        Raises:
+            ImproperConfigurationError: If extension installation or configuration fails.
+        """
+        if self.extensions is Empty:
+            return
+
+        for extension in cast("list[ExtensionConfig]", self.extensions):
+            try:
+                if extension.force_install:
+                    connection.install_extension(
+                        extension=extension.name,
+                        force_install=extension.force_install,
+                        repository=extension.repository,
+                        repository_url=extension.repository_url,
+                        version=extension.version,
+                    )
+                connection.load_extension(extension.name)
+
+                if extension.config:
+                    for key, value in extension.config.items():
+                        connection.execute(f"SET {key}={value}")
+            except Exception as e:
+                msg = f"Failed to configure extension {extension.name}. Error: {e!s}"
+                raise ImproperConfigurationError(msg) from e
+
     @property
     def connection_config_dict(self) -> dict[str, Any]:
         """Return the connection configuration as a dict.
@@ -46,44 +160,30 @@ class DuckDBConfig(GenericDatabaseConfig):
         Returns:
             A string keyed dict of config kwargs for the duckdb.connect() function.
         """
-        config = simple_asdict(self, exclude_empty=True, convert_nested=False)
+        config = dataclass_to_dict(self, exclude_empty=True, exclude={"extensions"}, convert_nested=False)
         if not config.get("database"):
             config["database"] = ":memory:"
         return config
 
     def create_connection(self) -> DuckDBPyConnection:
-        """Create and return a new database connection.
+        """Create and return a new database connection with configured extensions.
 
         Returns:
-            A new DuckDB connection instance.
+            A new DuckDB connection instance with extensions installed and configured.
 
         Raises:
-            ImproperConfigurationError: If the connection could not be established.
+            ImproperConfigurationError: If the connection could not be established or extensions could not be configured.
         """
         import duckdb
 
         try:
-            return duckdb.connect(**self.connection_config_dict)
+            connection = duckdb.connect(**self.connection_config_dict)
+            self._configure_extensions(connection)
+            return connection
         except Exception as e:
             msg = f"Could not configure the DuckDB connection. Error: {e!s}"
             raise ImproperConfigurationError(msg) from e
 
-    @contextmanager
-    def lifespan(self, *args: Any, **kwargs: Any) -> Generator[None, None, None]:
-        """Manage the lifecycle of a database connection.
-
-        Yields:
-            None
-
-        Raises:
-            ImproperConfigurationError: If the connection could not be established.
-        """
-        connection = self.create_connection()
-        try:
-            yield
-        finally:
-            connection.close()
-
     @contextmanager
     def provide_connection(self, *args: Any, **kwargs: Any) -> Generator[DuckDBPyConnection, None, None]:
         """Create and provide a database connection.

sqlspec/adapters/oracledb/config/_asyncio.py

@@ -13,7 +13,7 @@ from sqlspec.adapters.oracledb.config._common import (
     OracleGenericPoolConfig,
 )
 from sqlspec.exceptions import ImproperConfigurationError
-from sqlspec.utils.dataclass import simple_asdict
+from sqlspec.typing import dataclass_to_dict
 
 if TYPE_CHECKING:
     from collections.abc import AsyncGenerator, Awaitable
@@ -36,6 +36,11 @@ class OracleAsyncDatabaseConfig(OracleGenericDatabaseConfig[AsyncConnectionPool,
 
     pool_config: OracleAsyncPoolConfig | None = None
     """Oracle Pool configuration"""
+    pool_instance: AsyncConnectionPool | None = None
+    """Optional pool to use.
+
+    If set, the plugin will use the provided pool rather than instantiate one.
+    """
 
     @property
     def pool_config_dict(self) -> dict[str, Any]:
@@ -46,7 +51,7 @@ class OracleAsyncDatabaseConfig(OracleGenericDatabaseConfig[AsyncConnectionPool,
             function.
         """
         if self.pool_config is not None:
-            return simple_asdict(self.pool_config, exclude_empty=True, convert_nested=False)
+            return dataclass_to_dict(self.pool_config, exclude_empty=True, convert_nested=False)
         msg = "'pool_config' methods can not be used when a 'pool_instance' is provided."
         raise ImproperConfigurationError(msg)
 
@@ -70,15 +75,7 @@ class OracleAsyncDatabaseConfig(OracleGenericDatabaseConfig[AsyncConnectionPool,
             raise ImproperConfigurationError(msg)
         return self.pool_instance
 
-    @asynccontextmanager
-    async def lifespan(self, *args: Any, **kwargs) -> AsyncGenerator[None, None]:
-        db_pool = await self.create_pool()
-        try:
-            yield
-        finally:
-            await db_pool.close(force=True)
-
-    def provide_pool(self, *args: Any, **kwargs) -> Awaitable[AsyncConnectionPool]:
+    def provide_pool(self, *args: Any, **kwargs: Any) -> Awaitable[AsyncConnectionPool]:
         """Create a pool instance.
 
         Returns:

sqlspec/adapters/oracledb/config/_common.py

@@ -6,7 +6,7 @@ from typing import TYPE_CHECKING, Generic, TypeVar
 from oracledb import ConnectionPool
 
 from sqlspec.config import GenericDatabaseConfig, GenericPoolConfig
-from sqlspec.utils.empty import Empty
+from sqlspec.typing import Empty
 
 if TYPE_CHECKING:
     import ssl
@@ -17,7 +17,7 @@ if TYPE_CHECKING:
     from oracledb.connection import AsyncConnection, Connection
     from oracledb.pool import AsyncConnectionPool, ConnectionPool
 
-    from sqlspec.utils.empty import EmptyType
+    from sqlspec.typing import EmptyType
 
 __all__ = (
     "OracleGenericDatabaseConfig",

sqlspec/adapters/oracledb/config/_sync.py

@@ -13,7 +13,7 @@ from sqlspec.adapters.oracledb.config._common import (
     OracleGenericPoolConfig,
 )
 from sqlspec.exceptions import ImproperConfigurationError
-from sqlspec.utils.dataclass import simple_asdict
+from sqlspec.typing import dataclass_to_dict
 
 if TYPE_CHECKING:
     from collections.abc import Generator
@@ -51,7 +51,7 @@ class OracleSyncDatabaseConfig(OracleGenericDatabaseConfig[ConnectionPool, Conne
             function.
         """
         if self.pool_config:
-            return simple_asdict(self.pool_config, exclude_empty=True, convert_nested=False)
+            return dataclass_to_dict(self.pool_config, exclude_empty=True, convert_nested=False)
         msg = "'pool_config' methods can not be used when a 'pool_instance' is provided."
         raise ImproperConfigurationError(msg)
 
@@ -75,13 +75,6 @@ class OracleSyncDatabaseConfig(OracleGenericDatabaseConfig[ConnectionPool, Conne
             raise ImproperConfigurationError(msg)
         return self.pool_instance
 
-    def lifespan(self, *args: Any, **kwargs: Any) -> Generator[None, None, None]:
-        db_pool = self.create_pool()
-        try:
-            yield
-        finally:
-            db_pool.close()
-
     def provide_pool(self, *args: Any, **kwargs: Any) -> ConnectionPool:
         """Create a pool instance.
 

sqlspec/adapters/psycopg/config/_async.py

@@ -12,7 +12,7 @@ from sqlspec.adapters.psycopg.config._common import (
     PsycoPgGenericPoolConfig,
 )
 from sqlspec.exceptions import ImproperConfigurationError
-from sqlspec.utils.dataclass import simple_asdict
+from sqlspec.typing import dataclass_to_dict
 
 if TYPE_CHECKING:
     from collections.abc import AsyncGenerator, Awaitable
@@ -43,7 +43,7 @@ class PsycoPgAsyncDatabaseConfig(PsycoPgGenericDatabaseConfig[AsyncConnectionPoo
     def pool_config_dict(self) -> dict[str, Any]:
         """Return the pool configuration as a dict."""
         if self.pool_config:
-            return simple_asdict(self.pool_config, exclude_empty=True, convert_nested=False)
+            return dataclass_to_dict(self.pool_config, exclude_empty=True, convert_nested=False)
         msg = "'pool_config' methods can not be used when a 'pool_instance' is provided."
         raise ImproperConfigurationError(msg)
 
@@ -63,15 +63,6 @@ class PsycoPgAsyncDatabaseConfig(PsycoPgGenericDatabaseConfig[AsyncConnectionPoo
             raise ImproperConfigurationError(msg)
         return self.pool_instance
 
-    @asynccontextmanager
-    async def lifespan(self, *args: Any, **kwargs: Any) -> AsyncGenerator[None, None]:
-        """Manage the lifecycle of the connection pool."""
-        pool = await self.create_pool()
-        try:
-            yield
-        finally:
-            await pool.close()
-
     def provide_pool(self, *args: Any, **kwargs: Any) -> Awaitable[AsyncConnectionPool]:
         """Create and return a connection pool."""
         return self.create_pool()

sqlspec/adapters/psycopg/config/_common.py

@@ -4,7 +4,7 @@ from dataclasses import dataclass
 from typing import TYPE_CHECKING, Generic, TypeVar
 
 from sqlspec.config import GenericDatabaseConfig, GenericPoolConfig
-from sqlspec.utils.empty import Empty
+from sqlspec.typing import Empty
 
 if TYPE_CHECKING:
     from collections.abc import Callable
@@ -13,7 +13,8 @@ if TYPE_CHECKING:
     from psycopg import AsyncConnection, Connection
     from psycopg_pool import AsyncConnectionPool, ConnectionPool
 
-    from sqlspec.utils.empty import EmptyType
+    from sqlspec.typing import EmptyType
+
 
 __all__ = (
     "PsycoPgGenericDatabaseConfig",

sqlspec/adapters/psycopg/config/_sync.py

@@ -12,7 +12,7 @@ from sqlspec.adapters.psycopg.config._common import (
     PsycoPgGenericPoolConfig,
 )
 from sqlspec.exceptions import ImproperConfigurationError
-from sqlspec.utils.dataclass import simple_asdict
+from sqlspec.typing import dataclass_to_dict
 
 if TYPE_CHECKING:
     from collections.abc import Generator
@@ -43,7 +43,7 @@ class PsycoPgSyncDatabaseConfig(PsycoPgGenericDatabaseConfig[ConnectionPool, Con
     def pool_config_dict(self) -> dict[str, Any]:
         """Return the pool configuration as a dict."""
         if self.pool_config:
-            return simple_asdict(self.pool_config, exclude_empty=True, convert_nested=False)
+            return dataclass_to_dict(self.pool_config, exclude_empty=True, convert_nested=False)
         msg = "'pool_config' methods can not be used when a 'pool_instance' is provided."
         raise ImproperConfigurationError(msg)
 
@@ -63,15 +63,6 @@ class PsycoPgSyncDatabaseConfig(PsycoPgGenericDatabaseConfig[ConnectionPool, Con
             raise ImproperConfigurationError(msg)
         return self.pool_instance
 
-    @contextmanager
-    def lifespan(self, *args: Any, **kwargs: Any) -> Generator[None, None, None]:
-        """Manage the lifecycle of the connection pool."""
-        pool = self.create_pool()
-        try:
-            yield
-        finally:
-            pool.close()
-
     def provide_pool(self, *args: Any, **kwargs: Any) -> ConnectionPool:
         """Create and return a connection pool."""
         return self.create_pool()

sqlspec/adapters/sqlite/config.py

@@ -6,8 +6,7 @@ from typing import TYPE_CHECKING, Any, Literal
 
 from sqlspec.config import GenericDatabaseConfig
 from sqlspec.exceptions import ImproperConfigurationError
-from sqlspec.utils.dataclass import simple_asdict
-from sqlspec.utils.empty import Empty, EmptyType
+from sqlspec.typing import Empty, EmptyType, dataclass_to_dict
 
 if TYPE_CHECKING:
     from collections.abc import Generator
@@ -57,7 +56,7 @@ class SqliteConfig(GenericDatabaseConfig):
         Returns:
             A string keyed dict of config kwargs for the sqlite3.connect() function.
         """
-        return simple_asdict(self, exclude_empty=True, convert_nested=False)
+        return dataclass_to_dict(self, exclude_empty=True, convert_nested=False)
 
     def create_connection(self) -> Connection:
         """Create and return a new database connection.
@@ -71,27 +70,11 @@ class SqliteConfig(GenericDatabaseConfig):
         import sqlite3
 
         try:
-            return sqlite3.connect(**self.connection_config_dict)
+            return sqlite3.connect(**self.connection_config_dict)  # type: ignore[no-any-return,unused-ignore]
         except Exception as e:
             msg = f"Could not configure the SQLite connection. Error: {e!s}"
             raise ImproperConfigurationError(msg) from e
 
-    @contextmanager
-    def lifespan(self, *args: Any, **kwargs: Any) -> Generator[None, None, None]:
-        """Manage the lifecycle of a database connection.
-
-        Yields:
-            None
-
-        Raises:
-            ImproperConfigurationError: If the connection could not be established.
-        """
-        connection = self.create_connection()
-        try:
-            yield
-        finally:
-            connection.close()
-
     @contextmanager
     def provide_connection(self, *args: Any, **kwargs: Any) -> Generator[Connection, None, None]:
         """Create and provide a database connection.

sqlspec/filters.py

@@ -2,11 +2,11 @@
 
 from __future__ import annotations
 
-from abc import ABC, abstractmethod
+from abc import ABC
 from collections import abc  # noqa: TC003
 from dataclasses import dataclass
 from datetime import datetime  # noqa: TC003
-from typing import Generic, Literal
+from typing import Generic, Literal, Protocol
 
 from typing_extensions import TypeVar
 
@@ -27,9 +27,11 @@ __all__ = (
 T = TypeVar("T")
 
 
-class StatementFilter(ABC):
-    @abstractmethod
+class StatementFilter(Protocol):
+    """Protocol for filters that can be appended to a statement."""
+
     def append_to_statement(self, statement: str) -> str:
+        """Append the filter to the statement."""
         return statement
 
 

sqlspec/typing.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from collections.abc import Sequence
+from dataclasses import Field, fields
 from functools import lru_cache
 from typing import (
     TYPE_CHECKING,
@@ -18,15 +19,22 @@ from sqlspec._typing import (
     PYDANTIC_INSTALLED,
     UNSET,
     BaseModel,
+    DataclassProtocol,
+    Empty,
+    EmptyType,
     FailFast,
     Struct,
     TypeAdapter,
+    UnsetType,
     convert,
 )
-from sqlspec.utils.dataclass import DataclassProtocol, is_dataclass_instance, simple_asdict
 
 if TYPE_CHECKING:
-    from .filters import StatementFilter
+    from collections.abc import Iterable
+    from collections.abc import Set as AbstractSet
+
+    from sqlspec.filters import StatementFilter
+
 
 PYDANTIC_USE_FAILFAST = False  # leave permanently disabled for now
 
@@ -55,6 +63,18 @@ A list or sequence of any of the following:
 """
 
 
+def is_dataclass_instance(obj: Any) -> TypeGuard[DataclassProtocol]:
+    """Check if an object is a dataclass instance.
+
+    Args:
+        obj: An object to check.
+
+    Returns:
+        True if the object is a dataclass instance.
+    """
+    return hasattr(type(obj), "__dataclass_fields__")
+
+
 @lru_cache(typed=True)
 def get_type_adapter(f: type[T]) -> TypeAdapter[T]:
     """Caches and returns a pydantic type adapter.
@@ -224,6 +244,104 @@ def is_msgspec_model_without_field(v: Any, field_name: str) -> TypeGuard[Struct]
     return not is_msgspec_model_with_field(v, field_name)
 
 
+def extract_dataclass_fields(
+    dt: DataclassProtocol,
+    exclude_none: bool = False,
+    exclude_empty: bool = False,
+    include: AbstractSet[str] | None = None,
+    exclude: AbstractSet[str] | None = None,
+) -> tuple[Field[Any], ...]:
+    """Extract dataclass fields.
+
+    Args:
+        dt: A dataclass instance.
+        exclude_none: Whether to exclude None values.
+        exclude_empty: Whether to exclude Empty values.
+        include: An iterable of fields to include.
+        exclude: An iterable of fields to exclude.
+
+
+    Returns:
+        A tuple of dataclass fields.
+    """
+    include = include or set()
+    exclude = exclude or set()
+
+    if common := (include & exclude):
+        msg = f"Fields {common} are both included and excluded."
+        raise ValueError(msg)
+
+    dataclass_fields: Iterable[Field[Any]] = fields(dt)
+    if exclude_none:
+        dataclass_fields = (field for field in dataclass_fields if getattr(dt, field.name) is not None)
+    if exclude_empty:
+        dataclass_fields = (field for field in dataclass_fields if getattr(dt, field.name) is not Empty)
+    if include:
+        dataclass_fields = (field for field in dataclass_fields if field.name in include)
+    if exclude:
+        dataclass_fields = (field for field in dataclass_fields if field.name not in exclude)
+
+    return tuple(dataclass_fields)
+
+
+def extract_dataclass_items(
+    dt: DataclassProtocol,
+    exclude_none: bool = False,
+    exclude_empty: bool = False,
+    include: AbstractSet[str] | None = None,
+    exclude: AbstractSet[str] | None = None,
+) -> tuple[tuple[str, Any], ...]:
+    """Extract dataclass name, value pairs.
+
+    Unlike the 'asdict' method exports by the stdlib, this function does not pickle values.
+
+    Args:
+        dt: A dataclass instance.
+        exclude_none: Whether to exclude None values.
+        exclude_empty: Whether to exclude Empty values.
+        include: An iterable of fields to include.
+        exclude: An iterable of fields to exclude.
+
+    Returns:
+        A tuple of key/value pairs.
+    """
+    dataclass_fields = extract_dataclass_fields(dt, exclude_none, exclude_empty, include, exclude)
+    return tuple((field.name, getattr(dt, field.name)) for field in dataclass_fields)
+
+
+def dataclass_to_dict(
+    obj: DataclassProtocol,
+    exclude_none: bool = False,
+    exclude_empty: bool = False,
+    convert_nested: bool = True,
+    exclude: set[str] | None = None,
+) -> dict[str, Any]:
+    """Convert a dataclass to a dictionary.
+
+    This method has important differences to the standard library version:
+    - it does not deepcopy values
+    - it does not recurse into collections
+
+    Args:
+        obj: A dataclass instance.
+        exclude_none: Whether to exclude None values.
+        exclude_empty: Whether to exclude Empty values.
+        convert_nested: Whether to recursively convert nested dataclasses.
+        exclude: An iterable of fields to exclude.
+
+    Returns:
+        A dictionary of key/value pairs.
+    """
+    ret = {}
+    for field in extract_dataclass_fields(obj, exclude_none, exclude_empty, exclude=exclude):
+        value = getattr(obj, field.name)
+        if is_dataclass_instance(value) and convert_nested:
+            ret[field.name] = dataclass_to_dict(value, exclude_none, exclude_empty)
+        else:
+            ret[field.name] = getattr(obj, field.name)
+    return ret
+
+
 def schema_dump(
     data: dict[str, Any] | Struct | BaseModel | DataclassProtocol,
     exclude_unset: bool = True,
@@ -238,7 +356,7 @@ def schema_dump(
         :type: dict[str, Any]
     """
     if is_dataclass(data):
-        return simple_asdict(data, exclude_empty=exclude_unset)
+        return dataclass_to_dict(data, exclude_empty=exclude_unset)
     if is_pydantic_model(data):
         return data.model_dump(exclude_unset=exclude_unset)
     if is_msgspec_model(data) and exclude_unset:
@@ -254,6 +372,9 @@ __all__ = (
     "PYDANTIC_USE_FAILFAST",
     "UNSET",
     "BaseModel",
+    "DataclassProtocol",
+    "Empty",
+    "EmptyType",
     "FailFast",
     "FilterTypeT",
     "ModelDictListT",
@@ -262,7 +383,14 @@ __all__ = (
     "TypeAdapter",
     "UnsetType",
     "convert",
+    "dataclass_to_dict",
+    "extract_dataclass_fields",
+    "extract_dataclass_items",
     "get_type_adapter",
+    "is_dataclass",
+    "is_dataclass_instance",
+    "is_dataclass_with_field",
+    "is_dataclass_without_field",
     "is_dict",
     "is_dict_with_field",
     "is_dict_without_field",

{sqlspec-0.3.0.dist-info → sqlspec-0.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlspec
-Version: 0.3.0
+Version: 0.4.0
 Summary: SQL Experiments in Python
 Author-email: Cody Fincher <cody@litestar.dev>
 Maintainer-email: Litestar Developers <hello@litestar.dev>

sqlspec-0.4.0.dist-info/RECORD

@@ -0,0 +1,39 @@
+sqlspec/__init__.py,sha256=U4S_2y3zgLZVfMenHRaJFBW8yqh2mUBuI291LGQVOJ8,35
+sqlspec/__metadata__.py,sha256=Vw99abV_UQNVH2jB0IBa9-8emyZQcXm1J9eMtLxFX2Y,496
+sqlspec/_serialization.py,sha256=OL4x0Rz5UjF7RgAKqhYChi5qSS_ImtaVrIlA4DhIKUE,824
+sqlspec/_typing.py,sha256=Za41GlNdEKAGTy66GTofOiGYROE7ccFMvxZdh_vxIFk,3278
+sqlspec/config.py,sha256=BOX_V_q2MOP33tK0ISpYaiQJt3zrvK4D_JIBD9FOixY,272
+sqlspec/exceptions.py,sha256=fhCOILBj0J7HJP67BNSC0d9YUbW8QpZPXM55xJJzE8A,3039
+sqlspec/filters.py,sha256=H5UAn1HKm598QqDujQHwvytKHjw4QoQ2zPpgXMcYpSU,3552
+sqlspec/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sqlspec/typing.py,sha256=t5fpzxUCWkKJIpFDKmUeq77RkdmNNFqMj4azgJpRS7k,11316
+sqlspec/adapters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sqlspec/adapters/adbc/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sqlspec/adapters/adbc/config.py,sha256=BeiZdqoBQXuht0GXWleqVKL_LOFI3Ygna1XWDmb-dBw,1704
+sqlspec/adapters/aiosqlite/__init__.py,sha256=PLqWg24l3TooJvqA0Xf1WErrxtqwo8DEoL_Zp2iSCzs,68
+sqlspec/adapters/aiosqlite/config.py,sha256=5DOKaYT_lBFTimrITJwIqTHoweZ2aZlQ07kti1VJtxk,3821
+sqlspec/adapters/asyncmy/__init__.py,sha256=o0R_Azae3FHiSZ1TQ5ZjyCneDOuvnEeMjmSkhuiKoWo,103
+sqlspec/adapters/asyncmy/config.py,sha256=7VsNEokhBtBgXDj2gakdwplOYPaV3ADIwWX-o22vwNk,5461
+sqlspec/adapters/asyncpg/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sqlspec/adapters/asyncpg/config.py,sha256=NyVvsT2x3IIZBZF6dTaSv1w6lCPEvmUprYXyTSJ9Ixk,6014
+sqlspec/adapters/duckdb/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sqlspec/adapters/duckdb/config.py,sha256=BgGGkk0Y3CQboQeI1aB81_ABVGmgOL1cbk_cZKzeggQ,7927
+sqlspec/adapters/oracledb/__init__.py,sha256=fFQ2xOxFcgpr-ug4AVv430irnJgBRUINvt4sL3qzyBw,275
+sqlspec/adapters/oracledb/config/__init__.py,sha256=XoHgInT4IbXjDg5ax3ncuUoVvnYB5qQjI-Ib7gwSycU,338
+sqlspec/adapters/oracledb/config/_asyncio.py,sha256=Z87V7t-5blS6NkMhvFjoBgUrJtKgOrTyKSl8xy2uD_M,3211
+sqlspec/adapters/oracledb/config/_common.py,sha256=k8ou3aWR1En1jl5uo4fORMG3CoF-XQ96qdwULtteHLo,6173
+sqlspec/adapters/oracledb/config/_sync.py,sha256=guCrotTdNJajcbG5xwVCLoza7wLPQxZkQaw99s4ibNE,3071
+sqlspec/adapters/psycopg/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sqlspec/adapters/psycopg/config/__init__.py,sha256=pXI9Pa2VYESTchPgM3tt5kFF8tsmgq-ksZRGR6pgiUQ,280
+sqlspec/adapters/psycopg/config/_async.py,sha256=sNQU3dzencGgOToHZuMfxoqhR9EvRyrxdWqtPDC2gUY,2712
+sqlspec/adapters/psycopg/config/_common.py,sha256=gC-QQDy9DNjp0DGZAT3wu7MKW8ejHe5fuHU-318Vgr0,2757
+sqlspec/adapters/psycopg/config/_sync.py,sha256=lwzaeO6I-nYuC7vif-bjn2jLugPwbPjTW226_hcweqo,2590
+sqlspec/adapters/sqlite/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sqlspec/adapters/sqlite/config.py,sha256=rCv6XWWWi1dzpmAVnwHxg-ahmAif78yfFhA548fNaT8,3697
+sqlspec/extensions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sqlspec/extensions/litestar/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sqlspec/extensions/litestar/plugin.py,sha256=oiBFfRffNvy_vnGptREd6JYZGB6Yd98KbtVct_VcW0A,837
+sqlspec-0.4.0.dist-info/METADATA,sha256=OnTkY_OG3IeqaJQBkzHjsKuQwkfmhQO4WnhXKbEoDLc,3222
+sqlspec-0.4.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+sqlspec-0.4.0.dist-info/licenses/NOTICE,sha256=Lyir8ozXWov7CyYS4huVaOCNrtgL17P-bNV-5daLntQ,1634
+sqlspec-0.4.0.dist-info/RECORD,,

sqlspec/utils/dataclass.py

@@ -1,138 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import Field, fields
-from typing import TYPE_CHECKING, ClassVar, Protocol, runtime_checkable
-
-from typing_extensions import TypeGuard
-
-from sqlspec.utils.empty import Empty
-
-if TYPE_CHECKING:
-    from collections.abc import Iterable
-    from collections.abc import Set as AbstractSet
-    from typing import Any
-
-
-__all__ = (
-    "extract_dataclass_fields",
-    "extract_dataclass_items",
-    "is_dataclass_instance",
-    "simple_asdict",
-)
-
-
-@runtime_checkable
-class DataclassProtocol(Protocol):
-    """Protocol for instance checking dataclasses"""
-
-    __dataclass_fields__: ClassVar[dict[str, Any]]
-
-
-def is_dataclass_instance(obj: Any) -> TypeGuard[DataclassProtocol]:
-    """Check if an object is a dataclass instance.
-
-    Args:
-        obj: An object to check.
-
-    Returns:
-        True if the object is a dataclass instance.
-    """
-    return hasattr(type(obj), "__dataclass_fields__")
-
-
-def extract_dataclass_fields(
-    dt: DataclassProtocol,
-    exclude_none: bool = False,
-    exclude_empty: bool = False,
-    include: AbstractSet[str] | None = None,
-    exclude: AbstractSet[str] | None = None,
-) -> tuple[Field[Any], ...]:
-    """Extract dataclass fields.
-
-    Args:
-        dt: A dataclass instance.
-        exclude_none: Whether to exclude None values.
-        exclude_empty: Whether to exclude Empty values.
-        include: An iterable of fields to include.
-        exclude: An iterable of fields to exclude.
-
-
-    Returns:
-        A tuple of dataclass fields.
-    """
-    include = include or set()
-    exclude = exclude or set()
-
-    if common := (include & exclude):
-        msg = f"Fields {common} are both included and excluded."
-        raise ValueError(msg)
-
-    dataclass_fields: Iterable[Field[Any]] = fields(dt)
-    if exclude_none:
-        dataclass_fields = (field for field in dataclass_fields if getattr(dt, field.name) is not None)
-    if exclude_empty:
-        dataclass_fields = (field for field in dataclass_fields if getattr(dt, field.name) is not Empty)
-    if include:
-        dataclass_fields = (field for field in dataclass_fields if field.name in include)
-    if exclude:
-        dataclass_fields = (field for field in dataclass_fields if field.name not in exclude)
-
-    return tuple(dataclass_fields)
-
-
-def extract_dataclass_items(
-    dt: DataclassProtocol,
-    exclude_none: bool = False,
-    exclude_empty: bool = False,
-    include: AbstractSet[str] | None = None,
-    exclude: AbstractSet[str] | None = None,
-) -> tuple[tuple[str, Any], ...]:
-    """Extract dataclass name, value pairs.
-
-    Unlike the 'asdict' method exports by the stdlib, this function does not pickle values.
-
-    Args:
-        dt: A dataclass instance.
-        exclude_none: Whether to exclude None values.
-        exclude_empty: Whether to exclude Empty values.
-        include: An iterable of fields to include.
-        exclude: An iterable of fields to exclude.
-
-    Returns:
-        A tuple of key/value pairs.
-    """
-    dataclass_fields = extract_dataclass_fields(dt, exclude_none, exclude_empty, include, exclude)
-    return tuple((field.name, getattr(dt, field.name)) for field in dataclass_fields)
-
-
-def simple_asdict(
-    obj: DataclassProtocol,
-    exclude_none: bool = False,
-    exclude_empty: bool = False,
-    convert_nested: bool = True,
-    exclude: set[str] | None = None,
-) -> dict[str, Any]:
-    """Convert a dataclass to a dictionary.
-
-    This method has important differences to the standard library version:
-    - it does not deepcopy values
-    - it does not recurse into collections
-
-    Args:
-        obj: A dataclass instance.
-        exclude_none: Whether to exclude None values.
-        exclude_empty: Whether to exclude Empty values.
-        convert_nested: Whether to recursively convert nested dataclasses.
-        exclude: An iterable of fields to exclude.
-
-    Returns:
-        A dictionary of key/value pairs.
-    """
-    ret = {}
-    for field in extract_dataclass_fields(obj, exclude_none, exclude_empty, exclude=exclude):
-        value = getattr(obj, field.name)
-        if is_dataclass_instance(value) and convert_nested:
-            ret[field.name] = simple_asdict(value, exclude_none, exclude_empty)
-        else:
-            ret[field.name] = getattr(obj, field.name)
-    return ret

sqlspec/utils/empty.py

@@ -1,18 +0,0 @@
-from __future__ import annotations
-
-from enum import Enum
-from typing import Final, Literal, Union
-
-from sqlspec.typing import UnsetType
-
-__all__ = ("Empty", "EmptyType")
-
-
-class _EmptyEnum(Enum):
-    """A sentinel enum used as placeholder."""
-
-    EMPTY = 0
-
-
-EmptyType = Union[Literal[_EmptyEnum.EMPTY], UnsetType]
-Empty: Final = _EmptyEnum.EMPTY

sqlspec-0.3.0.dist-info/RECORD

@@ -1,42 +0,0 @@
-sqlspec/__init__.py,sha256=U4S_2y3zgLZVfMenHRaJFBW8yqh2mUBuI291LGQVOJ8,35
-sqlspec/__metadata__.py,sha256=Vw99abV_UQNVH2jB0IBa9-8emyZQcXm1J9eMtLxFX2Y,496
-sqlspec/_serialization.py,sha256=OL4x0Rz5UjF7RgAKqhYChi5qSS_ImtaVrIlA4DhIKUE,824
-sqlspec/_typing.py,sha256=8tk4KqqO8OLDe-PIow2oaAnzgHOiFb74Mx7yuoAZUgI,2814
-sqlspec/config.py,sha256=BOX_V_q2MOP33tK0ISpYaiQJt3zrvK4D_JIBD9FOixY,272
-sqlspec/exceptions.py,sha256=fhCOILBj0J7HJP67BNSC0d9YUbW8QpZPXM55xJJzE8A,3039
-sqlspec/filters.py,sha256=UtDJVpABSxHLkadiswMcneBsvawmWsz3Bq7wLxLJn74,3454
-sqlspec/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sqlspec/typing.py,sha256=9gXd4qAxZxejXo1NpGDKflsmWu5kQomB3fps3l4EbZs,7289
-sqlspec/adapters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sqlspec/adapters/adbc/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sqlspec/adapters/adbc/config.py,sha256=lCOoewYM0u9GHHGkux0FbSRAri4oIi91_Zrs_x3FkdQ,1745
-sqlspec/adapters/aiosqlite/__init__.py,sha256=PLqWg24l3TooJvqA0Xf1WErrxtqwo8DEoL_Zp2iSCzs,68
-sqlspec/adapters/aiosqlite/config.py,sha256=SM1nkRnrIzeUUMtL1cmMEh75epkCKtII1D-Wjgnc7ZY,4308
-sqlspec/adapters/asyncmy/__init__.py,sha256=o0R_Azae3FHiSZ1TQ5ZjyCneDOuvnEeMjmSkhuiKoWo,103
-sqlspec/adapters/asyncmy/config.py,sha256=0_0tdx7JvTIR1DZuaHeLg8IaK5Rv3li6dVKVOf8k_AI,5956
-sqlspec/adapters/asyncpg/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sqlspec/adapters/asyncpg/config.py,sha256=Q1TgWtI2lrn0SDtP8KTVfJ2f1I6XhOUPSujKngWIf5A,6306
-sqlspec/adapters/duckdb/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sqlspec/adapters/duckdb/config.py,sha256=2LfJnZYMcbXAR9BQ66Y9rhh7R_u6PI2GHApGo1Oy04k,3461
-sqlspec/adapters/oracledb/__init__.py,sha256=fFQ2xOxFcgpr-ug4AVv430irnJgBRUINvt4sL3qzyBw,275
-sqlspec/adapters/oracledb/config/__init__.py,sha256=XoHgInT4IbXjDg5ax3ncuUoVvnYB5qQjI-Ib7gwSycU,338
-sqlspec/adapters/oracledb/config/_asyncio.py,sha256=qB-1jPwjNdHYrDYjjQqR-q1KqMKFXESk-T9aZtdrwDI,3280
-sqlspec/adapters/oracledb/config/_common.py,sha256=VwMbZAX-jJ2kyAbtgRUOWDvO12nXsb68wO-3d3L9Wz4,6183
-sqlspec/adapters/oracledb/config/_sync.py,sha256=m_OkErwBKvQrFU6Q9PuduSJu_vHbmZl1gWYbpw6b22I,3268
-sqlspec/adapters/psycopg/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sqlspec/adapters/psycopg/config/__init__.py,sha256=pXI9Pa2VYESTchPgM3tt5kFF8tsmgq-ksZRGR6pgiUQ,280
-sqlspec/adapters/psycopg/config/_async.py,sha256=mdqFanrnodTq8u3THim3KkiNmEoIQpsKmBpJSaRiGTc,3004
-sqlspec/adapters/psycopg/config/_common.py,sha256=F4rwAlAcVM2HgDVnD87Pda0DjVV-oqzDUd0TofqnUL0,2766
-sqlspec/adapters/psycopg/config/_sync.py,sha256=YILMCmOpGX4E62hepuM0WgT7aPQpwbZpUwjAonmjUYc,2860
-sqlspec/adapters/sqlite/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sqlspec/adapters/sqlite/config.py,sha256=0c_eN01mEcM-OIiaDgs-4fM20z03QivANGxAuxJOisA,4117
-sqlspec/extensions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sqlspec/extensions/litestar/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sqlspec/extensions/litestar/plugin.py,sha256=oiBFfRffNvy_vnGptREd6JYZGB6Yd98KbtVct_VcW0A,837
-sqlspec/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sqlspec/utils/dataclass.py,sha256=g88yP0Pi3EiF8N-Npuo-D6QpPExCLuUvJCO0U_3lHkQ,4301
-sqlspec/utils/empty.py,sha256=u5KC3HUF7MolHYs9kSt7Uq-jTIl0x9gJqf-jX0y5_BY,349
-sqlspec-0.3.0.dist-info/METADATA,sha256=DCx_OsG0w07rjQx01g2av9VxMgQZsmDWcZl0nsqJU8A,3222
-sqlspec-0.3.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-sqlspec-0.3.0.dist-info/licenses/NOTICE,sha256=Lyir8ozXWov7CyYS4huVaOCNrtgL17P-bNV-5daLntQ,1634
-sqlspec-0.3.0.dist-info/RECORD,,