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

sqlspec/__metadata__.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from importlib.metadata import PackageNotFoundError, metadata, version
 
-__all__ = ["__project__", "__version__"]
+__all__ = ("__project__", "__version__")
 
 try:
     __version__ = version("sqlspec")

sqlspec/_serialization.py

@@ -13,7 +13,7 @@ try:
 
 except ImportError:
     try:
-        from orjson import dumps as _encode_json  # pyright: ignore[reportMissingImports]
+        from orjson import dumps as _encode_json  # pyright: ignore[reportMissingImports,reportUnknownVariableType]
         from orjson import loads as decode_json  # type: ignore[no-redef]
 
         def encode_json(data: Any) -> str:

sqlspec/_typing.py

@@ -29,7 +29,6 @@ class DataclassProtocol(Protocol):
 T = TypeVar("T")
 T_co = TypeVar("T_co", covariant=True)
 
-
 try:
     from pydantic import BaseModel, FailFast, TypeAdapter
 
@@ -110,6 +109,35 @@ except ImportError:
     UNSET = UnsetType.UNSET  # pyright: ignore[reportConstantRedefinition]
     MSGSPEC_INSTALLED = False  # pyright: ignore[reportConstantRedefinition]
 
+try:
+    from litestar.dto.data_structures import DTOData  # pyright: ignore[reportUnknownVariableType]
+
+    LITESTAR_INSTALLED = True
+except ImportError:
+
+    @runtime_checkable
+    class DTOData(Protocol[T]):  # type: ignore[no-redef]
+        """Placeholder implementation"""
+
+        __slots__ = ("_backend", "_data_as_builtins")
+
+        def __init__(self, backend: Any, data_as_builtins: Any) -> None:
+            """Placeholder init"""
+
+        def create_instance(self, **kwargs: Any) -> T:
+            """Placeholder implementation"""
+            return cast("T", kwargs)
+
+        def update_instance(self, instance: T, **kwargs: Any) -> T:
+            """Placeholder implementation"""
+            return cast("T", kwargs)
+
+        def as_builtins(self) -> Any:
+            """Placeholder implementation"""
+            return {}
+
+    LITESTAR_INSTALLED = False  # pyright: ignore[reportConstantRedefinition]
+
 
 class EmptyEnum(Enum):
     """A sentinel enum used as placeholder."""
