sqlspec 0.3.0__tar.gz → 0.4.0__tar.gz

{sqlspec-0.3.0 → sqlspec-0.4.0}/CONTRIBUTING.rst

@@ -14,7 +14,7 @@ Code contributions
 Workflow
 ++++++++
 
-1. `Fork <https://github.com/litestar-org/litestar-htmx/fork>`_ the `litestar-htmx repository <https://github.com/litestar-org/litestar-htmx>`_
+1. `Fork <https://github.com/litestar-org/sqlspec/fork>`_ the `sqlspec repository <https://github.com/litestar-org/sqlspec>`_
 2. Clone your fork locally with git
 3. `Set up the environment <#setting-up-the-environment>`_
 4. Make your changes
@@ -59,13 +59,13 @@ You can serve the documentation with ``make docs-serve``, or build them with ``m
 Creating a new release
 ----------------------
 
-1. Increment the version in `pyproject.toml <https://github.com/litestar-org/litestar-htmx/blob/main/pyproject.toml>`_.
+1. Increment the version in `pyproject.toml <https://github.com/litestar-org/sqlspec/blob/main/pyproject.toml>`_.
     .. note:: The version should follow `semantic versioning <https://semver.org/>`_ and `PEP 440 <https://www.python.org/dev/peps/pep-0440/>`_.
-2. `Draft a new release <https://github.com/litestar-org/litestar-htmx/releases/new>`_ on GitHub
+2. `Draft a new release <https://github.com/litestar-org/sqlspec/releases/new>`_ on GitHub
 
    * Use ``vMAJOR.MINOR.PATCH`` (e.g. ``v1.2.3``) as both the tag and release title
    * Fill in the release description. You can use the "Generate release notes" function to get a draft for this
 3. Commit your changes and push to ``main``
 4. Publish the release
-5. Go to `Actions <https://github.com/litestar-org/litestar-htmx/actions>`_ and approve the release workflow
+5. Go to `Actions <https://github.com/litestar-org/sqlspec/actions>`_ and approve the release workflow
 6. Check that the workflow runs successfully

{sqlspec-0.3.0 → sqlspec-0.4.0}/PKG-INFO

@@ -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.3.0 → sqlspec-0.4.0}/pyproject.toml

@@ -6,7 +6,7 @@ maintainers = [{ name = "Litestar Developers", email = "hello@litestar.dev" }]
 name = "sqlspec"
 readme = "README.md"
 requires-python = ">=3.9, <4.0"
-version = "0.3.0"
+version = "0.4.0"
 
 [project.optional-dependencies]
 adbc = ["adbc-driver-manager", "pyarrow"]
