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

sqlspec/adapters/oracledb/config/_sync.py

@@ -1,8 +1,6 @@
-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  # pyright: ignore[reportUnknownVariableType]
 from oracledb.connection import Connection
@@ -44,16 +42,16 @@ class OracleSyncDatabaseConfig(SyncDatabaseConfig[Connection, ConnectionPool]):
     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:
@@ -65,7 +63,7 @@ class OracleSyncDatabaseConfig(SyncDatabaseConfig[Connection, ConnectionPool]):
         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:
@@ -81,11 +79,11 @@ class OracleSyncDatabaseConfig(SyncDatabaseConfig[Connection, ConnectionPool]):
         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:
@@ -94,7 +92,7 @@ class OracleSyncDatabaseConfig(SyncDatabaseConfig[Connection, ConnectionPool]):
         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,8 +1,6 @@
-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
@@ -39,20 +37,20 @@ class PsycoPgAsyncDatabaseConfig(AsyncDatabaseConfig[AsyncConnection, AsyncConne
     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
@@ -68,12 +66,12 @@ class PsycoPgAsyncDatabaseConfig(AsyncDatabaseConfig[AsyncConnection, AsyncConne
             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,7 +1,5 @@
-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 GenericPoolConfig
 from sqlspec.typing import Empty
@@ -19,8 +17,8 @@ if TYPE_CHECKING:
 __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
@@ -32,27 +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"""

sqlspec/adapters/psycopg/config/_sync.py

@@ -1,8 +1,6 @@
-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
@@ -38,20 +36,20 @@ class PsycoPgSyncDatabaseConfig(SyncDatabaseConfig[Connection, ConnectionPool]):
     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
@@ -67,12 +65,12 @@ class PsycoPgSyncDatabaseConfig(SyncDatabaseConfig[Connection, ConnectionPool]):
             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,8 +1,6 @@
-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 NoPoolSyncConfig
 from sqlspec.exceptions import ImproperConfigurationError
@@ -28,29 +26,29 @@ class SqliteConfig(NoPoolSyncConfig["Connection"]):
     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(NoPoolSyncConfig["Connection"]):
         """
         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(NoPoolSyncConfig["Connection"]):
             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:

sqlspec/base.py

@@ -36,7 +36,9 @@ class DatabaseConfigProtocol(Generic[ConnectionT, PoolT], ABC):
 
     @abstractmethod
     def provide_connection(
-        self, *args: Any, **kwargs: Any
+        self,
+        *args: Any,
+        **kwargs: Any,
     ) -> Union[
         Generator[ConnectionT, None, None],
         AsyncGenerator[ConnectionT, None],
@@ -59,7 +61,9 @@ class DatabaseConfigProtocol(Generic[ConnectionT, PoolT], ABC):
 
     @abstractmethod
     def provide_pool(
-        self, *args: Any, **kwargs: Any
+        self,
+        *args: Any,
+        **kwargs: Any,
     ) -> Union[PoolT, Awaitable[PoolT], AbstractContextManager[PoolT], AbstractAsyncContextManager[PoolT]]:
         """Provide pool instance."""
         raise NotImplementedError
@@ -157,12 +161,14 @@ class ConfigManager:
     def get_config(self, name: type[AsyncConfigT]) -> AsyncConfigT: ...
 
     def get_config(
-        self, name: Union[type[DatabaseConfigProtocol[ConnectionT, PoolT]], Any]
+        self,
+        name: Union[type[DatabaseConfigProtocol[ConnectionT, PoolT]], Any],
     ) -> DatabaseConfigProtocol[ConnectionT, PoolT]:
         """Retrieve a configuration by its type."""
         config = self._configs.get(name)
         if not config:
-            raise KeyError(f"No configuration found for {name}")
+            msg = f"No configuration found for {name}"
+            raise KeyError(msg)
         return config
 
     @overload
@@ -170,18 +176,18 @@ class ConfigManager:
         self,
         name: Union[
             type[NoPoolSyncConfig[ConnectionT]],
-            type[SyncDatabaseConfig[ConnectionT, PoolT]],
+            type[SyncDatabaseConfig[ConnectionT, PoolT]],  # pyright: ignore[reportInvalidTypeVarUse]
         ],
-    ) -> ConnectionT: ...  # pyright: ignore[reportInvalidTypeVarUse]
+    ) -> ConnectionT: ...
 
     @overload
     def get_connection(
         self,
         name: Union[
             type[NoPoolAsyncConfig[ConnectionT]],
-            type[AsyncDatabaseConfig[ConnectionT, PoolT]],
+            type[AsyncDatabaseConfig[ConnectionT, PoolT]],  # pyright: ignore[reportInvalidTypeVarUse]
         ],
-    ) -> Awaitable[ConnectionT]: ...  # pyright: ignore[reportInvalidTypeVarUse]
+    ) -> Awaitable[ConnectionT]: ...
 
     def get_connection(
         self,

sqlspec/exceptions.py

@@ -1,6 +1,4 @@
-from __future__ import annotations
-
-from typing import Any
+from typing import Any, Optional
 
 __all__ = (
     "ImproperConfigurationError",
@@ -50,7 +48,7 @@ class MissingDependencyError(SQLSpecError, ImportError):
     This exception is raised only when a module depends on a dependency that has not been installed.
     """
 
-    def __init__(self, package: str, install_package: str | None = None) -> None:
+    def __init__(self, package: str, install_package: Optional[str] = None) -> None:
         super().__init__(
             f"Package {package!r} is not installed but required. You can install it by running "
             f"'pip install sqlspec[{install_package or package}]' to install sqlspec with the required extra "
@@ -61,7 +59,7 @@ class MissingDependencyError(SQLSpecError, ImportError):
 class SQLLoadingError(SQLSpecError):
     """Issues loading referenced SQL file."""
 
-    def __init__(self, message: str | None = None) -> None:
+    def __init__(self, message: Optional[str] = None) -> None:
         if message is None:
             message = "Issues loading referenced SQL file."
         super().__init__(message)
@@ -70,7 +68,7 @@ class SQLLoadingError(SQLSpecError):
 class SQLParsingError(SQLSpecError):
     """Issues parsing SQL statements."""
 
-    def __init__(self, message: str | None = None) -> None:
+    def __init__(self, message: Optional[str] = None) -> None:
         if message is None:
             message = "Issues parsing SQL statement."
         super().__init__(message)

sqlspec/extensions/litestar/plugin.py

@@ -1,21 +1,19 @@
-from __future__ import annotations
-
 from typing import TYPE_CHECKING
 
 from litestar.plugins import InitPluginProtocol
 
-from sqlspec.base import ConfigManager
-
 if TYPE_CHECKING:
     from litestar.config.app import AppConfig
 
+    from sqlspec.base import ConfigManager
+
 
 class SQLSpecPlugin(InitPluginProtocol):
     """SQLSpec plugin."""
 
     __slots__ = ("_config",)
 
-    def __init__(self, config: ConfigManager) -> None:
+    def __init__(self, config: "ConfigManager") -> None:
         """Initialize ``SQLSpecPlugin``.
 
         Args:
@@ -24,7 +22,7 @@ class SQLSpecPlugin(InitPluginProtocol):
         self._config = config
 
     @property
-    def config(self) -> ConfigManager:
+    def config(self) -> "ConfigManager":
         """Return the plugin config.
 
         Returns:
@@ -32,11 +30,14 @@ class SQLSpecPlugin(InitPluginProtocol):
         """
         return self._config
 
-    def on_app_init(self, app_config: AppConfig) -> AppConfig:
+    def on_app_init(self, app_config: "AppConfig") -> "AppConfig":
         """Configure application for use with SQLSpec.
 
         Args:
             app_config: The :class:`AppConfig <.config.app.AppConfig>` instance.
         """
+
+        from sqlspec.base import ConfigManager
+
         app_config.signature_types.append(ConfigManager)
         return app_config

sqlspec/filters.py

@@ -1,12 +1,10 @@
 """Collection filter datastructures."""
 
-from __future__ import annotations
-
 from abc import ABC
-from collections import abc  # noqa: TC003
+from collections import abc
 from dataclasses import dataclass
-from datetime import datetime  # noqa: TC003
-from typing import Generic, Literal, Protocol
+from datetime import datetime
+from typing import Generic, Literal, Optional, Protocol, Union
 
 from typing_extensions import TypeVar
 
@@ -42,9 +40,9 @@ class BeforeAfter(StatementFilter):
 
     field_name: str
     """Name of the model attribute to filter on."""
-    before: datetime | None
+    before: Optional[datetime] = None
     """Filter results where field earlier than this."""
-    after: datetime | None
+    after: Optional[datetime] = None
     """Filter results where field later than this."""
 
 
@@ -54,9 +52,9 @@ class OnBeforeAfter(StatementFilter):
 
     field_name: str
     """Name of the model attribute to filter on."""
-    on_or_before: datetime | None
+    on_or_before: Optional[datetime] = None
     """Filter results where field is on or earlier than this."""
-    on_or_after: datetime | None
+    on_or_after: Optional[datetime] = None
     """Filter results where field on or later than this."""
 
 
@@ -70,7 +68,7 @@ class CollectionFilter(InAnyFilter, Generic[T]):
 
     field_name: str
     """Name of the model attribute to filter on."""
-    values: abc.Collection[T] | None
+    values: Optional[abc.Collection[T]]
     """Values for ``IN`` clause.
 
     An empty list will return an empty result set, however, if ``None``, the filter is not applied to the query, and all rows are returned. """
@@ -82,7 +80,7 @@ class NotInCollectionFilter(InAnyFilter, Generic[T]):
 
     field_name: str
     """Name of the model attribute to filter on."""
-    values: abc.Collection[T] | None
+    values: Optional[abc.Collection[T]]
     """Values for ``NOT IN`` clause.
 
     An empty list or ``None`` will return all rows."""
@@ -116,11 +114,11 @@ class OrderBy(StatementFilter):
 class SearchFilter(StatementFilter):
     """Data required to construct a ``WHERE field_name LIKE '%' || :value || '%'`` clause."""
 
-    field_name: str | set[str]
+    field_name: Union[str, set[str]]
     """Name of the model attribute to search on."""
     value: str
     """Search value."""
-    ignore_case: bool | None = False
+    ignore_case: Optional[bool] = False
     """Should the search be case insensitive."""