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

sqlspec/adapters/oracledb/config/_common.py

@@ -1,11 +1,9 @@
-from __future__ import annotations
-
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Generic, TypeVar
+from typing import TYPE_CHECKING, Generic, TypeVar, Union
 
 from oracledb import ConnectionPool
 
-from sqlspec.base import DatabaseConfigProtocol, GenericDatabaseConfig, GenericPoolConfig
+from sqlspec.base import GenericPoolConfig
 from sqlspec.typing import Empty
 
 if TYPE_CHECKING:
@@ -19,16 +17,13 @@ if TYPE_CHECKING:
 
     from sqlspec.typing import EmptyType
 
-__all__ = (
-    "OracleGenericDatabaseConfig",
-    "OracleGenericPoolConfig",
-)
+__all__ = ("OracleGenericPoolConfig",)
 
 
 T = TypeVar("T")
 
-ConnectionT = TypeVar("ConnectionT", bound="Connection | AsyncConnection")
-PoolT = TypeVar("PoolT", bound="ConnectionPool | AsyncConnectionPool")
+ConnectionT = TypeVar("ConnectionT", bound="Union[Connection, AsyncConnection]")
+PoolT = TypeVar("PoolT", bound="Union[ConnectionPool, AsyncConnectionPool]")
 
 
 @dataclass
