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

sqlspec/base.py

@@ -2,16 +2,21 @@ from abc import ABC, abstractmethod
 from collections.abc import AsyncGenerator, Awaitable, Generator
 from contextlib import AbstractAsyncContextManager, AbstractContextManager
 from dataclasses import dataclass
-from typing import Any, ClassVar, Generic, TypeVar, Union
+from typing import Annotated, Any, ClassVar, Generic, TypeVar, Union, cast, overload
 
 __all__ = (
+    "AsyncDatabaseConfig",
     "DatabaseConfigProtocol",
     "GenericPoolConfig",
-    "NoPoolConfig",
+    "NoPoolAsyncConfig",
+    "NoPoolSyncConfig",
+    "SyncDatabaseConfig",
 )
 
 ConnectionT = TypeVar("ConnectionT")
 PoolT = TypeVar("PoolT")
+AsyncConfigT = TypeVar("AsyncConfigT", bound="Union[AsyncDatabaseConfig[Any, Any], NoPoolAsyncConfig[Any]]")
+SyncConfigT = TypeVar("SyncConfigT", bound="Union[SyncDatabaseConfig[Any, Any], NoPoolSyncConfig[Any]]")
 
 
 @dataclass
@@ -21,6 +26,9 @@ class DatabaseConfigProtocol(Generic[ConnectionT, PoolT], ABC):
     __is_async__: ClassVar[bool] = False
     __supports_connection_pooling__: ClassVar[bool] = False
 
+    def __hash__(self) -> int:
+        return id(self)
+
     @abstractmethod
     def create_connection(self) -> Union[ConnectionT, Awaitable[ConnectionT]]:
         """Create and return a new database connection."""
@@ -28,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],
@@ -51,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
@@ -67,14 +79,34 @@ class DatabaseConfigProtocol(Generic[ConnectionT, PoolT], ABC):
         return self.__supports_connection_pooling__
 
 
-class NoPoolConfig(DatabaseConfigProtocol[ConnectionT, None]):
-    """Base class for database configurations that do not implement a pool."""
+class NoPoolSyncConfig(DatabaseConfigProtocol[ConnectionT, None]):
+    """Base class for a sync database configurations that do not implement a pool."""
+
+    __is_async__ = False
+    __supports_connection_pooling__ = False
 
     def create_pool(self) -> None:
         """This database backend has not implemented the pooling configurations."""
+        return
+
+    def provide_pool(self, *args: Any, **kwargs: Any) -> None:
+        """This database backend has not implemented the pooling configurations."""
+        return
+
+
+class NoPoolAsyncConfig(DatabaseConfigProtocol[ConnectionT, None]):
+    """Base class for an async database configurations that do not implement a pool."""
+
+    __is_async__ = True
+    __supports_connection_pooling__ = False
+
+    async def create_pool(self) -> None:
+        """This database backend has not implemented the pooling configurations."""
+        return
 
     def provide_pool(self, *args: Any, **kwargs: Any) -> None:
         """This database backend has not implemented the pooling configurations."""
+        return
 
 
 @dataclass
@@ -83,5 +115,113 @@ class GenericPoolConfig:
 
 
 @dataclass