@@ -128,6 +128,8 @@ exclude_lines = [
 
 [tool.pytest.ini_options]
 addopts = "-ra -q --doctest-glob='*.md' --strict-markers --strict-config"
+asyncio_default_fixture_loop_scope = "function"
+asyncio_mode = "auto"
 testpaths = ["tests"]
 xfail_strict = true
 
@@ -149,7 +151,17 @@ warn_unused_ignores = true
 
 [[tool.mypy.overrides]]
 ignore_missing_imports = true
-module = ["orjson", "re2", "re2.*", "uvicorn.*", "googleapiclient", "googleapiclient.*", "uvloop.*","asyncmy", "asyncmy.*"]
+module = [
+  "orjson",
+  "re2",
+  "re2.*",
+  "uvicorn.*",
+  "googleapiclient",
+  "googleapiclient.*",
+  "uvloop.*",
+  "asyncmy",
+  "asyncmy.*",
+]
 
 [tool.pyright]
 disableBytesTypePromotions = true
@@ -272,25 +284,25 @@ docstring-code-line-length = 88
 [tool.git-cliff.changelog]
 body = """
 {% if version %}\
-    `Release [v{{ version | trim_start_matches(pat="v") }}] - {{ timestamp | date(format="%Y-%m-%d") }} <https://github.com/litestar-org/litestar-htmx/releases/tag/v{{ version | trim_start_matches(pat="v") }}>`_
+    `Release [v{{ version | trim_start_matches(pat="v") }}] - {{ timestamp | date(format="%Y-%m-%d") }} <https://github.com/litestar-org/sqlspec/releases/tag/v{{ version | trim_start_matches(pat="v") }}>`_
     ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-    * `See All commits in v{{ version | trim_start_matches(pat="v") }} <https://github.com/litestar-org/litestar-htmx/commits/v{{ version | trim_start_matches(pat="v") }}>`_
+    * `See All commits in v{{ version | trim_start_matches(pat="v") }} <https://github.com/litestar-org/sqlspec/commits/v{{ version | trim_start_matches(pat="v") }}>`_
 {% else %}\
     [unreleased]
     ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 {% endif %}\
 {% if previous %}\
     {% if previous.commit_id %}
-        `{{ previous.commit_id | truncate(length=7, end="") }} <https://github.com/litestar-org/litestar-htmx/commit/{{ previous.commit_id }}>`_ ... \
-            `{{ commit_id | truncate(length=7, end="") }} <https://github.com/litestar-org/litestar-htmx/commit/{{ commit_id }}>`_ \
-            | `See diff for {{ version | trim_start_matches(pat="v") }} <https://github.com/litestar-org/litestar-htmx/compare/{{ previous.commit_id }}...{{ commit_id }}>`_
+        `{{ previous.commit_id | truncate(length=7, end="") }} <https://github.com/litestar-org/sqlspec/commit/{{ previous.commit_id }}>`_ ... \
+            `{{ commit_id | truncate(length=7, end="") }} <https://github.com/litestar-org/sqlspec/commit/{{ commit_id }}>`_ \
+            | `See diff for {{ version | trim_start_matches(pat="v") }} <https://github.com/litestar-org/sqlspec/compare/{{ previous.commit_id }}...{{ commit_id }}>`_
     {% endif %}\
 {% endif %}\
 {% for group, commits in commits | group_by(attribute="group") %}
     {{ group | upper_first }}
     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
     {% for commit in commits %}
-        * (`{{ commit.id | truncate(length=7, end="") }} <https://github.com/litestar-org/litestar-htmx/commit/{{ commit.id }}>`_) {% if commit.breaking %}[**breaking**] {% endif %} - {{ commit.message | upper_first }} ({{ commit.author.name  }})\
+        * (`{{ commit.id | truncate(length=7, end="") }} <https://github.com/litestar-org/sqlspec/commit/{{ commit.id }}>`_) {% if commit.breaking %}[**breaking**] {% endif %} - {{ commit.message | upper_first }} ({{ commit.author.name  }})\
           {% for footer in commit.footers -%}
             , {{ footer.token }}{{ footer.separator }}{{ footer.value }}\
           {% endfor %}\

{sqlspec-0.3.0 → sqlspec-0.4.0}/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-0.3.0 → sqlspec-0.4.0}/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-0.3.0 → sqlspec-0.4.0}/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-0.3.0 → sqlspec-0.4.0}/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-0.3.0 → sqlspec-0.4.0}/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-0.4.0/sqlspec/adapters/duckdb/config.py

@@ -0,0 +1,201 @@
+from __future__ import annotations
+
+from contextlib import contextmanager
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, cast
+
+from sqlspec.config import GenericDatabaseConfig
+from sqlspec.exceptions import ImproperConfigurationError
+from sqlspec.typing import Empty, EmptyType, dataclass_to_dict
+
+if TYPE_CHECKING:
+    from collections.abc import Generator, Sequence
+
+    from duckdb import DuckDBPyConnection
+
+__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
+class DuckDBConfig(GenericDatabaseConfig):
+    """Configuration for DuckDB database connections.
+
+    This class provides configuration options for DuckDB database connections, wrapping all parameters
+    available to duckdb.connect().
+
+    For details see: https://duckdb.org/docs/api/python/overview#connection-options
+    """
+
+    database: str | EmptyType = Empty
+    """The path to the database file to be opened. Pass ":memory:" to open a connection to a database that resides in RAM instead of on disk. If not specified, an in-memory database will be created."""
+
+    read_only: bool | EmptyType = Empty
+    """If True, the database will be opened in read-only mode. This is required if multiple processes want to access the same database file at the same time."""
+
+    config: dict[str, Any] | EmptyType = Empty
+    """A dictionary of configuration options to be passed to DuckDB. These can include settings like 'access_mode', 'max_memory', 'threads', etc.
+
+    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.
+
+        Returns:
+            A string keyed dict of config kwargs for the duckdb.connect() function.
+        """
+        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 with configured extensions.
+
+        Returns:
+            A new DuckDB connection instance with extensions installed and configured.
+
+        Raises:
+            ImproperConfigurationError: If the connection could not be established or extensions could not be configured.
+        """
+        import duckdb
+
+        try:
+            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 provide_connection(self, *args: Any, **kwargs: Any) -> Generator[DuckDBPyConnection, None, None]:
+        """Create and provide a database connection.
+
+        Yields:
+            A DuckDB connection instance.
+
+        Raises:
+            ImproperConfigurationError: If the connection could not be established.
+        """
+        connection = self.create_connection()
+        try:
+            yield connection
+        finally:
+            connection.close()

{sqlspec-0.3.0 → sqlspec-0.4.0}/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-0.3.0 → sqlspec-0.4.0}/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-0.3.0 → sqlspec-0.4.0}/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-0.3.0 → sqlspec-0.4.0}/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-0.3.0 → sqlspec-0.4.0}/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",