@@ -122,10 +150,12 @@ Empty: Final = EmptyEnum.EMPTY
 
 
 __all__ = (
+    "LITESTAR_INSTALLED",
     "MSGSPEC_INSTALLED",
     "PYDANTIC_INSTALLED",
     "UNSET",
     "BaseModel",
+    "DTOData",
     "DataclassProtocol",
     "Empty",
     "EmptyEnum",

sqlspec/adapters/adbc/config.py

@@ -2,31 +2,31 @@ from __future__ import annotations
 
 from contextlib import contextmanager
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, TypeVar
+from typing import TYPE_CHECKING
 
-from sqlspec.config import GenericDatabaseConfig
+from sqlspec.base import NoPoolSyncConfig
 from sqlspec.typing import Empty, EmptyType
 
 if TYPE_CHECKING:
     from collections.abc import Generator
     from typing import Any
 
-    from adbc_driver_manager.dbapi import Connection, Cursor
+    from adbc_driver_manager.dbapi import Connection
 
 __all__ = ("AdbcDatabaseConfig",)
 
-ConnectionT = TypeVar("ConnectionT", bound="Connection")
-CursorT = TypeVar("CursorT", bound="Cursor")
-
 
 @dataclass
-class AdbcDatabaseConfig(GenericDatabaseConfig):
+class AdbcDatabaseConfig(NoPoolSyncConfig["Connection"]):
     """Configuration for ADBC connections.
 
     This class provides configuration options for ADBC database connections using the
     ADBC Driver Manager.([1](https://arrow.apache.org/adbc/current/python/api/adbc_driver_manager.html))
     """
 
+    __supports_connection_pooling = False
+    __is_async = False
+
     uri: str | EmptyType = Empty
     """Database URI"""
     driver_name: str | EmptyType = Empty

sqlspec/adapters/aiosqlite/config.py

@@ -1,10 +1,10 @@
 from __future__ import annotations
 
 from contextlib import asynccontextmanager
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any
 
-from sqlspec.config import GenericDatabaseConfig
+from sqlspec.base import NoPoolSyncConfig
 from sqlspec.exceptions import ImproperConfigurationError
 from sqlspec.typing import Empty, EmptyType, dataclass_to_dict
 
@@ -19,7 +19,7 @@ __all__ = ("AiosqliteConfig",)
 
 
 @dataclass
-class AiosqliteConfig(GenericDatabaseConfig):
+class AiosqliteConfig(NoPoolSyncConfig["Connection"]):
     """Configuration for Aiosqlite database connections.
 
     This class provides configuration options for Aiosqlite database connections, wrapping all parameters
@@ -28,28 +28,21 @@ class AiosqliteConfig(GenericDatabaseConfig):
     For details see: https://github.com/omnilib/aiosqlite/blob/main/aiosqlite/__init__.pyi
     """
 
-    database: str
+    database: str = field(default=":memory:")
     """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."""
-
-    timeout: float | EmptyType = Empty
+    timeout: float | EmptyType = field(default=Empty)
     """How many seconds the connection should wait before raising an OperationalError when a table is locked. If another thread or process has acquired a shared lock, a wait for the specified timeout occurs."""
-
-    detect_types: int | EmptyType = Empty
+    detect_types: int | EmptyType = field(default=Empty)
     """Control whether and how data types are detected. It can be 0 (default) or a combination of PARSE_DECLTYPES and PARSE_COLNAMES."""
-
-    isolation_level: Literal["DEFERRED", "IMMEDIATE", "EXCLUSIVE"] | None | EmptyType = Empty
+    isolation_level: Literal["DEFERRED", "IMMEDIATE", "EXCLUSIVE"] | None | EmptyType = field(default=Empty)
     """The isolation_level of the connection. This can be None for autocommit mode or one of "DEFERRED", "IMMEDIATE" or "EXCLUSIVE"."""
-
-    check_same_thread: bool | EmptyType = Empty
+    check_same_thread: bool | EmptyType = field(default=Empty)
     """If True (default), ProgrammingError is raised if the database connection is used by a thread other than the one that created it. If False, the connection may be shared across multiple threads."""
-
-    factory: type[SQLite3Connection] | EmptyType = Empty
+    factory: type[SQLite3Connection] | EmptyType = field(default=Empty)
     """A custom Connection class factory. If given, must be a callable that returns a Connection instance."""
-
-    cached_statements: int | EmptyType = Empty
+    cached_statements: int | EmptyType = field(default=Empty)
     """The number of statements that SQLite will cache for this connection. The default is 128."""
-
-    uri: bool | EmptyType = Empty
+    uri: bool | EmptyType = field(default=Empty)
     """If set to True, database is interpreted as a URI with supported options."""
 
     @property

sqlspec/adapters/asyncmy/config.py

@@ -4,6 +4,10 @@ from contextlib import asynccontextmanager
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, TypeVar
 
+from asyncmy.connection import Connection
+from asyncmy.pool import Pool
+
+from sqlspec.base import AsyncDatabaseConfig, GenericPoolConfig
 from sqlspec.exceptions import ImproperConfigurationError
 from sqlspec.typing import Empty, EmptyType, dataclass_to_dict
 
@@ -11,9 +15,7 @@ if TYPE_CHECKING:
     from collections.abc import AsyncGenerator
     from typing import Any
 
-    from asyncmy.connection import Connection
     from asyncmy.cursors import Cursor, DictCursor
-    from asyncmy.pool import Pool
 
 __all__ = (
     "AsyncMyConfig",
@@ -25,7 +27,7 @@ T = TypeVar("T")
 
 
 @dataclass
-class AsyncmyPoolConfig:
+class AsyncmyPoolConfig(GenericPoolConfig):
     """Configuration for Asyncmy's connection pool.
 
     This class provides configuration options for Asyncmy database connection pools.
@@ -104,9 +106,12 @@ class AsyncmyPoolConfig:
 
 
 @dataclass
-class AsyncMyConfig:
+class AsyncMyConfig(AsyncDatabaseConfig[Connection, Pool]):
     """Asyncmy Configuration."""
 
+    __is_async__ = True
+    __supports_connection_pooling__ = True
+
     pool_config: AsyncmyPoolConfig | None = None
     """Asyncmy Pool configuration"""
 

sqlspec/adapters/asyncpg/config.py

@@ -2,23 +2,23 @@ from __future__ import annotations
 
 from contextlib import asynccontextmanager
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, TypeVar
+from typing import TYPE_CHECKING, Any, 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.config import 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
-    from asyncpg.pool import Pool, PoolConnectionProxy
 
 __all__ = (
     "AsyncPgConfig",
@@ -28,6 +28,8 @@ __all__ = (
 
 T = TypeVar("T")
 
+PgConnection: TypeAlias = Union[Connection, PoolConnectionProxy]
+
 
 @dataclass
 class AsyncPgPoolConfig(GenericPoolConfig):
@@ -70,7 +72,7 @@ class AsyncPgPoolConfig(GenericPoolConfig):
 
 
 @dataclass
-class AsyncPgConfig(GenericDatabaseConfig):
+class AsyncPgConfig(AsyncDatabaseConfig[PgConnection, Pool]):
     """Asyncpg Configuration."""
 
     pool_config: AsyncPgPoolConfig | None = None
@@ -132,9 +134,7 @@ class AsyncPgConfig(GenericDatabaseConfig):
         return self.create_pool()
 
     @asynccontextmanager
-    async def provide_connection(
-        self, *args: Any, **kwargs: Any
-    ) -> AsyncGenerator[Connection | PoolConnectionProxy, None]:
+    async def provide_connection(self, *args: Any, **kwargs: Any) -> AsyncGenerator[PoolConnectionProxy, None]:
         """Create a connection instance.
 
         Returns:

sqlspec/adapters/duckdb/__init__.py

@@ -0,0 +1,3 @@
+from sqlspec.adapters.duckdb.config import DuckDBConfig
+
+__all__ = ("DuckDBConfig",)

sqlspec/adapters/duckdb/config.py

@@ -4,14 +4,15 @@ from contextlib import contextmanager
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, cast
 
-from sqlspec.config import GenericDatabaseConfig
+from duckdb import DuckDBPyConnection
+
+from sqlspec.base import NoPoolSyncConfig
 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")
 
@@ -23,21 +24,21 @@ class ExtensionConfig:
     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
+    For details see: https://duckdb.org/docs/extensions/overview
     """
 
     name: str
+    """The name of the extension to install"""
     config: dict[str, Any] | None = None
+    """Optional configuration settings to apply after installation"""
     force_install: bool = False
+    """Whether to force reinstall if already present"""
     repository: str | None = None
+    """Optional repository name to install from"""
     repository_url: str | None = None
+    """Optional repository URL to install from"""
     version: str | None = None
+    """Optional version of the extension to install"""
 
     @classmethod
     def from_dict(cls, name: str, config: dict[str, Any] | bool | None = None) -> ExtensionConfig:
@@ -65,7 +66,7 @@ class ExtensionConfig:
 
 
 @dataclass
-class DuckDBConfig(GenericDatabaseConfig):
+class DuckDBConfig(NoPoolSyncConfig[DuckDBPyConnection]):
     """Configuration for DuckDB database connections.
 
     This class provides configuration options for DuckDB database connections, wrapping all parameters
@@ -114,13 +115,13 @@ class DuckDBConfig(GenericDatabaseConfig):
             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}
+            _e = {str(ext): {"force_install": False} for ext in _e}  # pyright: ignore[reportUnknownVariableType,reportUnknownArgumentType]
 
-        if len(set(_e.keys()).intersection({ext.name for ext in self.extensions})) > 0:
+        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)
 