@@ -40,112 +35,97 @@ class OracleGenericPoolConfig(Generic[ConnectionT, PoolT], GenericPoolConfig):
     settings.([1](https://python-oracledb.readthedocs.io/en/latest/api_manual/module.html))
     """
 
-    conn_class: type[ConnectionT] | EmptyType = Empty
+    conn_class: "Union[type[ConnectionT], EmptyType]" = Empty
     """The connection class to use (Connection or AsyncConnection)"""
-    dsn: str | EmptyType = Empty
+    dsn: "Union[str, EmptyType]" = Empty
     """Connection string for the database   """
-    pool: PoolT | EmptyType = Empty
+    pool: "Union[PoolT, EmptyType]" = Empty
     """Existing pool instance to use"""
-    params: ConnectParams | EmptyType = Empty
+    params: "Union[ConnectParams, EmptyType]" = Empty
     """Connection parameters object"""
-    user: str | EmptyType = Empty
+    user: "Union[str, EmptyType]" = Empty
     """Username for database authentication"""
-    proxy_user: str | EmptyType = Empty
+    proxy_user: "Union[str, EmptyType]" = Empty
     """Name of the proxy user to connect through"""
-    password: str | EmptyType = Empty
+    password: "Union[str, EmptyType]" = Empty
     """Password for database authentication"""
-    newpassword: str | EmptyType = Empty
+    newpassword: "Union[str, EmptyType]" = Empty
     """New password for password change operations"""
-    wallet_password: str | EmptyType = Empty
+    wallet_password: "Union[str, EmptyType]" = Empty
     """Password for accessing Oracle Wallet"""
-    access_token: str | tuple[str, ...] | Callable[[], str] | EmptyType = Empty
+    access_token: "Union[str, tuple[str, ...], Callable[[], str], EmptyType]" = Empty
     """Token for token-based authentication"""
-    host: str | EmptyType = Empty
+    host: "Union[str, EmptyType]" = Empty
     """Database server hostname"""
-    port: int | EmptyType = Empty
+    port: "Union[int, EmptyType]" = Empty
     """Database server port number"""
-    protocol: str | EmptyType = Empty
+    protocol: "Union[str, EmptyType]" = Empty
     """Network protocol (TCP or TCPS)"""
-    https_proxy: str | EmptyType = Empty
+    https_proxy: "Union[str, EmptyType]" = Empty
     """HTTPS proxy server address"""
-    https_proxy_port: int | EmptyType = Empty
+    https_proxy_port: "Union[int, EmptyType]" = Empty
     """HTTPS proxy server port"""
-    service_name: str | EmptyType = Empty
+    service_name: "Union[str, EmptyType]" = Empty
     """Oracle service name"""
-    sid: str | EmptyType = Empty
+    sid: "Union[str, EmptyType]" = Empty
     """Oracle System ID (SID)"""
-    server_type: str | EmptyType = Empty
+    server_type: "Union[str, EmptyType]" = Empty
     """Server type (dedicated, shared, pooled, or drcp)"""
-    cclass: str | EmptyType = Empty
+    cclass: "Union[str, EmptyType]" = Empty
     """Connection class for database resident connection pooling"""
-    purity: Purity | EmptyType = Empty
+    purity: "Union[Purity, EmptyType]" = Empty
     """Session purity (NEW, SELF, or DEFAULT)"""
-    expire_time: int | EmptyType = Empty
+    expire_time: "Union[int, EmptyType]" = Empty
     """Time in minutes after which idle connections are closed"""
-    retry_count: int | EmptyType = Empty
+    retry_count: "Union[int, EmptyType]" = Empty
     """Number of attempts to connect"""
-    retry_delay: int | EmptyType = Empty
+    retry_delay: "Union[int, EmptyType]" = Empty
     """Time in seconds between connection attempts"""
-    tcp_connect_timeout: float | EmptyType = Empty
+    tcp_connect_timeout: "Union[float, EmptyType]" = Empty
     """Timeout for establishing TCP connections"""
-    ssl_server_dn_match: bool | EmptyType = Empty
+    ssl_server_dn_match: "Union[bool, EmptyType]" = Empty
     """If True, verify server certificate DN"""
-    ssl_server_cert_dn: str | EmptyType = Empty
+    ssl_server_cert_dn: "Union[str, EmptyType]" = Empty
     """Expected server certificate DN"""
-    wallet_location: str | EmptyType = Empty
+    wallet_location: "Union[str, EmptyType]" = Empty
     """Location of Oracle Wallet"""
-    events: bool | EmptyType = Empty
+    events: "Union[bool, EmptyType]" = Empty
     """If True, enables Oracle events for FAN and RLB"""
-    externalauth: bool | EmptyType = Empty
+    externalauth: "Union[bool, EmptyType]" = Empty
     """If True, uses external authentication"""
-    mode: AuthMode | EmptyType = Empty
+    mode: "Union[AuthMode, EmptyType]" = Empty
     """Session mode (SYSDBA, SYSOPER, etc.)"""
-    disable_oob: bool | EmptyType = Empty
+    disable_oob: "Union[bool, EmptyType]" = Empty
     """If True, disables Oracle out-of-band breaks"""
-    stmtcachesize: int | EmptyType = Empty
+    stmtcachesize: "Union[int, EmptyType]" = Empty
     """Size of the statement cache"""
-    edition: str | EmptyType = Empty
+    edition: "Union[str, EmptyType]" = Empty
     """Edition name for edition-based redefinition"""
-    tag: str | EmptyType = Empty
+    tag: "Union[str, EmptyType]" = Empty
     """Connection pool tag"""
-    matchanytag: bool | EmptyType = Empty
+    matchanytag: "Union[bool, EmptyType]" = Empty
     """If True, allows connections with different tags"""
-    config_dir: str | EmptyType = Empty
+    config_dir: "Union[str, EmptyType]" = Empty
     """Directory containing Oracle configuration files"""
-    appcontext: list[str] | EmptyType = Empty
+    appcontext: "Union[list[str], EmptyType]" = Empty
     """Application context list"""
-    shardingkey: list[str] | EmptyType = Empty
+    shardingkey: "Union[list[str], EmptyType]" = Empty
     """Sharding key list"""
-    supershardingkey: list[str] | EmptyType = Empty
+    supershardingkey: "Union[list[str], EmptyType]" = Empty
     """Super sharding key list"""
-    debug_jdwp: str | EmptyType = Empty
+    debug_jdwp: "Union[str, EmptyType]" = Empty
     """JDWP debugging string"""
-    connection_id_prefix: str | EmptyType = Empty
+    connection_id_prefix: "Union[str, EmptyType]" = Empty
     """Prefix for connection identifiers"""
-    ssl_context: Any | EmptyType = Empty
+    ssl_context: "Union[Any, EmptyType]" = Empty
     """SSL context for TCPS connections"""
-    sdu: int | EmptyType = Empty
+    sdu: "Union[int, EmptyType]" = Empty
     """Session data unit size"""
-    pool_boundary: str | EmptyType = Empty
+    pool_boundary: "Union[str, EmptyType]" = Empty
     """Connection pool boundary (statement or transaction)"""
-    use_tcp_fast_open: bool | EmptyType = Empty
+    use_tcp_fast_open: "Union[bool, EmptyType]" = Empty
     """If True, enables TCP Fast Open"""
-    ssl_version: ssl.TLSVersion | EmptyType = Empty
+    ssl_version: "Union[ssl.TLSVersion, EmptyType]" = Empty
     """SSL/TLS protocol version"""
-    handle: int | EmptyType = Empty
+    handle: "Union[int, EmptyType]" = Empty
     """Oracle service context handle"""
-
-
-@dataclass
-class OracleGenericDatabaseConfig(DatabaseConfigProtocol[ConnectionT, PoolT], 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

@@ -1,17 +1,15 @@
-from __future__ import annotations
-
 from contextlib import contextmanager
 from dataclasses import dataclass
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any, Optional
 
-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
 
@@ -31,22 +29,29 @@ class OracleSyncPoolConfig(OracleGenericPoolConfig[Connection, ConnectionPool]):
 
 
 @dataclass
-class OracleSyncDatabaseConfig(OracleGenericDatabaseConfig[Connection, ConnectionPool]):
-    """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))
 