-class GenericDatabaseConfig:
-    """Generic Database Configuration."""
+class SyncDatabaseConfig(DatabaseConfigProtocol[ConnectionT, PoolT]):
+    """Generic Sync Database Configuration."""
+
+    __is_async__ = False
+    __supports_connection_pooling__ = True
+
+
+@dataclass
+class AsyncDatabaseConfig(DatabaseConfigProtocol[ConnectionT, PoolT]):
+    """Generic Async Database Configuration."""
+
+    __is_async__ = True
+    __supports_connection_pooling__ = True
+
+
+class ConfigManager:
+    """Type-safe configuration manager with literal inference."""
+
+    def __init__(self) -> None:
+        self._configs: dict[Any, DatabaseConfigProtocol[Any, Any]] = {}
+
+    @overload
+    def add_config(self, config: SyncConfigT) -> type[SyncConfigT]: ...
+
+    @overload
+    def add_config(self, config: AsyncConfigT) -> type[AsyncConfigT]: ...
+
+    def add_config(
+        self,
+        config: Union[
+            SyncConfigT,
+            AsyncConfigT,
+        ],
+    ) -> Union[Annotated[type[SyncConfigT], int], Annotated[type[AsyncConfigT], int]]:  # pyright: ignore[reportInvalidTypeVarUse]
+        """Add a new configuration to the manager."""
+        key = Annotated[type(config), id(config)]  # type: ignore[valid-type]
+        self._configs[key] = config
+        return key  # type: ignore[return-value]  # pyright: ignore[reportReturnType]
+
+    @overload
+    def get_config(self, name: type[SyncConfigT]) -> SyncConfigT: ...
+
+    @overload
+    def get_config(self, name: type[AsyncConfigT]) -> AsyncConfigT: ...
+
+    def get_config(
+        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:
+            msg = f"No configuration found for {name}"
+            raise KeyError(msg)
+        return config
+
+    @overload
+    def get_connection(
+        self,
+        name: Union[
+            type[NoPoolSyncConfig[ConnectionT]],
+            type[SyncDatabaseConfig[ConnectionT, PoolT]],  # pyright: ignore[reportInvalidTypeVarUse]
+        ],
+    ) -> ConnectionT: ...
+
+    @overload
+    def get_connection(
+        self,
+        name: Union[
+            type[NoPoolAsyncConfig[ConnectionT]],
+            type[AsyncDatabaseConfig[ConnectionT, PoolT]],  # pyright: ignore[reportInvalidTypeVarUse]
+        ],
+    ) -> Awaitable[ConnectionT]: ...
+
+    def get_connection(
+        self,
+        name: Union[
+            type[NoPoolSyncConfig[ConnectionT]],
+            type[NoPoolAsyncConfig[ConnectionT]],
+            type[SyncDatabaseConfig[ConnectionT, PoolT]],
+            type[AsyncDatabaseConfig[ConnectionT, PoolT]],
+        ],
+    ) -> Union[ConnectionT, Awaitable[ConnectionT]]:
+        """Create and return a connection from the specified configuration."""
+        config = self.get_config(name)
+        return config.create_connection()
+
+    @overload
+    def get_pool(self, name: type[Union[NoPoolSyncConfig[ConnectionT], NoPoolAsyncConfig[ConnectionT]]]) -> None: ...  # pyright: ignore[reportInvalidTypeVarUse]
+
+    @overload
+    def get_pool(self, name: type[SyncDatabaseConfig[ConnectionT, PoolT]]) -> type[PoolT]: ...  # pyright: ignore[reportInvalidTypeVarUse]
+
+    @overload
+    def get_pool(self, name: type[AsyncDatabaseConfig[ConnectionT, PoolT]]) -> Awaitable[type[PoolT]]: ...  # pyright: ignore[reportInvalidTypeVarUse]
+
+    def get_pool(
+        self,
+        name: Union[
+            type[NoPoolSyncConfig[ConnectionT]],
+            type[NoPoolAsyncConfig[ConnectionT]],
+            type[SyncDatabaseConfig[ConnectionT, PoolT]],
+            type[AsyncDatabaseConfig[ConnectionT, PoolT]],
+        ],
+    ) -> Union[type[PoolT], Awaitable[type[PoolT]], None]:
+        """Create and return a connection pool from the specified configuration."""
+        config = self.get_config(name)
+        if isinstance(config, (NoPoolSyncConfig, NoPoolAsyncConfig)):
+            return None
+        return cast("Union[type[PoolT], Awaitable[type[PoolT]]]", config.create_pool())

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,34 +1,43 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any, TypeVar
+from typing import TYPE_CHECKING
 
 from litestar.plugins import InitPluginProtocol
 
 if TYPE_CHECKING:
     from litestar.config.app import AppConfig
 
-
-T = TypeVar("T")
+    from sqlspec.base import ConfigManager
 
 
 class SQLSpecPlugin(InitPluginProtocol):
-    """Aiosql plugin."""
+    """SQLSpec plugin."""
 
     __slots__ = ("_config",)
 
-    def __init__(self, config: Any) -> None:
-        """Initialize ``AiosqlPlugin``.
+    def __init__(self, config: "ConfigManager") -> None:
+        """Initialize ``SQLSpecPlugin``.
 
         Args:
-            config: configure and start Aiosql.
+            config: configure SQLSpec plugin for use with Litestar.
         """
         self._config = config
 
-    def on_app_init(self, app_config: AppConfig) -> AppConfig:
-        """Configure application for use with Aiosql.
+    @property
+    def config(self) -> "ConfigManager":
+        """Return the plugin config.
+
+        Returns:
+            ConfigManager.
+        """
+        return self._config
+
+    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.
         """
-        app_config.signature_namespace.update(self._config.signature_namespace)
+
+        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."""