-        self.extensions.extend([ExtensionConfig.from_dict(name, ext_config) for name, ext_config in _e.items()])
+        self.extensions.extend([ExtensionConfig.from_dict(name, ext_config) for name, ext_config in _e.items()])  # pyright: ignore[reportUnknownArgumentType,reportUnknownVariableType]
 
     def _configure_extensions(self, connection: DuckDBPyConnection) -> None:
         """Configure extensions for the connection.
@@ -177,7 +178,7 @@ class DuckDBConfig(GenericDatabaseConfig):
         import duckdb
 
         try:
-            connection = duckdb.connect(**self.connection_config_dict)
+            connection = duckdb.connect(**self.connection_config_dict)  # pyright: ignore[reportUnknownMemberType]
             self._configure_extensions(connection)
             return connection
         except Exception as e:

sqlspec/adapters/oracledb/__init__.py

@@ -1,4 +1,4 @@
-from .config import (
+from sqlspec.adapters.oracledb.config import (
     OracleAsyncDatabaseConfig,
     OracleAsyncPoolConfig,
     OracleSyncDatabaseConfig,

sqlspec/adapters/oracledb/config/_asyncio.py

@@ -4,14 +4,14 @@ from contextlib import asynccontextmanager
 from dataclasses import dataclass
 from typing import TYPE_CHECKING
 
-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
 
@@ -26,13 +26,23 @@ __all__ = (
 
 
 @dataclass
-class OracleAsyncPoolConfig(OracleGenericPoolConfig[AsyncConnectionPool, AsyncConnection]):
+class OracleAsyncPoolConfig(OracleGenericPoolConfig[AsyncConnection, AsyncConnectionPool]):
     """Async Oracle Pool Config"""
 
 
 @dataclass
-class OracleAsyncDatabaseConfig(OracleGenericDatabaseConfig[AsyncConnectionPool, AsyncConnection]):
-    """Async Oracle database Configuration."""
+class OracleAsyncDatabaseConfig(AsyncDatabaseConfig[AsyncConnection, AsyncConnectionPool]):
+    """Oracle Async database Configuration.
+
+    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
     """Oracle Pool configuration"""
