sqlmodel-ext 0.5.0__py3-none-any.whl → 0.5.2__py3-none-any.whl

sqlmodel_ext/__init__.py

@@ -20,7 +20,7 @@ Quick start::
     user = await user.save(session)
     users = await User.get(session, fetch_mode="all")
 """
-__version__ = "0.5.0"
+__version__ = "0.5.2"
 
 # Every re-export below uses the redundant ``X as X`` form: the package ships
 # ``py.typed``, and type checkers treat a plain ``from m import X`` in a typed
@@ -66,6 +66,9 @@ from sqlmodel_ext.pagination import (
     TableViewRequest as TableViewRequest,
 )
 
+# FastAPI dependency for query-parameter DTOs (cross-field errors -> 422; requires the `fastapi` extra when called)
+from sqlmodel_ext.dependencies import query_dependency as query_dependency
+
 # Mixins
 from sqlmodel_ext.mixins import (
     # Table

sqlmodel_ext/_compat.py

@@ -9,7 +9,9 @@ Import this module for side effects before using SQLModelBase.
 import sys
 
 if sys.version_info >= (3, 14):
-    import annotationlib  # noqa: F401
+    # The checker analyzes at pythonVersion 3.12 (the lowest supported version), where this
+    # version-gated block is statically unreachable; it does run on 3.14+.
+    import annotationlib  # noqa: F401  # pyright: ignore[reportUnreachable]
     import types
     from enum import StrEnum
     from typing import Literal, Union, get_args, get_origin
@@ -101,7 +103,7 @@ if sys.version_info >= (3, 14):
                 if non_none_args:
                     first_arg = non_none_args[0]
                     # Check for Annotated SA type metadata first (e.g. Array[T] | None).
-                    # Array[T] desugars to Annotated[list[T], _ArrayTypeHandler(T)];
+                    # Array[T] desugars to Annotated[list[T], ArrayTypeHandler(T)];
                     # wrapping with | None produces Union[Annotated[...], None],
                     # so the SA type must be extracted from the inner Annotated.
                     first_arg_type_name = type(first_arg).__name__

sqlmodel_ext/_exceptions.py

@@ -12,5 +12,5 @@ class RecordNotFoundError(Exception):
     status_code: int = 404
 
     def __init__(self, detail: str = "Not found"):
-        self.detail = detail
+        self.detail: str = detail
         super().__init__(detail)

sqlmodel_ext/_sa_type.py

@@ -2,15 +2,27 @@
 Internal helpers for extracting SQLAlchemy types from annotations.
 
 These are used by the metaclass to inject sa_type into Field definitions.
+
+Internal protocol, not part of the public API: the functions carry public names
+only because :mod:`sqlmodel_ext.base` (the metaclass) imports them across module
+boundaries; the module itself stays private (``_sa_type``).
 """
 import sys
 import typing
-from typing import Any, Mapping, get_args, get_origin, get_type_hints
+from collections.abc import Mapping
+from typing import Any, get_args, get_origin, get_type_hints
+
 
-from sqlalchemy.orm import Mapped
+def _null_schema_handler(_source_type: Any) -> None:
+    """
+    Stand-in for pydantic's ``GetCoreSchemaHandler`` when probing a type's
+    ``__get_pydantic_core_schema__`` for ``metadata['sa_type']``: the probe
+    only reads the metadata and never needs the delegated inner schema.
+    """
+    return None
 
 
-def _extract_sa_type_from_annotation(annotation: Any) -> Any | None:
+def extract_sa_type_from_annotation(annotation: Any) -> Any | None:
     """
     Extract SQLAlchemy type from a type annotation.
 
@@ -40,7 +52,7 @@ def _extract_sa_type_from_annotation(annotation: Any) -> Any | None:
                     try:
                         schema = item.__get_pydantic_core_schema__(
                             annotation,
-                            lambda x: None,
+                            _null_schema_handler,
                         )
                         if isinstance(schema, dict) and 'metadata' in schema:
                             sa_type = schema['metadata'].get('sa_type')
@@ -54,7 +66,7 @@ def _extract_sa_type_from_annotation(annotation: Any) -> Any | None:
         try:
             schema = annotation.__get_pydantic_core_schema__(
                 annotation,
-                lambda x: None,
+                _null_schema_handler,
             )
             if isinstance(schema, dict) and 'metadata' in schema:
                 sa_type = schema['metadata'].get('sa_type')
@@ -66,7 +78,7 @@ def _extract_sa_type_from_annotation(annotation: Any) -> Any | None:
     return None
 
 
-def _resolve_annotations(attrs: dict[str, Any]) -> tuple[
+def resolve_annotations(attrs: dict[str, Any]) -> tuple[
     dict[str, Any],
     dict[str, str],
     Mapping[str, Any],
@@ -112,7 +124,7 @@ def _resolve_annotations(attrs: dict[str, Any]) -> tuple[
     return dict(evaluated), {}, module_globals, localns
 
 
-def _evaluate_annotation_from_string(
+def evaluate_annotation_from_string(
     field_name: str,
     annotation_strings: dict[str, str],
     current_type: Any,
@@ -129,7 +141,7 @@ def _evaluate_annotation_from_string(
         return current_type
 
     expr = annotation_strings.get(field_name)
-    if not expr or not isinstance(expr, str):
+    if not expr:
         return current_type
 
     try:

sqlmodel_ext/_type_unwrap.py

@@ -17,7 +17,15 @@ from a ``response_model`` to its DTO / ORM classes).
 """
 import types
 import typing
-from typing import Annotated, Any, Union
+from typing import Annotated, Any, Final
+
+# ``typing.Union`` as a runtime value: the ``get_origin()`` of ``Optional[X]`` /
+# ``Union[X, Y]`` on Python < 3.14 (``X | Y`` has origin ``types.UnionType``).
+# reportDeprecated targets spelling *annotations* with ``Union`` (use ``X | Y``);
+# an identity-comparison target has no non-deprecated spelling, so the single
+# reference lives here and every origin check in the package compares against
+# this name (internal protocol, not part of the public API).
+TYPING_UNION: Final = typing.Union  # pyright: ignore[reportDeprecated]
 
 
 def unwrap_to_class(hint: Any) -> type | None:
@@ -41,7 +49,7 @@ def unwrap_to_class(hint: Any) -> type | None:
             return unwrap_to_class(args[0])
 
     # X | None (UnionType) or Optional[X] (Union[X, None])
-    if origin is types.UnionType or origin is Union:  # pyright: ignore[reportDeprecated]
+    if origin is types.UnionType or origin is TYPING_UNION:
         args = typing.get_args(hint)
         non_none = [a for a in args if a is not type(None)]
         if len(non_none) == 1: