sqlspec 0.5.0__py3-none-any.whl → 0.7.0__py3-none-any.whl

sqlspec/adapters/asyncpg/config.py

@@ -1,24 +1,22 @@
-from __future__ import annotations
-
 from contextlib import asynccontextmanager
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, TypeVar, Union
+from typing import TYPE_CHECKING, Any, Optional, TypeVar, Union
 
 from asyncpg import Record
 from asyncpg import create_pool as asyncpg_create_pool
-from asyncpg.connection import Connection
 from asyncpg.pool import Pool, PoolConnectionProxy
 from typing_extensions import TypeAlias
 
 from sqlspec._serialization import decode_json, encode_json
-from sqlspec.base import DatabaseConfigProtocol, GenericDatabaseConfig, GenericPoolConfig
+from sqlspec.base import AsyncDatabaseConfig, GenericPoolConfig
 from sqlspec.exceptions import ImproperConfigurationError
 from sqlspec.typing import Empty, EmptyType, dataclass_to_dict
 
 if TYPE_CHECKING:
-    from asyncio import AbstractEventLoop
+    from asyncio import AbstractEventLoop  # pyright: ignore[reportAttributeAccessIssue]
     from collections.abc import AsyncGenerator, Awaitable, Callable, Coroutine
-    from typing import Any
+
+    from asyncpg.connection import Connection
 
 
 __all__ = (
@@ -29,7 +27,7 @@ __all__ = (
 
 T = TypeVar("T")
 
-PgConnection: TypeAlias = Union[Connection, PoolConnectionProxy]
+PgConnection: TypeAlias = "Union[Connection, PoolConnectionProxy]"  # pyright: ignore[reportMissingTypeArgument]
 
 
 @dataclass
@@ -42,60 +40,57 @@ class AsyncPgPoolConfig(GenericPoolConfig):
     dsn: str
     """Connection arguments specified using as a single string in the following format: ``postgres://user:pass@host:port/database?option=value``
     """
-    connect_kwargs: dict[Any, Any] | None | EmptyType = Empty
+    connect_kwargs: "Optional[Union[dict[Any, Any], EmptyType]]" = Empty
     """A dictionary of arguments which will be passed directly to the ``connect()`` method as keyword arguments.
     """
-    connection_class: type[Connection] | None | EmptyType = Empty
+    connection_class: "Optional[Union[type[Connection], EmptyType]]" = Empty  # pyright: ignore[reportMissingTypeArgument]
     """The class to use for connections. Must be a subclass of Connection
     """
-    record_class: type[Record] | EmptyType = Empty
+    record_class: "Union[type[Record], EmptyType]" = Empty
     """If specified, the class to use for records returned by queries on the connections in this pool. Must be a subclass of Record."""
 
-    min_size: int | EmptyType = Empty
+    min_size: "Union[int, EmptyType]" = Empty
     """The number of connections to keep open inside the connection pool."""
-    max_size: int | EmptyType = Empty
+    max_size: "Union[int, EmptyType]" = Empty
     """The number of connections to allow in connection pool “overflow”, that is connections that can be opened above
     and beyond the pool_size setting, which defaults to 10."""
 
-    max_queries: int | EmptyType = Empty
+    max_queries: "Union[int, EmptyType]" = Empty
     """Number of queries after a connection is closed and replaced with a new connection.
     """
-    max_inactive_connection_lifetime: float | EmptyType = Empty
+    max_inactive_connection_lifetime: "Union[float, EmptyType]" = Empty
     """Number of seconds after which inactive connections in the pool will be closed. Pass 0 to disable this mechanism."""
 
-    setup: Coroutine[None, type[Connection], Any] | EmptyType = Empty
+    setup: "Union[Coroutine[None, type[Connection], Any], EmptyType]" = Empty  # pyright: ignore[reportMissingTypeArgument]
     """A coroutine to prepare a connection right before it is returned from Pool.acquire(). An example use case would be to automatically set up notifications listeners for all connections of a pool."""
-    init: Coroutine[None, type[Connection], Any] | EmptyType = Empty
+    init: "Union[Coroutine[None, type[Connection], Any], EmptyType]" = Empty  # pyright: ignore[reportMissingTypeArgument]
     """A coroutine to prepare a connection right before it is returned from Pool.acquire(). An example use case would be to automatically set up notifications listeners for all connections of a pool."""
 
-    loop: AbstractEventLoop | EmptyType = Empty
+    loop: "Union[AbstractEventLoop, EmptyType]" = Empty
     """An asyncio event loop instance. If None, the default event loop will be used."""
 
 
 @dataclass
-class AsyncPgConfig(DatabaseConfigProtocol[PgConnection, Pool], GenericDatabaseConfig):
+class AsyncPgConfig(AsyncDatabaseConfig[PgConnection, Pool]):  # pyright: ignore[reportMissingTypeArgument]
     """Asyncpg Configuration."""
 
-    __is_async__ = True
-    __supports_connection_pooling__ = True
-
-    pool_config: AsyncPgPoolConfig | None = None
+    pool_config: "Optional[AsyncPgPoolConfig]" = None
     """Asyncpg Pool configuration"""
-    json_deserializer: Callable[[str], Any] = decode_json
+    json_deserializer: "Callable[[str], Any]" = decode_json
     """For dialects that support the :class:`JSON <sqlalchemy.types.JSON>` datatype, this is a Python callable that will
     convert a JSON string to a Python object. By default, this is set to SQLSpec's
     :attr:`decode_json() <sqlspec._serialization.decode_json>` function."""
-    json_serializer: Callable[[Any], str] = encode_json
+    json_serializer: "Callable[[Any], str]" = encode_json
     """For dialects that support the JSON datatype, this is a Python callable that will render a given object as JSON.
     By default, SQLSpec's :attr:`encode_json() <sqlspec._serialization.encode_json>` is used."""
-    pool_instance: Pool | None = None
+    pool_instance: "Optional[Pool[Any]]" = 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]:
+    def pool_config_dict(self) -> "dict[str, Any]":
         """Return the pool configuration as a dict.
 
         Returns:
@@ -107,7 +102,7 @@ class AsyncPgConfig(DatabaseConfigProtocol[PgConnection, Pool], GenericDatabaseC
         msg = "'pool_config' methods can not be used when a 'pool_instance' is provided."
         raise ImproperConfigurationError(msg)
 
-    async def create_pool(self) -> Pool:
+    async def create_pool(self) -> "Pool":  # pyright: ignore[reportMissingTypeArgument,reportUnknownParameterType]
         """Return a pool. If none exists yet, create one.
 
         Returns:
@@ -129,21 +124,21 @@ class AsyncPgConfig(DatabaseConfigProtocol[PgConnection, Pool], GenericDatabaseC
             )
         return self.pool_instance
 
-    def provide_pool(self, *args: Any, **kwargs: Any) -> Awaitable[Pool]:
+    def provide_pool(self, *args: "Any", **kwargs: "Any") -> "Awaitable[Pool]":  # pyright: ignore[reportMissingTypeArgument,reportUnknownParameterType]
         """Create a pool instance.
 
         Returns:
             A Pool instance.
         """
-        return self.create_pool()
+        return self.create_pool()  # pyright: ignore[reportUnknownMemberType,reportUnknownVariableType]
 
     @asynccontextmanager
-    async def provide_connection(self, *args: Any, **kwargs: Any) -> AsyncGenerator[PoolConnectionProxy, None]:
+    async def provide_connection(self, *args: "Any", **kwargs: "Any") -> "AsyncGenerator[PoolConnectionProxy, None]":  # pyright: ignore[reportMissingTypeArgument,reportUnknownParameterType]
         """Create a connection instance.
 
         Returns:
             A connection instance.
         """
-        db_pool = await self.provide_pool(*args, **kwargs)
-        async with db_pool.acquire() as connection:
+        db_pool = await self.provide_pool(*args, **kwargs)  # pyright: ignore[reportUnknownMemberType,reportUnknownVariableType]
+        async with db_pool.acquire() as connection:  # pyright: ignore[reportUnknownVariableType]
             yield connection

sqlspec/adapters/duckdb/config.py

@@ -1,12 +1,11 @@
-from __future__ import annotations
-
 from contextlib import contextmanager
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, cast
+from typing import TYPE_CHECKING, Any, Union, cast
 
 from duckdb import DuckDBPyConnection
+from typing_extensions import NotRequired, TypedDict
 
-from sqlspec.base import GenericDatabaseConfig, NoPoolConfig
+from sqlspec.base import NoPoolSyncConfig
 from sqlspec.exceptions import ImproperConfigurationError
 from sqlspec.typing import Empty, EmptyType, dataclass_to_dict
 
@@ -17,8 +16,7 @@ if TYPE_CHECKING:
 __all__ = ("DuckDBConfig", "ExtensionConfig")
 
 
-@dataclass
-class ExtensionConfig:
+class ExtensionConfig(TypedDict):
     """Configuration for a DuckDB extension.
 
     This class provides configuration options for DuckDB extensions, including installation
@@ -29,44 +27,20 @@ class ExtensionConfig:
 
     name: str
     """The name of the extension to install"""
-    config: dict[str, Any] | None = None
+    config: "NotRequired[dict[str, Any]]"
     """Optional configuration settings to apply after installation"""
-    force_install: bool = False
+    force_install: "NotRequired[bool]"
     """Whether to force reinstall if already present"""
-    repository: str | None = None
+    repository: "NotRequired[str]"
     """Optional repository name to install from"""
-    repository_url: str | None = None
+    repository_url: "NotRequired[str]"
     """Optional repository URL to install from"""
-    version: str | None = None
+    version: "NotRequired[str]"
     """Optional version of the extension to install"""
 
-    @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(NoPoolConfig[DuckDBPyConnection], GenericDatabaseConfig):
+class DuckDBConfig(NoPoolSyncConfig[DuckDBPyConnection]):
     """Configuration for DuckDB database connections.
 
     This class provides configuration options for DuckDB database connections, wrapping all parameters
@@ -75,28 +49,24 @@ class DuckDBConfig(NoPoolConfig[DuckDBPyConnection], GenericDatabaseConfig):
     For details see: https://duckdb.org/docs/api/python/overview#connection-options
     """
 
-    database: str | EmptyType = Empty
+    database: "Union[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
+    read_only: "Union[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
+    config: "Union[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
+    extensions: "Union[Sequence[ExtensionConfig], 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.
@@ -106,56 +76,81 @@ class DuckDBConfig(NoPoolConfig[DuckDBPyConnection], GenericDatabaseConfig):
 
         if self.extensions is Empty:
             self.extensions = []
+        if isinstance(self.extensions, dict):
+            self.extensions = [self.extensions]
         # this is purely for mypy
         assert isinstance(self.config, dict)  # noqa: S101
         assert isinstance(self.extensions, list)  # noqa: S101
+        config_exts: list[ExtensionConfig] = self.config.pop("extensions", [])
+        if not isinstance(config_exts, list):  # pyright: ignore[reportUnnecessaryIsInstance]
+            config_exts = [config_exts]  # type: ignore[unreachable]
 
-        _e = self.config.pop("extensions", {})
-        if not isinstance(_e, (dict, list, tuple)):
+        try:
+            if (
+                len(set({ext["name"] for ext in config_exts}).intersection({ext["name"] for ext in self.extensions}))
+                > 0
+            ):  # pyright: ignore[ reportUnknownArgumentType]
+                msg = "Configuring the same extension in both 'extensions' and as a key in 'config['extensions']' is not allowed.  Please use only one method to configure extensions."
+                raise ImproperConfigurationError(msg)
+        except (KeyError, TypeError) as e:
             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}  # pyright: ignore[reportUnknownVariableType,reportUnknownArgumentType]
+            raise ImproperConfigurationError(msg) from e
+        self.extensions.extend(config_exts)
 
-        if len(set(_e.keys()).intersection({ext.name for ext in self.extensions})) > 0:  # pyright: ignore[ reportUnknownArgumentType]
-            msg = "Configuring the same extension in both 'extensions' and as a key in 'config['extensions']' is not allowed"
-            raise ImproperConfigurationError(msg)
+    def _configure_connection(self, connection: "DuckDBPyConnection") -> None:
+        """Configure the connection.
 
-        self.extensions.extend([ExtensionConfig.from_dict(name, ext_config) for name, ext_config in _e.items()])  # pyright: ignore[reportUnknownArgumentType,reportUnknownVariableType]
+        Args:
+            connection: The DuckDB connection to configure.
+        """
+        for config in cast("list[str]", self.config):
+            connection.execute(config)
 
-    def _configure_extensions(self, connection: DuckDBPyConnection) -> None:
+    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
+            self._configure_extension(connection, extension)
+
+    @staticmethod
+    def _configure_extension(connection: "DuckDBPyConnection", extension: ExtensionConfig) -> None:
+        """Configure a single extension for the connection.
+
+        Args:
+            connection: The DuckDB connection to configure extension for.
+            extension: The extension configuration to apply.
+
+        Raises:
+            ImproperConfigurationError: If extension installation or configuration fails.
+        """
+        try:
+            if extension.get("force_install"):
+                connection.install_extension(
+                    extension=extension["name"],
+                    force_install=extension.get("force_install", False),
+                    repository=extension.get("repository"),
+                    repository_url=extension.get("repository_url"),
+                    version=extension.get("version"),
+                )
+            connection.load_extension(extension["name"])
+
+            if extension.get("config"):
+                for key, value in extension.get("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]:
+    def connection_config_dict(self) -> "dict[str, Any]":
         """Return the connection configuration as a dict.
 
         Returns:
@@ -166,7 +161,7 @@ class DuckDBConfig(NoPoolConfig[DuckDBPyConnection], GenericDatabaseConfig):
             config["database"] = ":memory:"
         return config
 
-    def create_connection(self) -> DuckDBPyConnection:
+    def create_connection(self) -> "DuckDBPyConnection":
         """Create and return a new database connection with configured extensions.
 
         Returns:
@@ -180,20 +175,21 @@ class DuckDBConfig(NoPoolConfig[DuckDBPyConnection], GenericDatabaseConfig):
         try:
             connection = duckdb.connect(**self.connection_config_dict)  # pyright: ignore[reportUnknownMemberType]
             self._configure_extensions(connection)
-            return connection
+            self._configure_connection(connection)
         except Exception as e:
             msg = f"Could not configure the DuckDB connection. Error: {e!s}"
             raise ImproperConfigurationError(msg) from e
+        else:
+            return connection
 
     @contextmanager
-    def provide_connection(self, *args: Any, **kwargs: Any) -> Generator[DuckDBPyConnection, None, None]:
+    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:

sqlspec/adapters/oracledb/config/_asyncio.py

@@ -1,23 +1,21 @@
-from __future__ import annotations
-
 from contextlib import asynccontextmanager
 from dataclasses import dataclass
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any, Optional
 
-from oracledb import create_pool_async as oracledb_create_pool
+from oracledb import create_pool_async as oracledb_create_pool  # pyright: ignore[reportUnknownVariableType]
 from oracledb.connection import AsyncConnection
 from oracledb.pool import AsyncConnectionPool
 
 from sqlspec.adapters.oracledb.config._common import (
-    OracleGenericDatabaseConfig,
     OracleGenericPoolConfig,
 )
+from sqlspec.base import AsyncDatabaseConfig
 from sqlspec.exceptions import ImproperConfigurationError
 from sqlspec.typing import dataclass_to_dict
 
 if TYPE_CHECKING:
     from collections.abc import AsyncGenerator, Awaitable
-    from typing import Any
+
 
 __all__ = (
     "OracleAsyncDatabaseConfig",
@@ -31,22 +29,29 @@ class OracleAsyncPoolConfig(OracleGenericPoolConfig[AsyncConnection, AsyncConnec
 
 
 @dataclass
-class OracleAsyncDatabaseConfig(OracleGenericDatabaseConfig[AsyncConnection, AsyncConnectionPool]):
-    """Async Oracle database Configuration."""
+class OracleAsyncDatabaseConfig(AsyncDatabaseConfig[AsyncConnection, AsyncConnectionPool]):
+    """Oracle Async database Configuration.
 
-    __is_async__ = True
-    __supports_connection_pooling__ = True
+    This class provides the base configuration for Oracle database connections, extending
+    the generic database configuration with Oracle-specific settings. It supports both
+    thin and thick modes of the python-oracledb driver.([1](https://python-oracledb.readthedocs.io/en/latest/index.html))
+
+    The configuration supports all standard Oracle connection parameters and can be used
+    with both synchronous and asynchronous connections. It includes support for features
+    like Oracle Wallet, external authentication, connection pooling, and advanced security
+    options.([2](https://python-oracledb.readthedocs.io/en/latest/user_guide/tuning.html))
+    """
 
-    pool_config: OracleAsyncPoolConfig | None = None
+    pool_config: "Optional[OracleAsyncPoolConfig]" = None
     """Oracle Pool configuration"""
-    pool_instance: AsyncConnectionPool | None = None
+    pool_instance: "Optional[AsyncConnectionPool]" = 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]:
+    def pool_config_dict(self) -> "dict[str, Any]":
         """Return the pool configuration as a dict.
 
         Returns:
@@ -58,7 +63,7 @@ class OracleAsyncDatabaseConfig(OracleGenericDatabaseConfig[AsyncConnection, Asy
         msg = "'pool_config' methods can not be used when a 'pool_instance' is provided."
         raise ImproperConfigurationError(msg)
 
-    async def create_pool(self) -> AsyncConnectionPool:
+    async def create_pool(self) -> "AsyncConnectionPool":
         """Return a pool. If none exists yet, create one.
 
         Returns:
@@ -74,11 +79,11 @@ class OracleAsyncDatabaseConfig(OracleGenericDatabaseConfig[AsyncConnection, Asy
         pool_config = self.pool_config_dict
         self.pool_instance = oracledb_create_pool(**pool_config)
         if self.pool_instance is None:  # pyright: ignore[reportUnnecessaryComparison]
-            msg = "Could not configure the 'pool_instance'. Please check your configuration."
+            msg = "Could not configure the 'pool_instance'. Please check your configuration."  # type: ignore[unreachable]
             raise ImproperConfigurationError(msg)
         return self.pool_instance
 
-    def provide_pool(self, *args: Any, **kwargs: Any) -> Awaitable[AsyncConnectionPool]:
+    def provide_pool(self, *args: "Any", **kwargs: "Any") -> "Awaitable[AsyncConnectionPool]":
         """Create a pool instance.
 
         Returns:
@@ -87,12 +92,12 @@ class OracleAsyncDatabaseConfig(OracleGenericDatabaseConfig[AsyncConnection, Asy
         return self.create_pool()
 
     @asynccontextmanager
-    async def provide_connection(self, *args: Any, **kwargs: Any) -> AsyncGenerator[AsyncConnection, None]:
+    async def provide_connection(self, *args: "Any", **kwargs: "Any") -> "AsyncGenerator[AsyncConnection, None]":
         """Create a connection instance.
 
         Returns:
             A connection instance.
         """
         db_pool = await self.provide_pool(*args, **kwargs)
-        async with db_pool.acquire() as connection:
+        async with db_pool.acquire() as connection:  # pyright: ignore[reportUnknownMemberType]
             yield connection