-    __is_async__ = False
-    __supports_connection_pooling__ = True
+    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
+    pool_config: "Optional[OracleSyncPoolConfig]" = None
     """Oracle Pool configuration"""
-    pool_instance: ConnectionPool | None = None
+    pool_instance: "Optional[ConnectionPool]" = 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 OracleSyncDatabaseConfig(OracleGenericDatabaseConfig[Connection, Connectio
         msg = "'pool_config' methods can not be used when a 'pool_instance' is provided."
         raise ImproperConfigurationError(msg)
 
-    def create_pool(self) -> ConnectionPool:
+    def create_pool(self) -> "ConnectionPool":
         """Return a pool. If none exists yet, create one.
 
         Returns:
@@ -74,11 +79,11 @@ class OracleSyncDatabaseConfig(OracleGenericDatabaseConfig[Connection, Connectio
         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) -> ConnectionPool:
+    def provide_pool(self, *args: "Any", **kwargs: "Any") -> "ConnectionPool":
         """Create a pool instance.
 
         Returns:
@@ -87,7 +92,7 @@ class OracleSyncDatabaseConfig(OracleGenericDatabaseConfig[Connection, Connectio
         return self.create_pool()
 
     @contextmanager
-    def provide_connection(self, *args: Any, **kwargs: Any) -> Generator[Connection, None, None]:
+    def provide_connection(self, *args: "Any", **kwargs: "Any") -> "Generator[Connection, None, None]":
         """Create a connection instance.
 
         Returns:

sqlspec/adapters/psycopg/config/_async.py

@@ -1,16 +1,12 @@
-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 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
 
@@ -31,26 +27,30 @@ class PsycoPgAsyncPoolConfig(PsycoPgGenericPoolConfig[AsyncConnection, AsyncConn
 
 
 @dataclass
-class PsycoPgAsyncDatabaseConfig(PsycoPgGenericDatabaseConfig[AsyncConnection, AsyncConnectionPool]):
-    """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))
 
-    __is_async__ = True
-    __supports_connection_pooling__ = True
+    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
+    pool_config: "Optional[PsycoPgAsyncPoolConfig]" = None
     """Psycopg Pool configuration"""
-    pool_instance: AsyncConnectionPool | None = None
+    pool_instance: "Optional[AsyncConnectionPool]" = None
     """Optional pool to use"""
 
     @property
-    def pool_config_dict(self) -> dict[str, Any]:
+    def pool_config_dict(self) -> "dict[str, Any]":
         """Return the pool configuration as a dict."""
         if self.pool_config:
             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)
 
-    async def create_pool(self) -> AsyncConnectionPool:
+    async def create_pool(self) -> "AsyncConnectionPool":
         """Create and return a connection pool."""
         if self.pool_instance is not None:
             return self.pool_instance
@@ -66,12 +66,12 @@ class PsycoPgAsyncDatabaseConfig(PsycoPgGenericDatabaseConfig[AsyncConnection, A
             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 and return a connection pool."""
         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 and provide a database connection."""
         pool = await self.provide_pool(*args, **kwargs)
         async with pool.connection() as connection:

sqlspec/adapters/psycopg/config/_common.py

@@ -1,9 +1,7 @@
-from __future__ import annotations
-
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Generic, TypeVar
+from typing import TYPE_CHECKING, Generic, TypeVar, Union
 
-from sqlspec.base import DatabaseConfigProtocol, GenericDatabaseConfig, GenericPoolConfig
+from sqlspec.base import GenericPoolConfig
 from sqlspec.typing import Empty
 
 if TYPE_CHECKING:
@@ -16,14 +14,11 @@ if TYPE_CHECKING:
     from sqlspec.typing import EmptyType
 
 
-__all__ = (
-    "PsycoPgGenericDatabaseConfig",
-    "PsycoPgGenericPoolConfig",
-)
+__all__ = ("PsycoPgGenericPoolConfig",)
 
 
-ConnectionT = TypeVar("ConnectionT", bound="Connection | AsyncConnection")
-PoolT = TypeVar("PoolT", bound="ConnectionPool | AsyncConnectionPool")
+ConnectionT = TypeVar("ConnectionT", bound="Union[Connection, AsyncConnection]")
+PoolT = TypeVar("PoolT", bound="Union[ConnectionPool, AsyncConnectionPool]")
 
 
 @dataclass
@@ -35,39 +30,27 @@ class PsycoPgGenericPoolConfig(Generic[ConnectionT, PoolT], GenericPoolConfig):
     settings.([1](https://www.psycopg.org/psycopg3/docs/api/pool.html))
     """
 
-    conninfo: str | EmptyType = Empty
+    conninfo: "Union[str, EmptyType]" = Empty
     """Connection string in libpq format"""
-    kwargs: dict[str, Any] | EmptyType = Empty
+    kwargs: "Union[dict[str, Any], EmptyType]" = Empty
     """Additional connection parameters"""
-    min_size: int | EmptyType = Empty
+    min_size: "Union[int, EmptyType]" = Empty
     """Minimum number of connections in the pool"""
-    max_size: int | EmptyType = Empty
+    max_size: "Union[int, EmptyType]" = Empty
     """Maximum number of connections in the pool"""
-    name: str | EmptyType = Empty
+    name: "Union[str, EmptyType]" = Empty
     """Name of the connection pool"""
-    timeout: float | EmptyType = Empty
+    timeout: "Union[float, EmptyType]" = Empty
     """Timeout for acquiring connections"""
-    max_waiting: int | EmptyType = Empty
+    max_waiting: "Union[int, EmptyType]" = Empty
     """Maximum number of waiting clients"""
-    max_lifetime: float | EmptyType = Empty
+    max_lifetime: "Union[float, EmptyType]" = Empty
     """Maximum connection lifetime"""
-    max_idle: float | EmptyType = Empty
+    max_idle: "Union[float, EmptyType]" = Empty
     """Maximum idle time for connections"""
-    reconnect_timeout: float | EmptyType = Empty
+    reconnect_timeout: "Union[float, EmptyType]" = Empty
     """Time between reconnection attempts"""
-    num_workers: int | EmptyType = Empty
+    num_workers: "Union[int, EmptyType]" = Empty
     """Number of background workers"""
-    configure: Callable[[ConnectionT], None] | EmptyType = Empty
+    configure: "Union[Callable[[ConnectionT], None], EmptyType]" = Empty
     """Callback to configure new connections"""
-
-
-@dataclass
-class PsycoPgGenericDatabaseConfig(DatabaseConfigProtocol[ConnectionT, PoolT], 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))
-    """

sqlspec/adapters/psycopg/config/_sync.py

@@ -1,16 +1,12 @@
-from __future__ import annotations
-
 from contextlib import contextmanager
 from dataclasses import dataclass
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any, Optional
 
 from psycopg import Connection
 from psycopg_pool import ConnectionPool
 
-from sqlspec.adapters.psycopg.config._common import (
-    PsycoPgGenericDatabaseConfig,
-    PsycoPgGenericPoolConfig,
-)
+from sqlspec.adapters.psycopg.config._common import PsycoPgGenericPoolConfig
+from sqlspec.base import SyncDatabaseConfig
 from sqlspec.exceptions import ImproperConfigurationError
 from sqlspec.typing import dataclass_to_dict
 
@@ -31,26 +27,29 @@ class PsycoPgSyncPoolConfig(PsycoPgGenericPoolConfig[Connection, ConnectionPool]
 
 
 @dataclass
-class PsycoPgSyncDatabaseConfig(PsycoPgGenericDatabaseConfig[Connection, ConnectionPool]):
-    """Sync Psycopg database Configuration."""
+class PsycoPgSyncDatabaseConfig(SyncDatabaseConfig[Connection, ConnectionPool]):
+    """Sync 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))
 
-    __is_async__ = False
-    __supports_connection_pooling__ = True
+    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: PsycoPgSyncPoolConfig | None = None
+    pool_config: "Optional[PsycoPgSyncPoolConfig]" = None
     """Psycopg Pool configuration"""
-    pool_instance: ConnectionPool | None = None
+    pool_instance: "Optional[ConnectionPool]" = None
     """Optional pool to use"""
 
     @property
-    def pool_config_dict(self) -> dict[str, Any]:
+    def pool_config_dict(self) -> "dict[str, Any]":
         """Return the pool configuration as a dict."""
         if self.pool_config:
             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)
 
-    def create_pool(self) -> ConnectionPool:
+    def create_pool(self) -> "ConnectionPool":
         """Create and return a connection pool."""
         if self.pool_instance is not None:
             return self.pool_instance
@@ -66,12 +65,12 @@ class PsycoPgSyncDatabaseConfig(PsycoPgGenericDatabaseConfig[Connection, Connect
             raise ImproperConfigurationError(msg)
         return self.pool_instance
 
-    def provide_pool(self, *args: Any, **kwargs: Any) -> ConnectionPool:
+    def provide_pool(self, *args: "Any", **kwargs: "Any") -> "ConnectionPool":
         """Create and return a connection pool."""
         return self.create_pool()
 
     @contextmanager
-    def provide_connection(self, *args: Any, **kwargs: Any) -> Generator[Connection, None, None]:
+    def provide_connection(self, *args: "Any", **kwargs: "Any") -> "Generator[Connection, None, None]":
         """Create and provide a database connection."""
         pool = self.provide_pool(*args, **kwargs)
         with pool.connection() as connection:

sqlspec/adapters/sqlite/config.py

@@ -1,10 +1,8 @@
-from __future__ import annotations
-
 from contextlib import contextmanager
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Literal
+from typing import TYPE_CHECKING, Any, Literal, Optional, Union
 
-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
 
@@ -16,7 +14,7 @@ __all__ = ("SqliteConfig",)
 
 
 @dataclass
-class SqliteConfig(NoPoolConfig["Connection"], GenericDatabaseConfig):
+class SqliteConfig(NoPoolSyncConfig["Connection"]):
     """Configuration for SQLite database connections.
 
     This class provides configuration options for SQLite database connections, wrapping all parameters
@@ -28,29 +26,29 @@ class SqliteConfig(NoPoolConfig["Connection"], GenericDatabaseConfig):
     database: str = ":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: "Union[float, EmptyType]" = 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: "Union[int, EmptyType]" = 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: "Optional[Union[Literal['DEFERRED', 'IMMEDIATE', 'EXCLUSIVE'], EmptyType]]" = 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: "Union[bool, EmptyType]" = 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[Connection] | EmptyType = Empty
+    factory: "Union[type[Connection], EmptyType]" = Empty
     """A custom Connection class factory. If given, must be a callable that returns a Connection instance."""
 
-    cached_statements: int | EmptyType = Empty
+    cached_statements: "Union[int, EmptyType]" = Empty
     """The number of statements that SQLite will cache for this connection. The default is 128."""
 
-    uri: bool | EmptyType = Empty
+    uri: "Union[bool, EmptyType]" = Empty
     """If set to True, database is interpreted as a URI with supported options."""
 
     @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:
@@ -58,7 +56,7 @@ class SqliteConfig(NoPoolConfig["Connection"], GenericDatabaseConfig):
         """
         return dataclass_to_dict(self, exclude_empty=True, convert_nested=False)
 
-    def create_connection(self) -> Connection:
+    def create_connection(self) -> "Connection":
         """Create and return a new database connection.
 
         Returns:
@@ -76,7 +74,7 @@ class SqliteConfig(NoPoolConfig["Connection"], GenericDatabaseConfig):
             raise ImproperConfigurationError(msg) from e
 
     @contextmanager
-    def provide_connection(self, *args: Any, **kwargs: Any) -> Generator[Connection, None, None]:
+    def provide_connection(self, *args: "Any", **kwargs: "Any") -> "Generator[Connection, None, None]":
         """Create and provide a database connection.
 
         Yields: