sqlspec 0.45.0__tar.gz → 0.46.1__tar.gz

{sqlspec-0.45.0 → sqlspec-0.46.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlspec
-Version: 0.45.0
+Version: 0.46.1
 Summary: SQL Experiments in Python
 Project-URL: Discord, https://discord.gg/litestar
 Project-URL: Issue, https://github.com/litestar-org/sqlspec/issues/

{sqlspec-0.45.0 → sqlspec-0.46.1}/pyproject.toml

@@ -24,7 +24,7 @@ maintainers = [{ name = "Litestar Developers", email = "hello@litestar.dev" }]
 name = "sqlspec"
 readme = "README.md"
 requires-python = ">=3.10, <4.0"
-version = "0.45.0"
+version = "0.46.1"
 
 [project.urls]
 Discord = "https://discord.gg/litestar"
@@ -264,7 +264,7 @@ opt_level = "3"   # Maximum optimization (0-3)
 allow_dirty = true
 commit = false
 commit_args = "--no-verify"
-current_version = "0.45.0"
+current_version = "0.46.1"
 ignore_missing_files = false
 ignore_missing_version = false
 message = "chore(release): bump to v{new_version}"

{sqlspec-0.45.0 → sqlspec-0.46.1}/sqlspec/adapters/oracledb/core.py

@@ -800,7 +800,7 @@ def build_profile() -> "DriverParameterProfile":
         allow_mixed_parameter_styles=False,
         preserve_original_params_for_many=False,
         json_serializer_strategy="driver",
-        custom_type_coercions={**build_uuid_coercions()},
+        custom_type_coercions={**build_uuid_coercions(native=True)},
         default_dialect="oracle",
     )
 

{sqlspec-0.45.0 → sqlspec-0.46.1}/sqlspec/extensions/litestar/plugin.py