@@ -70,7 +80,7 @@ class OracleAsyncDatabaseConfig(OracleGenericDatabaseConfig[AsyncConnectionPool,
 
         pool_config = self.pool_config_dict
         self.pool_instance = oracledb_create_pool(**pool_config)
-        if self.pool_instance is None:
+        if self.pool_instance is None:  # pyright: ignore[reportUnnecessaryComparison]
             msg = "Could not configure the 'pool_instance'. Please check your configuration."
             raise ImproperConfigurationError(msg)
         return self.pool_instance
@@ -91,5 +101,5 @@ class OracleAsyncDatabaseConfig(OracleGenericDatabaseConfig[AsyncConnectionPool,
             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

sqlspec/adapters/oracledb/config/_common.py

@@ -5,7 +5,7 @@ from typing import TYPE_CHECKING, Generic, TypeVar
 
 from oracledb import ConnectionPool
 
-from sqlspec.config import GenericDatabaseConfig, GenericPoolConfig
+from sqlspec.base import GenericPoolConfig
 from sqlspec.typing import Empty
 
 if TYPE_CHECKING:
@@ -19,10 +19,7 @@ if TYPE_CHECKING:
 
     from sqlspec.typing import EmptyType
 
-__all__ = (
-    "OracleGenericDatabaseConfig",
-    "OracleGenericPoolConfig",
-)
+__all__ = ("OracleGenericPoolConfig",)
 
 
 T = TypeVar("T")
@@ -32,7 +29,7 @@ PoolT = TypeVar("PoolT", bound="ConnectionPool | AsyncConnectionPool")
 
 
 @dataclass
-class OracleGenericPoolConfig(Generic[PoolT, ConnectionT], GenericPoolConfig):
+class OracleGenericPoolConfig(Generic[ConnectionT, PoolT], GenericPoolConfig):
     """Configuration for Oracle database connection pools.
 
     This class provides configuration options for both synchronous and asynchronous Oracle
@@ -58,7 +55,7 @@ class OracleGenericPoolConfig(Generic[PoolT, ConnectionT], GenericPoolConfig):
     """New password for password change operations"""
     wallet_password: str | EmptyType = Empty
     """Password for accessing Oracle Wallet"""
-    access_token: str | tuple | Callable | EmptyType = Empty
+    access_token: str | tuple[str, ...] | Callable[[], str] | EmptyType = Empty
     """Token for token-based authentication"""
     host: str | EmptyType = Empty
     """Database server hostname"""
@@ -112,11 +109,11 @@ class OracleGenericPoolConfig(Generic[PoolT, ConnectionT], GenericPoolConfig):
     """If True, allows connections with different tags"""
     config_dir: str | EmptyType = Empty
     """Directory containing Oracle configuration files"""
-    appcontext: list | EmptyType = Empty
+    appcontext: list[str] | EmptyType = Empty
     """Application context list"""
-    shardingkey: list | EmptyType = Empty
+    shardingkey: list[str] | EmptyType = Empty
     """Sharding key list"""
-    supershardingkey: list | EmptyType = Empty
+    supershardingkey: list[str] | EmptyType = Empty
     """Super sharding key list"""
     debug_jdwp: str | EmptyType = Empty
     """JDWP debugging string"""
@@ -134,18 +131,3 @@ class OracleGenericPoolConfig(Generic[PoolT, ConnectionT], GenericPoolConfig):
     """SSL/TLS protocol version"""
     handle: int | EmptyType = Empty
     """Oracle service context handle"""
-
-
-@dataclass
-class OracleGenericDatabaseConfig(Generic[PoolT, ConnectionT], GenericDatabaseConfig):
-    """Oracle database Configuration.
-
-    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))
-    """

sqlspec/adapters/oracledb/config/_sync.py

@@ -4,14 +4,14 @@ from contextlib import contextmanager
 from dataclasses import dataclass
 from typing import TYPE_CHECKING
 
-from oracledb import create_pool as oracledb_create_pool
+from oracledb import create_pool as oracledb_create_pool  # pyright: ignore[reportUnknownVariableType]
 from oracledb.connection import Connection
 from oracledb.pool import ConnectionPool
 
 from sqlspec.adapters.oracledb.config._common import (
-    OracleGenericDatabaseConfig,
     OracleGenericPoolConfig,
 )
+from sqlspec.base import SyncDatabaseConfig
 from sqlspec.exceptions import ImproperConfigurationError
 from sqlspec.typing import dataclass_to_dict
 
@@ -26,13 +26,23 @@ __all__ = (
 
 
 @dataclass
-class OracleSyncPoolConfig(OracleGenericPoolConfig[ConnectionPool, Connection]):
+class OracleSyncPoolConfig(OracleGenericPoolConfig[Connection, ConnectionPool]):
     """Sync Oracle Pool Config"""
 
 
 @dataclass
-class OracleSyncDatabaseConfig(OracleGenericDatabaseConfig[ConnectionPool, Connection]):
-    """Oracle database Configuration."""
+class OracleSyncDatabaseConfig(SyncDatabaseConfig[Connection, ConnectionPool]):
+    """Oracle Sync database Configuration.
+
+    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: OracleSyncPoolConfig | None = None
     """Oracle Pool configuration"""
@@ -70,7 +80,7 @@ class OracleSyncDatabaseConfig(OracleGenericDatabaseConfig[ConnectionPool, Conne
 
         pool_config = self.pool_config_dict
         self.pool_instance = oracledb_create_pool(**pool_config)
-        if self.pool_instance is None:
+        if self.pool_instance is None:  # pyright: ignore[reportUnnecessaryComparison]
             msg = "Could not configure the 'pool_instance'. Please check your configuration."
             raise ImproperConfigurationError(msg)
         return self.pool_instance
@@ -91,5 +101,5 @@ class OracleSyncDatabaseConfig(OracleGenericDatabaseConfig[ConnectionPool, Conne
             A connection instance.
         """
         db_pool = self.provide_pool(*args, **kwargs)
-        with db_pool.acquire() as connection:
+        with db_pool.acquire() as connection:  # pyright: ignore[reportUnknownMemberType]
             yield connection

sqlspec/adapters/psycopg/config/__init__.py

@@ -1,5 +1,5 @@
-from ._async import PsycoPgAsyncDatabaseConfig, PsycoPgAsyncPoolConfig
-from ._sync import PsycoPgSyncDatabaseConfig, PsycoPgSyncPoolConfig
+from sqlspec.adapters.psycopg.config._async import PsycoPgAsyncDatabaseConfig, PsycoPgAsyncPoolConfig
+from sqlspec.adapters.psycopg.config._sync import PsycoPgSyncDatabaseConfig, PsycoPgSyncPoolConfig
 
 __all__ = (
     "PsycoPgAsyncDatabaseConfig",

sqlspec/adapters/psycopg/config/_async.py

@@ -7,10 +7,8 @@ from typing import TYPE_CHECKING
 from psycopg import AsyncConnection
 from psycopg_pool import AsyncConnectionPool
 
-from sqlspec.adapters.psycopg.config._common import (
-    PsycoPgGenericDatabaseConfig,
-    PsycoPgGenericPoolConfig,
-)
+from sqlspec.adapters.psycopg.config._common import PsycoPgGenericPoolConfig
+from sqlspec.base import AsyncDatabaseConfig
 from sqlspec.exceptions import ImproperConfigurationError
 from sqlspec.typing import dataclass_to_dict
 
@@ -26,13 +24,20 @@ __all__ = (
 
 
 @dataclass
-class PsycoPgAsyncPoolConfig(PsycoPgGenericPoolConfig[AsyncConnectionPool, AsyncConnection]):
+class PsycoPgAsyncPoolConfig(PsycoPgGenericPoolConfig[AsyncConnection, AsyncConnectionPool]):
     """Async Psycopg Pool Config"""
 
 
 @dataclass
-class PsycoPgAsyncDatabaseConfig(PsycoPgGenericDatabaseConfig[AsyncConnectionPool, AsyncConnection]):
-    """Async Psycopg database Configuration."""
+class PsycoPgAsyncDatabaseConfig(AsyncDatabaseConfig[AsyncConnection, AsyncConnectionPool]):
+    """Async Psycopg database Configuration.
+
+    This class provides the base configuration for Psycopg database connections, extending
+    the generic database configuration with Psycopg-specific settings.([1](https://www.psycopg.org/psycopg3/docs/api/connections.html))
+
+    The configuration supports all standard Psycopg connection parameters and can be used
+    with both synchronous and asynchronous connections.([2](https://www.psycopg.org/psycopg3/docs/api/connections.html))
+    """
 
     pool_config: PsycoPgAsyncPoolConfig | None = None
     """Psycopg Pool configuration"""
@@ -58,7 +63,7 @@ class PsycoPgAsyncDatabaseConfig(PsycoPgGenericDatabaseConfig[AsyncConnectionPoo
 
         pool_config = self.pool_config_dict
         self.pool_instance = AsyncConnectionPool(**pool_config)
-        if self.pool_instance is None:
+        if self.pool_instance is None:  # pyright: ignore[reportUnnecessaryComparison]
             msg = "Could not configure the 'pool_instance'. Please check your configuration."  # type: ignore[unreachable]
             raise ImproperConfigurationError(msg)
         return self.pool_instance

sqlspec/adapters/psycopg/config/_common.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Generic, TypeVar
 
-from sqlspec.config import GenericDatabaseConfig, GenericPoolConfig
+from sqlspec.base import GenericPoolConfig
 from sqlspec.typing import Empty
 
 if TYPE_CHECKING:
@@ -16,10 +16,7 @@ if TYPE_CHECKING:
     from sqlspec.typing import EmptyType
 
 
-__all__ = (
-    "PsycoPgGenericDatabaseConfig",
-    "PsycoPgGenericPoolConfig",
-)
+__all__ = ("PsycoPgGenericPoolConfig",)
 
 
 ConnectionT = TypeVar("ConnectionT", bound="Connection | AsyncConnection")
@@ -27,7 +24,7 @@ PoolT = TypeVar("PoolT", bound="ConnectionPool | AsyncConnectionPool")
 
 
 @dataclass
-class PsycoPgGenericPoolConfig(Generic[PoolT, ConnectionT], GenericPoolConfig):
+class PsycoPgGenericPoolConfig(Generic[ConnectionT, PoolT], GenericPoolConfig):
     """Configuration for Psycopg connection pools.
 
     This class provides configuration options for both synchronous and asynchronous Psycopg
@@ -59,15 +56,3 @@ class PsycoPgGenericPoolConfig(Generic[PoolT, ConnectionT], GenericPoolConfig):
     """Number of background workers"""
     configure: Callable[[ConnectionT], None] | EmptyType = Empty
     """Callback to configure new connections"""
-
-
-@dataclass
-class PsycoPgGenericDatabaseConfig(Generic[PoolT, ConnectionT], GenericDatabaseConfig):
-    """Psycopg database Configuration.
-
-    This class provides the base configuration for Psycopg database connections, extending
-    the generic database configuration with Psycopg-specific settings.([1](https://www.psycopg.org/psycopg3/docs/api/connections.html))
-
-    The configuration supports all standard Psycopg connection parameters and can be used
-    with both synchronous and asynchronous connections.([2](https://www.psycopg.org/psycopg3/docs/api/connections.html))
-    """