@@ -39,7 +39,7 @@ from sqlspec.extensions.litestar.handlers import (
 from sqlspec.typing import NUMPY_INSTALLED, ConnectionT, PoolT, SchemaT
 from sqlspec.utils.correlation import CorrelationContext
 from sqlspec.utils.logging import get_logger, log_with_context
-from sqlspec.utils.serializers import numpy_array_dec_hook, numpy_array_enc_hook, numpy_array_predicate
+from sqlspec.utils.serializers import DEFAULT_TYPE_ENCODERS, numpy_array_dec_hook, numpy_array_predicate
 
 if TYPE_CHECKING:
     from collections.abc import AsyncGenerator, Callable
@@ -179,6 +179,23 @@ def _build_correlation_headers(*, primary: str, configured: list[str], auto_trac
     return tuple(_dedupe_headers(header_order))
 
 
+def _build_litestar_type_decoders() -> "list[tuple[Callable[[Any], bool], Callable[[type, Any], Any]]]":
+    """Build the Litestar-specific ``type_decoders`` list.
+
+    Decoders are predicate-tuples consumed by Litestar's request-body parsing,
+    not part of sqlspec's serializer registry — so they live here rather than
+    in :data:`sqlspec.utils.serializers.DEFAULT_TYPE_ENCODERS`.
+    """
+    decoders: list[tuple[Callable[[Any], bool], Callable[[type, Any], Any]]] = []
+    if NUMPY_INSTALLED:
+        decoders.append((numpy_array_predicate, numpy_array_dec_hook))
+    with suppress(ImportError):
+        import uuid_utils  # pyright: ignore[reportMissingImports]
+
+        decoders.append((lambda t: t is uuid_utils.UUID, lambda t, v: t(str(v))))
+    return decoders
+
+
 class CorrelationMiddleware:
     __slots__ = ("_app", "_headers")
 
@@ -467,28 +484,20 @@ class SQLSpecPlugin(InitPluginProtocol, CLIPlugin):
         existing_plugins = list(app_config.plugins or [])
         if not any(isinstance(p, _OffsetPaginationSchemaPlugin) for p in existing_plugins):
             existing_plugins.append(_OffsetPaginationSchemaPlugin())
-            app_config.plugins = existing_plugins
+        app_config.plugins = existing_plugins
 
         if app_config.exception_handlers is None:
             app_config.exception_handlers = {}
         app_config.exception_handlers.setdefault(NotFoundError, not_found_error_handler)
 
-        if NUMPY_INSTALLED:
-            import numpy as np
-
-            if app_config.type_encoders is None:
-                app_config.type_encoders = {np.ndarray: numpy_array_enc_hook}
-            else:
-                encoders_dict = dict(app_config.type_encoders)
-                encoders_dict[np.ndarray] = numpy_array_enc_hook
-                app_config.type_encoders = encoders_dict
-
-            if app_config.type_decoders is None:
-                app_config.type_decoders = [(numpy_array_predicate, numpy_array_dec_hook)]
-            else:
-                decoders_list = list(app_config.type_decoders)
-                decoders_list.append((numpy_array_predicate, numpy_array_dec_hook))
-                app_config.type_decoders = decoders_list
+        # Inject sqlspec's DEFAULT_TYPE_ENCODERS into Litestar's response serializer
+        # (user-supplied encoders win on conflict). Litestar's per-handler
+        # resolve_type_encoders() merges these with route/controller/router-level
+        # overrides automatically — no bidirectional thread needed.
+        app_config.type_encoders = {**DEFAULT_TYPE_ENCODERS, **(app_config.type_encoders or {})}
+        sqlspec_decoders = _build_litestar_type_decoders()
+        if sqlspec_decoders:
+            app_config.type_decoders = [*(app_config.type_decoders or []), *sqlspec_decoders]
 
         if self._correlation_headers:
             middleware = DefineMiddleware(CorrelationMiddleware, headers=self._correlation_headers)

{sqlspec-0.45.0 → sqlspec-0.46.1}/sqlspec/extensions/litestar/providers.py

@@ -171,7 +171,103 @@ def _resolve_sort_fields(sort_field: SortField) -> tuple[str, set[str]]:
     return fields[0], set(fields)
 
 
-def _create_statement_filters(  # noqa: C901
+def _build_in_collection_provider(field: FieldNameType, *, negated: bool) -> Callable[..., Any]:
+    """Build a per-field `IN` / `NOT IN` filter provider with a unique parameter name.
+
+    Litestar's dependency resolver collapses parameters across distinct ``Provide()``
+    instances by Python parameter name, ignoring per-instance ``Parameter(query=...)``
+    aliases. Giving each provider a unique parameter name (via ``__signature__``)
+    prevents siblings in the same family from cross-binding (issue #435).
+    """
+    type_hint = field.type_hint
+    field_name = field.name
+    param_name = f"{field_name}_values"
+    alias = camelize(f"{field_name}_{'not_in' if negated else 'in'}")
+    filter_cls: Any = NotInCollectionFilter if negated else InCollectionFilter
+    annotation = list[type_hint] | None  # type: ignore[valid-type]
+    return_annotation = filter_cls[type_hint] | None
+
+    def provide(**kwargs: Any) -> Any:
+        values = kwargs.get(param_name)
+        return filter_cls[type_hint](field_name=field_name, values=values) if values else None
+
+    provide.__signature__ = inspect.Signature(  # type: ignore[attr-defined]
+        parameters=[
+            inspect.Parameter(
+                param_name,
+                kind=inspect.Parameter.KEYWORD_ONLY,
+                default=Parameter(query=alias, default=None, required=False),
+                annotation=annotation,
+            )
+        ],
+        return_annotation=return_annotation,
+    )
+    provide.__annotations__ = {param_name: annotation, "return": return_annotation}
+    return provide
+
+
+def _build_null_provider(field_name: str, *, negated: bool) -> Callable[..., Any]:
+    """Build a per-field ``IS NULL`` / ``IS NOT NULL`` provider with a unique parameter name (issue #435)."""
+    suffix = "is_not_null" if negated else "is_null"
+    param_name = f"{field_name}_{suffix}"
+    alias = camelize(f"{field_name}_{suffix}")
+    filter_cls: type[Any] = NotNullFilter if negated else NullFilter
+    annotation = bool | None
+    return_annotation = filter_cls | None
+
+    def provide(**kwargs: Any) -> Any:
+        flag = kwargs.get(param_name)
+        return filter_cls(field_name=field_name) if flag else None
+
+    provide.__signature__ = inspect.Signature(  # type: ignore[attr-defined]
+        parameters=[
+            inspect.Parameter(
+                param_name,
+                kind=inspect.Parameter.KEYWORD_ONLY,
+                default=Parameter(query=alias, default=None, required=False),
+                annotation=annotation,
+            )
+        ],
+        return_annotation=return_annotation,
+    )
+    provide.__annotations__ = {param_name: annotation, "return": return_annotation}
+    return provide
+
+
+def _build_before_after_provider(field_name: str, before_alias: str, after_alias: str) -> Callable[..., Any]:
+    """Build a ``BeforeAfterFilter`` provider with unique ``before``/``after`` parameter names (issue #435).
+
+    ``created_at`` and ``updated_at`` providers both used ``before``/``after``, so when
+    enabled together they cross-bound to whichever query alias Litestar resolved first.
+    """
+    before_param = f"{field_name}_before"
+    after_param = f"{field_name}_after"
+
+    def provide(**kwargs: Any) -> BeforeAfterFilter:
+        return BeforeAfterFilter(field_name, kwargs.get(before_param), kwargs.get(after_param))
+
+    provide.__signature__ = inspect.Signature(  # type: ignore[attr-defined]
+        parameters=[
+            inspect.Parameter(
+                before_param,
+                kind=inspect.Parameter.KEYWORD_ONLY,
+                default=Parameter(query=before_alias, default=None, required=False),
+                annotation=DTorNone,
+            ),
+            inspect.Parameter(
+                after_param,
+                kind=inspect.Parameter.KEYWORD_ONLY,
+                default=Parameter(query=after_alias, default=None, required=False),
+                annotation=DTorNone,
+            ),
+        ],
+        return_annotation=BeforeAfterFilter,
+    )
+    provide.__annotations__ = {before_param: DTorNone, after_param: DTorNone, "return": BeforeAfterFilter}
+    return provide
+
+
+def _create_statement_filters(
     config: FilterConfig, dep_defaults: DependencyDefaults = DEPENDENCY_DEFAULTS
 ) -> dict[str, Provide]:
     """Create filter dependencies based on configuration.
@@ -195,24 +291,14 @@ def _create_statement_filters(  # noqa: C901
         filters[dep_defaults.ID_FILTER_DEPENDENCY_KEY] = Provide(provide_id_filter, sync_to_thread=False)  # pyright: ignore[reportUnknownArgumentType]
 
     if config.get("created_at", False):
-
-        def provide_created_filter(
-            before: DTorNone = Parameter(query="createdBefore", default=None, required=False),
-            after: DTorNone = Parameter(query="createdAfter", default=None, required=False),
-        ) -> BeforeAfterFilter:
-            return BeforeAfterFilter("created_at", before, after)
-
-        filters[dep_defaults.CREATED_FILTER_DEPENDENCY_KEY] = Provide(provide_created_filter, sync_to_thread=False)
+        filters[dep_defaults.CREATED_FILTER_DEPENDENCY_KEY] = Provide(
+            _build_before_after_provider("created_at", "createdBefore", "createdAfter"), sync_to_thread=False
+        )
 
     if config.get("updated_at", False):
-
-        def provide_updated_filter(
-            before: DTorNone = Parameter(query="updatedBefore", default=None, required=False),
-            after: DTorNone = Parameter(query="updatedAfter", default=None, required=False),
-        ) -> BeforeAfterFilter:
-            return BeforeAfterFilter("updated_at", before, after)
-
-        filters[dep_defaults.UPDATED_FILTER_DEPENDENCY_KEY] = Provide(provide_updated_filter, sync_to_thread=False)
+        filters[dep_defaults.UPDATED_FILTER_DEPENDENCY_KEY] = Provide(
+            _build_before_after_provider("updated_at", "updatedBefore", "updatedAfter"), sync_to_thread=False
+        )
 
     if config.get("pagination_type") == "limit_offset":
 
@@ -276,85 +362,33 @@ def _create_statement_filters(  # noqa: C901
         not_in_fields = {not_in_fields} if isinstance(not_in_fields, (str, FieldNameType)) else not_in_fields
 
         for field_def in not_in_fields:
-            field_def = FieldNameType(name=field_def, type_hint=str) if isinstance(field_def, str) else field_def
-
-            def create_not_in_filter_provider(  # pyright: ignore
-                field_name: FieldNameType,
-            ) -> Callable[..., NotInCollectionFilter[field_def.type_hint] | None]:  # type: ignore
-                def provide_not_in_filter(  # pyright: ignore
-                    values: list[field_name.type_hint] | None = Parameter(  # type: ignore
-                        query=camelize(f"{field_name.name}_not_in"), default=None, required=False
-                    ),
-                ) -> NotInCollectionFilter[field_name.type_hint] | None:  # type: ignore
-                    return (
-                        NotInCollectionFilter[field_name.type_hint](field_name=field_name.name, values=values)  # type: ignore
-                        if values
-                        else None
-                    )
-
-                return provide_not_in_filter  # pyright: ignore
-
-            provider = create_not_in_filter_provider(field_def)  # pyright: ignore
-            filters[f"{field_def.name}_not_in_filter"] = Provide(provider, sync_to_thread=False)  # pyright: ignore
+            resolved = FieldNameType(name=field_def, type_hint=str) if isinstance(field_def, str) else field_def
+            filters[f"{resolved.name}_not_in_filter"] = Provide(
+                _build_in_collection_provider(resolved, negated=True), sync_to_thread=False
+            )
 
     if in_fields := config.get("in_fields"):
         in_fields = {in_fields} if isinstance(in_fields, (str, FieldNameType)) else in_fields
 
         for field_def in in_fields:
-            field_def = FieldNameType(name=field_def, type_hint=str) if isinstance(field_def, str) else field_def
-
-            def create_in_filter_provider(  # pyright: ignore
-                field_name: FieldNameType,
-            ) -> Callable[..., InCollectionFilter[field_def.type_hint] | None]:  # type: ignore # pyright: ignore
-                def provide_in_filter(  # pyright: ignore
-                    values: list[field_name.type_hint] | None = Parameter(  # type: ignore # pyright: ignore
-                        query=camelize(f"{field_name.name}_in"), default=None, required=False
-                    ),
-                ) -> InCollectionFilter[field_name.type_hint] | None:  # type: ignore # pyright: ignore
-                    return (
-                        InCollectionFilter[field_name.type_hint](field_name=field_name.name, values=values)  # type: ignore  # pyright: ignore
-                        if values
-                        else None
-                    )
-
-                return provide_in_filter  # pyright: ignore
-
-            provider = create_in_filter_provider(field_def)  # type: ignore
-            filters[f"{field_def.name}_in_filter"] = Provide(provider, sync_to_thread=False)  # pyright: ignore
+            resolved = FieldNameType(name=field_def, type_hint=str) if isinstance(field_def, str) else field_def
+            filters[f"{resolved.name}_in_filter"] = Provide(
+                _build_in_collection_provider(resolved, negated=False), sync_to_thread=False
+            )
 
     if null_fields := config.get("null_fields"):
         null_fields = {null_fields} if isinstance(null_fields, str) else set(null_fields)
-
         for field_name in null_fields:
-
-            def create_null_filter_provider(fname: str) -> Callable[..., NullFilter | None]:
-                def provide_null_filter(
-                    is_null: bool | None = Parameter(query=camelize(f"{fname}_is_null"), default=None, required=False),
-                ) -> NullFilter | None:
-                    return NullFilter(field_name=fname) if is_null else None
-
-                return provide_null_filter
-
-            null_provider = create_null_filter_provider(field_name)
-            filters[f"{field_name}_null_filter"] = Provide(null_provider, sync_to_thread=False)
+            filters[f"{field_name}_null_filter"] = Provide(
+                _build_null_provider(field_name, negated=False), sync_to_thread=False
+            )
 
     if not_null_fields := config.get("not_null_fields"):
         not_null_fields = {not_null_fields} if isinstance(not_null_fields, str) else set(not_null_fields)
-
         for field_name in not_null_fields:
-
-            def create_not_null_filter_provider(fname: str) -> Callable[..., NotNullFilter | None]:
-                def provide_not_null_filter(
-                    is_not_null: bool | None = Parameter(
-                        query=camelize(f"{fname}_is_not_null"), default=None, required=False
-                    ),
-                ) -> NotNullFilter | None:
-                    return NotNullFilter(field_name=fname) if is_not_null else None
-
-                return provide_not_null_filter
-
-            not_null_provider = create_not_null_filter_provider(field_name)
-            filters[f"{field_name}_not_null_filter"] = Provide(not_null_provider, sync_to_thread=False)
+            filters[f"{field_name}_not_null_filter"] = Provide(
+                _build_null_provider(field_name, negated=True), sync_to_thread=False
+            )
 
     if filters:
         filters[dep_defaults.FILTERS_DEPENDENCY_KEY] = Provide(

{sqlspec-0.45.0 → sqlspec-0.46.1}/sqlspec/service.py

@@ -1,7 +1,7 @@
 """Service base classes for SQLSpec application services."""
 
 from contextlib import asynccontextmanager, contextmanager
-from typing import TYPE_CHECKING, Any, Generic, cast
+from typing import TYPE_CHECKING, Any, Generic, cast, overload
 
 from typing_extensions import TypeVar
 
@@ -51,6 +51,28 @@ class SQLSpecAsyncService(Generic[AsyncDriverT]):
         """Alias for :attr:`session` matching the recipe-doc terminology."""
         return self._session
 
+    @overload
+    async def paginate(
+        self,
+        statement: "Statement | QueryBuilder",
+        /,
+        *parameters: "StatementParameters | StatementFilter",
+        schema_type: "type[SchemaT]",
+        count_with_window: bool = False,
+        **kwargs: Any,
+    ) -> OffsetPagination[SchemaT]: ...
+
+    @overload
+    async def paginate(
+        self,
+        statement: "Statement | QueryBuilder",
+        /,
+        *parameters: "StatementParameters | StatementFilter",
+        schema_type: None = None,
+        count_with_window: bool = False,
+        **kwargs: Any,
+    ) -> OffsetPagination[dict[str, Any]]: ...
+
     async def paginate(
         self,
         statement: "Statement | QueryBuilder",
@@ -59,7 +81,7 @@ class SQLSpecAsyncService(Generic[AsyncDriverT]):
         schema_type: "type[SchemaT] | None" = None,
         count_with_window: bool = False,
         **kwargs: Any,
-    ) -> OffsetPagination[SchemaT]:
+    ) -> "OffsetPagination[SchemaT] | OffsetPagination[dict[str, Any]]":
         """Execute a paginated query and return an OffsetPagination container.
 
         Args:
@@ -78,6 +100,14 @@ class SQLSpecAsyncService(Generic[AsyncDriverT]):
             statement, *parameters, schema_type=schema_type, count_with_window=count_with_window, **kwargs
         )
 
+        if schema_type is None:
+            return OffsetPagination(
+                items=cast("list[dict[str, Any]]", items),
+                limit=limit_offset.limit if limit_offset is not None else len(items),
+                offset=limit_offset.offset if limit_offset is not None else 0,
+                total=total,
+            )
+
         return OffsetPagination(
             items=cast("list[SchemaT]", items),
             limit=limit_offset.limit if limit_offset is not None else len(items),
@@ -85,6 +115,39 @@ class SQLSpecAsyncService(Generic[AsyncDriverT]):
             total=total,
         )
 
+    @overload
+    async def get_one(
+        self,
+        statement: "Statement | QueryBuilder",
+        /,
+        *parameters: "StatementParameters | StatementFilter",
+        schema_type: "type[SchemaT]",
+        error_message: str | None = None,
+        **kwargs: Any,
+    ) -> SchemaT: ...
+
+    @overload
+    async def get_one(
+        self,
+        statement: "Statement | QueryBuilder",
+        /,
+        *parameters: "StatementParameters | StatementFilter",
+        schema_type: None = None,
+        error_message: str | None = None,
+        **kwargs: Any,
+    ) -> dict[str, Any]: ...
+
+    @overload
+    async def get_one(
+        self,
+        statement: "Statement | QueryBuilder",
+        /,
+        *parameters: "StatementParameters | StatementFilter",
+        schema_type: "type[SchemaT] | None" = None,
+        error_message: str | None = None,
+        **kwargs: Any,
+    ) -> "SchemaT | dict[str, Any]": ...
+
     async def get_one(
         self,
         statement: "Statement | QueryBuilder",
@@ -191,6 +254,28 @@ class SQLSpecSyncService(Generic[SyncDriverT]):
         """Alias for :attr:`session` matching the recipe-doc terminology."""
         return self._session
 
+    @overload
+    def paginate(
+        self,
+        statement: "Statement | QueryBuilder",
+        /,
+        *parameters: "StatementParameters | StatementFilter",
+        schema_type: "type[SchemaT]",
+        count_with_window: bool = False,
+        **kwargs: Any,
+    ) -> OffsetPagination[SchemaT]: ...
+
+    @overload
+    def paginate(
+        self,
+        statement: "Statement | QueryBuilder",
+        /,
+        *parameters: "StatementParameters | StatementFilter",
+        schema_type: None = None,
+        count_with_window: bool = False,
+        **kwargs: Any,
+    ) -> OffsetPagination[dict[str, Any]]: ...
+
     def paginate(
         self,
         statement: "Statement | QueryBuilder",
@@ -199,7 +284,7 @@ class SQLSpecSyncService(Generic[SyncDriverT]):
         schema_type: "type[SchemaT] | None" = None,
         count_with_window: bool = False,
         **kwargs: Any,
-    ) -> OffsetPagination[SchemaT]:
+    ) -> "OffsetPagination[SchemaT] | OffsetPagination[dict[str, Any]]":
         """Execute a paginated query and return an OffsetPagination container.
 
         Args:
@@ -218,6 +303,14 @@ class SQLSpecSyncService(Generic[SyncDriverT]):
             statement, *parameters, schema_type=schema_type, count_with_window=count_with_window, **kwargs
         )
 
+        if schema_type is None:
+            return OffsetPagination(
+                items=cast("list[dict[str, Any]]", items),
+                limit=limit_offset.limit if limit_offset is not None else len(items),
+                offset=limit_offset.offset if limit_offset is not None else 0,
+                total=total,
+            )
+
         return OffsetPagination(
             items=cast("list[SchemaT]", items),
             limit=limit_offset.limit if limit_offset is not None else len(items),
@@ -225,6 +318,39 @@ class SQLSpecSyncService(Generic[SyncDriverT]):
             total=total,
         )
 
+    @overload
+    def get_one(
+        self,
+        statement: "Statement | QueryBuilder",
+        /,
+        *parameters: "StatementParameters | StatementFilter",
+        schema_type: "type[SchemaT]",
+        error_message: str | None = None,
+        **kwargs: Any,
+    ) -> SchemaT: ...
+
+    @overload
+    def get_one(
+        self,
+        statement: "Statement | QueryBuilder",
+        /,
+        *parameters: "StatementParameters | StatementFilter",
+        schema_type: None = None,
+        error_message: str | None = None,
+        **kwargs: Any,
+    ) -> dict[str, Any]: ...
+
+    @overload
+    def get_one(
+        self,
+        statement: "Statement | QueryBuilder",
+        /,
+        *parameters: "StatementParameters | StatementFilter",
+        schema_type: "type[SchemaT] | None" = None,
+        error_message: str | None = None,
+        **kwargs: Any,
+    ) -> "SchemaT | dict[str, Any]": ...
+
     def get_one(
         self,
         statement: "Statement | QueryBuilder",