sqlmodel-ext 0.3.2__py3-none-any.whl → 0.3.3__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.3.0"
+__version__ = "0.3.3"
 
 # Base
 from sqlmodel_ext.base import SQLModelBase, ExtraIgnoreModelBase

sqlmodel_ext/_compat.py

@@ -67,10 +67,15 @@ if sys.version_info >= (3, 14):
         # Check field.metadata (Pydantic-processed Annotated types)
         metadata = getattr(field, 'metadata', None)
         if metadata:
+            # Pass field.annotation as source_type so handlers that need the element type
+            # (e.g. _PendingArrayHandler extracting T from list[T] to compute ARRAY(T))
+            # can resolve. handler=None is fine because the sa_type extraction path only
+            # reads metadata['sa_type'] and never invokes the schema itself.
+            field_annotation = getattr(field, 'annotation', None)
             for metadata_item in metadata:
                 if hasattr(metadata_item, '__get_pydantic_core_schema__'):
                     try:
-                        schema = metadata_item.__get_pydantic_core_schema__(None, None)
+                        schema = metadata_item.__get_pydantic_core_schema__(field_annotation, None)
                         if isinstance(schema, dict) and 'metadata' in schema:
                             sa_type = schema['metadata'].get('sa_type')
                             if sa_type is not None:
@@ -105,7 +110,9 @@ if sys.version_info >= (3, 14):
                         for md in inner_args[1:]:
                             if hasattr(md, '__get_pydantic_core_schema__'):
                                 try:
-                                    schema = md.__get_pydantic_core_schema__(None, None)
+                                    # Pass first_arg (the full Annotated alias) as source_type so
+                                    # handlers like _PendingArrayHandler can extract the element type.
+                                    schema = md.__get_pydantic_core_schema__(first_arg, None)
                                     if isinstance(schema, dict) and 'metadata' in schema:
                                         sa_type = schema['metadata'].get('sa_type')
                                         if sa_type is not None:
@@ -153,7 +160,10 @@ if sys.version_info >= (3, 14):
                 for md in args[1:]:
                     if hasattr(md, '__get_pydantic_core_schema__'):
                         try:
-                            schema = md.__get_pydantic_core_schema__(None, None)
+                            # Pass annotation (the full Annotated form) as source_type so
+                            # handlers needing the element type (_PendingArrayHandler etc.)
+                            # can extract T from list[T].
+                            schema = md.__get_pydantic_core_schema__(annotation, None)
                             if isinstance(schema, dict) and 'metadata' in schema:
                                 sa_type = schema['metadata'].get('sa_type')
                                 if sa_type is not None:

sqlmodel_ext/base.py

@@ -15,7 +15,7 @@ import re
 import sys
 import types
 import typing
-from typing import Any, get_args, get_origin
+from typing import Any, Self, Sequence, get_args, get_origin
 
 from pydantic import ConfigDict, model_validator
 from pydantic.fields import FieldInfo
@@ -102,6 +102,47 @@ def _merge_field_info_attrs(target: SQLModelFieldInfo, source: SQLModelFieldInfo
         target.metadata = list(target_meta) + list(source_meta)
 
 
+def _find_field_info_in_annotated(annotation: Any) -> SQLModelFieldInfo | None:
+    """
+    Extract SQLModel ``FieldInfo`` embedded in ``Annotated[T, Field(...)]`` metadata.
+
+    Used by the metaclass sa_type injection loop. When a field is declared
+    ``Annotated[X, Field(default_factory=list, ...)]`` *without* an explicit
+    ``= ...`` assignment, ``attrs[field_name]`` is ``Undefined``. Replacing
+    it with a fresh ``Field(sa_type=sa_type)`` would discard the user's
+    Field metadata (``default_factory``, ``max_length``, validators, ...)
+    that lives inside the Annotated args. This helper recovers that
+    FieldInfo so the caller can attach ``sa_type`` to the user's Field
+    instead of clobbering it. The bug only surfaces after 2+ levels of
+    inheritance: single-class instantiation goes through Pydantic's native
+    Annotated path and works, but child classes rebuild ``model_fields``
+    from the clobbered ``attrs`` and the field becomes silently
+    ``is_required=True``.
+
+    Multiple FieldInfo args (e.g. ``Annotated[Str64, Field(unique=True)]``
+    expands to ``Annotated[str, Field(max_length=64), Field(unique=True)]``)
+    are merged into a single shallow copy so the shared Annotated metadata
+    singletons are never mutated.
+
+    :param annotation: Field type annotation
+    :returns: Merged SQLModelFieldInfo (shallow copy, safe to mutate), or None
+    """
+    if get_origin(annotation) is not typing.Annotated:
+        return None
+    args = get_args(annotation)
+    if len(args) < 2:
+        return None
+    sqlmodel_fis: list[SQLModelFieldInfo] = [
+        arg for arg in args[1:] if isinstance(arg, SQLModelFieldInfo)
+    ]
+    if not sqlmodel_fis:
+        return None
+    merged = copy.copy(sqlmodel_fis[0])
+    for extra_fi in sqlmodel_fis[1:]:
+        _merge_field_info_attrs(merged, extra_fi)
+    return merged
+
+
 def _make_annotation_optional(annotation: typing.Any) -> typing.Any:
     """
     Convert type annotation to optional: ``T → T | None``
@@ -179,6 +220,27 @@ def _apply_all_fields_optional(
         if original_ann is None:
             continue
 
+        # Bug fix: when a field is declared as ``field: T = Field(gt=..., le=...)`` (non-Annotated form),
+        # MRO ``__annotations__`` only stores the bare ``T``. The ``Field(...)`` constraint metadata
+        # lives on the right-hand-side assignment, so all_fields_optional-derived UpdateRequest classes
+        # lose those constraints (e.g. UFT-style "missing range" warnings fire on derived fields that
+        # had constraints in the source class). Patch: when ``original_ann`` is not already Annotated,
+        # pull constraints from the base class's resolved ``model_fields[name].metadata`` (Pydantic
+        # stores them there as ``[Gt(0), Le(600), ...]``) and re-wrap into ``Annotated[T, *metadata]``,
+        # letting downstream ``_make_annotation_optional`` preserve the constraints when converting
+        # to ``T | None``. The root recommended fix is still to declare fields in Annotated form at
+        # the source; this patch is defense-in-depth for legacy ``field: T = Field(...)`` declarations.
+        if get_origin(original_ann) is not typing.Annotated:
+            for base in bases:
+                base_model_fields = getattr(base, 'model_fields', None)
+                if not base_model_fields:
+                    continue
+                base_field_info = base_model_fields.get(field_name)
+                if base_field_info is None or not base_field_info.metadata:
+                    continue
+                original_ann = typing.Annotated[original_ann, *base_field_info.metadata]
+                break
+
         # Skip Literal type fields (e.g. discriminator):
         # Literal['text'] | None breaks Pydantic discriminated union
         raw_type = original_ann
@@ -268,10 +330,33 @@ def _recover_annotated_sqlmodel_fields(
     all_annotated.update(annotations)
 
     for field_name, field_type in all_annotated.items():
-        if get_origin(field_type) is not typing.Annotated:
+        # Unwrap Optional/Union wrappers: forms like ``Annotated[X, Field(sa_type=BigInteger)] | None``
+        # have ``get_origin() == Union`` (or ``types.UnionType`` for PEP 604 ``|``); we must
+        # peel back to find the inner Annotated to extract the SQLModel FieldInfo. Otherwise
+        # nullable aliases like ``PositiveBigInt | None`` lose ``sa_type`` and the SA column
+        # silently degrades (e.g. BigInteger → Integer → asyncpg int32 overflow on large defaults).
+        annotated_type = field_type
+        union_args: list[typing.Any] | None = None
+        union_origin = get_origin(field_type)
+        # ``X | None`` (PEP 604) has origin ``types.UnionType``; ``Union[X, None]`` is ``typing.Union``.
+        # Match both without depending on ``types`` import inside any version block.
+        is_union = union_origin is typing.Union or (
+            union_origin is not None and getattr(union_origin, '__name__', '') == 'UnionType'
+        )
+        if is_union:
+            union_args = list(get_args(field_type))
+            annotated_in_union = next(
+                (arg for arg in union_args if get_origin(arg) is typing.Annotated),
+                None,
+            )
+            if annotated_in_union is None:
+                continue
+            annotated_type = annotated_in_union
+
+        if get_origin(annotated_type) is not typing.Annotated:
             continue
 
-        args = get_args(field_type)
+        args = get_args(annotated_type)
         if len(args) < 2:
             continue
 
@@ -313,10 +398,24 @@ def _recover_annotated_sqlmodel_fields(
         base_type = args[0]
         remaining_metadata = [a for a in args[1:] if not isinstance(a, SQLModelFieldInfo)]
         if remaining_metadata:
-            new_ann = typing.Annotated[tuple([base_type] + remaining_metadata)]
+            new_inner: typing.Any = typing.Annotated[tuple([base_type] + remaining_metadata)]
         else:
-            new_ann = base_type
-        annotations[field_name] = new_ann
+            new_inner = base_type
+
+        if union_args is not None:
+            # Rebuild Union: replace the inner Annotated with the stripped version, keeping
+            # the other Union members (e.g. ``| None``) intact. Use PEP 604 ``|`` to accumulate
+            # so we don't trip the deprecated-typing.Union warning.
+            new_union_args = [
+                new_inner if get_origin(arg) is typing.Annotated else arg
+                for arg in union_args
+            ]
+            rebuilt: typing.Any = new_union_args[0]
+            for extra in new_union_args[1:]:
+                rebuilt = rebuilt | extra
+            annotations[field_name] = rebuilt
+        else:
+            annotations[field_name] = new_inner
 
 
 def _make_sti_fk_resolver(
@@ -495,7 +594,19 @@ class __DeclarativeMeta(SQLModelMetaclass):
                 field_value = attrs.get(field_name, Undefined)
 
                 if field_value is Undefined:
-                    attrs[field_name] = Field(sa_type=sa_type)
+                    # No explicit ``= Field(...)`` assignment. Prefer recovering
+                    # FieldInfo from inside Annotated[X, Field(default_factory=..., ...)]
+                    # so user-supplied default_factory / max_length / constraints
+                    # survive — clobbering with a fresh Field(sa_type=sa_type)
+                    # would silently make the field required after multi-level
+                    # inheritance.
+                    annotated_fi = _find_field_info_in_annotated(field_type)
+                    if annotated_fi is not None:
+                        if getattr(annotated_fi, 'sa_type', Undefined) is Undefined:
+                            setattr(annotated_fi, 'sa_type', sa_type)
+                        attrs[field_name] = annotated_fi
+                    else:
+                        attrs[field_name] = Field(sa_type=sa_type)
                 elif isinstance(field_value, FieldInfo):
                     if getattr(field_value, 'sa_type', Undefined) is Undefined:
                         setattr(field_value, 'sa_type', sa_type)
@@ -975,6 +1086,11 @@ class SQLModelBase(SQLModel, metaclass=__DeclarativeMeta):
                         prop['description'] = finfo.description
         return json_schema
 
+    @classmethod
+    def validate_list(cls, items: Sequence[Any]) -> list[Self]:
+        """Batch-convert a sequence of ORM instances (or dicts) to this model type."""
+        return [cls.model_validate(item, from_attributes=True) for item in items]
+
     @classmethod
     def get_computed_field_names(cls) -> set[str]:
         """Get the set of computed_field names for this model class."""

sqlmodel_ext/field_types/__init__.py

@@ -108,6 +108,9 @@ Text5K: TypeAlias = Annotated[str, Field(max_length=5000), _NO_NULL_BYTE]
 Text10K: TypeAlias = Annotated[str, Field(max_length=10000), _NO_NULL_BYTE]
 """10000-character text field"""
 
+Text16K: TypeAlias = Annotated[str, Field(max_length=16000), _NO_NULL_BYTE]
+"""16000-character text field (long-form descriptions, tool docs)"""
+
 Text32K: TypeAlias = Annotated[str, Field(max_length=32000), _NO_NULL_BYTE]
 """32000-character text field"""
 
@@ -120,9 +123,29 @@ Text64K: TypeAlias = Annotated[str, Field(max_length=65536), _NO_NULL_BYTE]
 Text100K: TypeAlias = Annotated[str, Field(max_length=100000), _NO_NULL_BYTE]
 """100000-character text field"""
 
+Text128K: TypeAlias = Annotated[str, Field(max_length=131072), _NO_NULL_BYTE]
+"""131072-character (128 * 1024) text field (large markdown documents etc.)"""
+
 Text1M: TypeAlias = Annotated[str, Field(max_length=1000000), _NO_NULL_BYTE]
 """1000000-character text field (tool call parameters, tool responses, etc.)"""
 
+# NonEmptyStr* — same as Str* but also requires ``min_length=1``, rejecting empty
+# ``""`` strings with a 422 ValidationError. Use for naming fields where the empty
+# string is semantically invalid (e.g. UserFolder.name).
+NonEmptyStr64: TypeAlias = Annotated[str, Field(min_length=1, max_length=64), _NO_NULL_BYTE]
+"""1-64 character non-empty string field"""
+
+NonEmptyStr128: TypeAlias = Annotated[str, Field(min_length=1, max_length=128), _NO_NULL_BYTE]
+"""1-128 character non-empty string field"""
+
+NonEmptyStr256: TypeAlias = Annotated[str, Field(min_length=1, max_length=256), _NO_NULL_BYTE]
+"""1-256 character non-empty string field"""
+
+# Sha256Hex — exactly 64 lowercase hex characters, the canonical SHA-256 hex digest form.
+# The strict regex also implicitly rejects NUL bytes, so no separate _NO_NULL_BYTE is needed.
+Sha256Hex: TypeAlias = Annotated[str, StringConstraints(min_length=64, max_length=64, pattern=r'^[0-9a-f]{64}$')]
+"""64-char lowercase-hex SHA-256 digest (e.g. content hashes)"""
+
 # Numeric range constraints
 Port: TypeAlias = Annotated[int, Field(ge=1, le=65535)]
 """Port number (1-65535)"""

sqlmodel_ext/mixins/cached_table.py

@@ -91,6 +91,7 @@ logger = logging.getLogger(__name__)
 
 from pydantic import ValidationError
 from sqlalchemy import ColumnElement, event, inspect as sa_inspect, select as sa_select
+from sqlalchemy.exc import NoResultFound
 from sqlalchemy.orm import InstanceState, QueryableAttribute, Session as _SyncSession, make_transient_to_detached
 from sqlalchemy.orm.attributes import set_committed_value
 from sqlalchemy.orm.relationships import MANYTOONE  # pyright: ignore[reportPrivateImportUsage]
@@ -1319,6 +1320,15 @@ class CachedTableBaseMixin(TableBaseMixin):
                         if cached is not _LOAD_CACHE_MISS:
                             if cls.on_cache_hit is not None:
                                 cls.on_cache_hit(cls.__name__)
+                            if cached is None and fetch_mode == 'one':
+                                # ``fetch_mode='one'`` type contract guarantees raise (not None);
+                                # when the cache hit is None we must raise, matching the SQL
+                                # path's ``result.one()`` behavior. Otherwise downstream
+                                # ``try/except NoResultFound`` callers (e.g. dep injection that
+                                # maps "missing" to 503) would silently see None and fail later.
+                                raise NoResultFound(
+                                    f"No row was found when one was required: {cls.__name__}(id={id_value})"
+                                )
                             return cached
                         # Redis was actually queried and missed.
 
@@ -1394,18 +1404,25 @@ class CachedTableBaseMixin(TableBaseMixin):
                 else:
                     # Phase 2: merge into the session identity map to preserve
                     # the same semantics as a DB query.
-                    if result is not None:
-                        if isinstance(result, list):
-                            merged_list: list[Self] = []
-                            for item in result:
-                                make_transient_to_detached(item)
-                                merged_list.append(await session.merge(item, load=False))
-                            return merged_list
-                        else:
-                            make_transient_to_detached(result)
-                            result = await session.merge(result, load=False)
                     if cls.on_cache_hit is not None:
                         cls.on_cache_hit(cls.__name__)
+                    if result is None:
+                        if fetch_mode == 'one':
+                            # ``fetch_mode='one'`` type contract guarantees raise (not None);
+                            # raise on cache hit to mirror the SQL path's ``result.one()`` behavior.
+                            raise NoResultFound(
+                                f"No row was found when one was required: {cls.__name__}"
+                            )
+                        return result
+                    if isinstance(result, list):
+                        merged_list: list[Self] = []
+                        for item in result:
+                            make_transient_to_detached(item)
+                            merged_list.append(await session.merge(item, load=False))
+                        return merged_list
+                    else:
+                        make_transient_to_detached(result)
+                        result = await session.merge(result, load=False)
                     return result
 
         # Cache miss callback (only when Redis was actually queried, not skip_cache path)
@@ -1709,35 +1726,53 @@ class CachedTableBaseMixin(TableBaseMixin):
         # SA does not load children and persistent_to_deleted does not fire,
         # so we must query child IDs ourselves before DELETE and invalidate
         # their caches afterwards.
+        #
+        # The walk is BFS over the entire passive_deletes chain — a single
+        # level is not enough. Example: A -[passive=True]-> B -[passive=True]-> C
+        # all use DB CASCADE, SA never loads B or C, persistent_to_deleted
+        # only fires for A. Stale rows of both B and C linger in Redis until
+        # TTL. The BFS prefetches every cached level before issuing DELETE.
         passive_targets: dict[type[CachedTableBaseMixin], list[Any]] = {}
-        try:
-            mapper = sa_inspect(cls)
-            if mapper is None:
-                raise TypeError(f"sa_inspect({cls.__name__}) returned None")
-            for rel in mapper.relationships:
-                if not rel.cascade.delete or not rel.passive_deletes:
-                    continue
-                target = rel.mapper.class_
-                if not (isinstance(target, type) and issubclass(target, CachedTableBaseMixin)):
+        # Queue items: (current_cls, IDs from the previous level, or None for
+        # full-model propagation when the upstream delete used a condition).
+        passive_queue: list[tuple[type, list[Any] | None]] = [
+            (cls, list(instance_ids) if instance_ids else None)
+        ]
+        while passive_queue:
+            current_cls, current_ids = passive_queue.pop(0)
+            try:
+                current_mapper = sa_inspect(current_cls)
+                if current_mapper is None:
                     continue
-                if instance_ids:
+                for rel in current_mapper.relationships:
+                    if not rel.cascade.delete or not rel.passive_deletes:
+                        continue
+                    target = rel.mapper.class_
+                    if not (isinstance(target, type) and issubclass(target, CachedTableBaseMixin)):
+                        continue
+                    if current_ids is None:
+                        # Condition delete or already-full propagation.
+                        if _FULL_MODEL_INVALIDATION not in passive_targets.get(target, []):
+                            passive_targets.setdefault(target, []).append(_FULL_MODEL_INVALIDATION)
+                            passive_queue.append((target, None))
+                        continue
                     remote_cols = list(rel.remote_side)
-                    if len(remote_cols) == 1:
-                        target_mapper = sa_inspect(target)
-                        if target_mapper is None:
-                            continue
-                        target_pk = target_mapper.primary_key[0]
-                        stmt = sa_select(target_pk).where(remote_cols[0].in_(instance_ids))
-                        rows = await session.execute(stmt)
-                        child_ids = [row[0] for row in rows]
-                        if child_ids:
-                            passive_targets[target] = child_ids
-                else:
-                    # Condition deletes cannot enumerate parent IDs; use the
-                    # sentinel to request a model-level full invalidation.
-                    passive_targets[target] = [_FULL_MODEL_INVALIDATION]
-        except Exception as e:
-            logger.warning(f"passive_deletes pre-query failed ({cls.__name__}): {e}")
+                    if len(remote_cols) != 1:
+                        # Composite FK is not supported (matches the original
+                        # single-level behaviour).
+                        continue
+                    target_mapper = sa_inspect(target)
+                    if target_mapper is None:
+                        continue
+                    target_pk = target_mapper.primary_key[0]
+                    stmt = sa_select(target_pk).where(remote_cols[0].in_(current_ids))
+                    rows = await session.execute(stmt)
+                    child_ids = [row[0] for row in rows]
+                    if child_ids:
+                        passive_targets.setdefault(target, []).extend(child_ids)
+                        passive_queue.append((target, child_ids))
+            except Exception as e:
+                logger.warning(f"passive_deletes pre-query failed ({current_cls.__name__}): {e}")
 
         # Clear any leftover cascade data from a previous run (defensive;
         # normal flows never leave residue).

sqlmodel_ext/mixins/table.py

@@ -141,34 +141,170 @@ class TableBaseMixin(AsyncAttrs):
         default_factory=now
     )
 
+    # ==================== IntegrityError friendly-message registry ====================
+    #
+    # Each application module declares its own constraint-name → user-facing message
+    # at the same site as the ``UniqueConstraint`` / ``ForeignKey`` / ``CheckConstraint``
+    # declaration, by calling ``TableBaseMixin.register_*_violation_message(...)``.
+    # Both ``sanitize_integrity_error`` and any global FastAPI integrity-error handler
+    # look up the registry; on hit they return the registered message, otherwise they
+    # fall through to a generic fallback. No code path leaks table/column names or SQL.
+    #
+    # Design:
+    # - The registry hangs off ``TableBaseMixin`` (the root mixin for all table models),
+    #   so it is shared across subclasses.
+    # - ``setdefault`` semantics (first registration wins) protect against duplicate
+    #   registration from re-imports.
+    # - The ``CheckConstraint`` registry only serves ORM-declared CHECKs. Trigger
+    #   ``RAISE EXCEPTION`` errors typically don't carry ``constraint_name``; those
+    #   are surfaced via ``extract_trigger_message`` instead.
+
+    _UNIQUE_VIOLATION_MESSAGES: ClassVar[dict[str, str]] = {}
+    """UNIQUE constraint name -> user-facing message"""
+
+    _FOREIGN_KEY_VIOLATION_MESSAGES: ClassVar[dict[str, str]] = {}
+    """FK constraint name -> user-facing message"""
+
+    _CHECK_VIOLATION_MESSAGES: ClassVar[dict[str, str]] = {}
+    """Declared CHECK constraint name -> user-facing message (trigger-raised check_violation does not go through here)"""
+
+    @staticmethod
+    def register_unique_violation_message(constraint_name: str, friendly_message: str) -> None:
+        """
+        Declare the user-facing message shown when a UNIQUE constraint is violated.
+
+        Call this at module top-level next to the matching ``UniqueConstraint(..., name='xxx')``
+        declaration. SQLModel modules are import-eager (loaded during FastAPI startup),
+        so registration completes before any request runs.
+
+        :param constraint_name: Constraint name, must exactly match the ``name=`` kwarg
+            of the ``UniqueConstraint`` declaration.
+        :param friendly_message: Message returned to the user when the constraint fires.
+            Should not contain table/column names.
+        """
+        _ = TableBaseMixin._UNIQUE_VIOLATION_MESSAGES.setdefault(constraint_name, friendly_message)
+
+    @staticmethod
+    def register_foreign_key_violation_message(constraint_name: str, friendly_message: str) -> None:
+        """
+        Declare the user-facing message shown when a FK constraint is violated
+        (typically for "referenced resource missing" semantics).
+
+        :param constraint_name: FK constraint name (PostgreSQL default is ``<table>_<col>_fkey``)
+        :param friendly_message: User-facing message
+        """
+        _ = TableBaseMixin._FOREIGN_KEY_VIOLATION_MESSAGES.setdefault(constraint_name, friendly_message)
+
+    @staticmethod
+    def register_check_violation_message(constraint_name: str, friendly_message: str) -> None:
+        """
+        Declare the user-facing message shown when a declared ``CheckConstraint`` is violated.
+
+        Only applies to ORM-level ``CheckConstraint(..., name='ck_xxx')``. Database trigger
+        ``RAISE EXCEPTION`` that produces a check_violation typically lacks a
+        ``constraint_name``; those are surfaced by ``extract_trigger_message`` directly
+        and bypass this registry.
+
+        :param constraint_name: CHECK constraint name
+        :param friendly_message: User-facing message
+        """
+        _ = TableBaseMixin._CHECK_VIOLATION_MESSAGES.setdefault(constraint_name, friendly_message)
+
+    @staticmethod
+    def lookup_unique_violation_message(constraint_name: str | None) -> str | None:
+        """Look up the friendly message for a UNIQUE constraint; returns None if missing/unregistered."""
+        if not constraint_name:
+            return None
+        return TableBaseMixin._UNIQUE_VIOLATION_MESSAGES.get(constraint_name)
+
+    @staticmethod
+    def lookup_foreign_key_violation_message(constraint_name: str | None) -> str | None:
+        """Look up the friendly message for a FK constraint; returns None if missing/unregistered."""
+        if not constraint_name:
+            return None
+        return TableBaseMixin._FOREIGN_KEY_VIOLATION_MESSAGES.get(constraint_name)
+
+    @staticmethod
+    def lookup_check_violation_message(constraint_name: str | None) -> str | None:
+        """Look up the friendly message for a declared CHECK constraint; returns None if missing/unregistered."""
+        if not constraint_name:
+            return None
+        return TableBaseMixin._CHECK_VIOLATION_MESSAGES.get(constraint_name)
+
+    @staticmethod
+    def extract_trigger_message(orig: BaseException) -> str:
+        """
+        Extract the first-line business message from an asyncpg ``CheckViolationError``
+        raised by a trigger ``RAISE EXCEPTION`` (strips ``ERROR:`` prefix and ``DETAIL:`` /
+        ``CONTEXT:`` trailing lines).
+
+        Shared between ``sanitize_integrity_error`` and any global integrity-error
+        handler (hence exposed). Other callers should not consume raw trigger
+        messages directly.
+        """
+        message = str(orig)
+        if '\n' in message:
+            message = message.split('\n')[0]
+        if message.startswith('ERROR:'):
+            message = message[6:].strip()
+        return message
+
     @staticmethod
     def sanitize_integrity_error(e: IntegrityError, default_message: str = "Data integrity constraint violation") -> str:
         """
         Extract a safe, user-friendly error message from an IntegrityError.
 
-        PostgreSQL triggers (``RAISE EXCEPTION ... USING ERRCODE = 'check_violation'``)
-        produce SQLSTATE 23514 errors with business-semantic messages that can be
-        shown directly to users. Other constraint errors (FK, unique, etc.) may leak
-        table structure information and need sanitizing.
+        Priority:
+
+        1. ``UniqueViolationError`` (SQLSTATE 23505) / ``ForeignKeyViolationError``
+           (23503) / declared ``CheckConstraint`` (23514 *with* ``constraint_name``):
+           look up the registry, return the registered message on hit, else
+           ``default_message``.
+        2. Trigger ``RAISE EXCEPTION`` check_violation (23514 *without* ``constraint_name``):
+           the message itself is a developer-authored user-facing string; surface
+           it directly via ``extract_trigger_message``.
+        3. Fallback: log the raw error and return ``default_message``.
 
-        Note: This method is PostgreSQL-specific. For other databases, only the
-        default_message will be returned for non-trigger constraint errors.
+        Note: SQLSTATE values are PostgreSQL-specific. For other databases, only
+        ``default_message`` will be returned for non-trigger constraint errors.
 
-        :param e: SQLAlchemy IntegrityError
-        :param default_message: Fallback message for non-trigger constraint errors
+        :param e: SQLAlchemy ``IntegrityError``
+        :param default_message: Fallback message when registry misses and the error
+            is not a trigger-raised check_violation
         :returns: A user-safe error description
         """
         orig = e.orig
-        # check_violation (SQLSTATE 23514): produced by trigger RAISE EXCEPTION
-        if orig is not None and getattr(orig, 'sqlstate', None) == '23514':
-            error_msg = str(orig)
-            # PostgreSQL format: "ERROR: message\nDETAIL: ...\nCONTEXT: ..."
-            if '\n' in error_msg:
-                error_msg = error_msg.split('\n')[0]
-            if error_msg.startswith('ERROR:'):
-                error_msg = error_msg[6:].strip()
-            return error_msg
-        logger.warning(f"Data integrity constraint error: {e}")
+        if orig is None:
+            logger.warning(f"Data integrity constraint error (no orig): {e}")
+            return default_message
+
+        sqlstate = getattr(orig, 'sqlstate', None)
+        constraint = getattr(orig, 'constraint_name', None)
+
+        if sqlstate == '23505':  # UniqueViolation
+            friendly = TableBaseMixin.lookup_unique_violation_message(constraint)
+            if friendly is not None:
+                return friendly
+        elif sqlstate == '23503':  # ForeignKeyViolation
+            friendly = TableBaseMixin.lookup_foreign_key_violation_message(constraint)
+            if friendly is not None:
+                return friendly
+        elif sqlstate == '23514':  # CheckViolation
+            if constraint:
+                # Declared CheckConstraint: only return a registered friendly message;
+                # do not surface the raw message (CheckConstraint expressions may
+                # contain column names).
+                friendly = TableBaseMixin.lookup_check_violation_message(constraint)
+                if friendly is not None:
+                    return friendly
+            else:
+                # Trigger RAISE EXCEPTION: the message is already a user-facing string,
+                # surface it directly.
+                trigger_msg = TableBaseMixin.extract_trigger_message(orig)
+                if trigger_msg:
+                    return trigger_msg
+
+        logger.warning(f"Data integrity constraint error: constraint={constraint}, sqlstate={sqlstate}, orig={e}")
         return default_message
 
     @classmethod
@@ -204,16 +340,20 @@ class TableBaseMixin(AsyncAttrs):
                     # After commit objects expire; use sa_inspect to safely read id
                     _insp = cast(InstanceState[Any], inspect(instance))
                     _inst_id = _insp.identity[0] if _insp.identity else None
-                    assert _inst_id is not None, f"{cls.__name__} id is None after add"
+                    if _inst_id is None:
+                        raise RuntimeError(f"{cls.__name__} id is None after add")
                     result = await cls.get(session, cls.id == _inst_id)
-                    assert result is not None, f"{cls.__name__} record not found (id={_inst_id})"
+                    if result is None:
+                        raise RuntimeError(f"{cls.__name__} record not found (id={_inst_id})")
                     instances[i] = result
             else:
                 _insp = cast(InstanceState[Any], inspect(instances))
                 _inst_id = _insp.identity[0] if _insp.identity else None
-                assert _inst_id is not None, f"{cls.__name__} id is None after add"
+                if _inst_id is None:
+                    raise RuntimeError(f"{cls.__name__} id is None after add")
                 result = await cls.get(session, cls.id == _inst_id)
-                assert result is not None, f"{cls.__name__} record not found (id={_inst_id})"
+                if result is None:
+                    raise RuntimeError(f"{cls.__name__} record not found (id={_inst_id})")
                 instances = result
 
         return instances
@@ -294,9 +434,11 @@ class TableBaseMixin(AsyncAttrs):
         # After commit objects expire; use sa_inspect to safely read id from identity map
         _insp = cast(InstanceState[Any], inspect(instance))
         _instance_id = _insp.identity[0] if _insp.identity else None
-        assert _instance_id is not None, f"{cls.__name__} id is None after save"
+        if _instance_id is None:
+            raise RuntimeError(f"{cls.__name__} id is None after save")
         result = await cls.get(session, cls.id == _instance_id, load=load, jti_subclasses=jti_subclasses)
-        assert result is not None, f"{cls.__name__} record not found (id={_instance_id})"
+        if result is None:
+            raise RuntimeError(f"{cls.__name__} record not found (id={_instance_id})")
         return result
 
     async def update(
@@ -375,9 +517,11 @@ class TableBaseMixin(AsyncAttrs):
         # After commit objects expire; use sa_inspect to safely read id from identity map
         _insp = cast(InstanceState[Any], inspect(instance))
         _instance_id = _insp.identity[0] if _insp.identity else None
-        assert _instance_id is not None, f"{cls.__name__} id is None after update"
+        if _instance_id is None:
+            raise RuntimeError(f"{cls.__name__} id is None after update")
         result = await cls.get(session, cls.id == _instance_id, load=load, jti_subclasses=jti_subclasses)
-        assert result is not None, f"{cls.__name__} record not found (id={_instance_id})"
+        if result is None:
+            raise RuntimeError(f"{cls.__name__} record not found (id={_instance_id})")
         return result
 
     @classmethod
@@ -1025,14 +1169,14 @@ class TableBaseMixin(AsyncAttrs):
 
     @overload
     @classmethod
-    async def get_exist_one(cls: type[T], session: AsyncSession, id: int, load: QueryableAttribute[Any] | list[QueryableAttribute[Any]] | None = None) -> T: ...
+    async def get_exist_one(cls: type[T], session: AsyncSession, id: int, load: QueryableAttribute[Any] | list[QueryableAttribute[Any]] | None = None, *, detail: str = "Not found") -> T: ...
 
     @overload
     @classmethod
-    async def get_exist_one(cls: type[T], session: AsyncSession, id: uuid.UUID, load: QueryableAttribute[Any] | list[QueryableAttribute[Any]] | None = None) -> T: ...
+    async def get_exist_one(cls: type[T], session: AsyncSession, id: uuid.UUID, load: QueryableAttribute[Any] | list[QueryableAttribute[Any]] | None = None, *, detail: str = "Not found") -> T: ...
 
     @classmethod
-    async def get_exist_one(cls: type[T], session: AsyncSession, id: int | uuid.UUID, load: QueryableAttribute[Any] | list[QueryableAttribute[Any]] | None = None) -> T:
+    async def get_exist_one(cls: type[T], session: AsyncSession, id: int | uuid.UUID, load: QueryableAttribute[Any] | list[QueryableAttribute[Any]] | None = None, *, detail: str = "Not found") -> T:
         """
         Get a record by primary key ID, raising 404 if not found.
 
@@ -1042,6 +1186,10 @@ class TableBaseMixin(AsyncAttrs):
         :param session: Async database session
         :param id: Primary key ID
         :param load: Relationship(s) to eagerly load
+        :param detail: 404 response detail text (default ``"Not found"``).
+            Callers may supply a localized / context-specific message
+            (e.g. ``"Bundle not found"``) without falling back to manual
+            ``get(...) + null check + raise`` boilerplate.
         :returns: The found instance
         :raises HTTPException: (FastAPI) If not found
         :raises RecordNotFoundError: (no FastAPI) If not found
@@ -1049,8 +1197,8 @@ class TableBaseMixin(AsyncAttrs):
         instance = await cls.get(session, col(cls.id) == id, load=load)
         if instance is None:
             if _HAS_FASTAPI:
-                raise _FastAPIHTTPException(status_code=404, detail="Not found")
-            raise RecordNotFoundError("Not found")
+                raise _FastAPIHTTPException(status_code=404, detail=detail)
+            raise RecordNotFoundError(detail)
         return instance
 
 
@@ -1090,15 +1238,16 @@ class UUIDTableBaseMixin(TableBaseMixin):
 
     @override
     @classmethod
-    async def get_exist_one(cls: type[T], session: AsyncSession, id: uuid.UUID, load: QueryableAttribute[Any] | list[QueryableAttribute[Any]] | None = None) -> T:
+    async def get_exist_one(cls: type[T], session: AsyncSession, id: uuid.UUID, load: QueryableAttribute[Any] | list[QueryableAttribute[Any]] | None = None, *, detail: str = "Not found") -> T:
         """
         Get a record by UUID primary key, raising 404 if not found.
 
         :param session: Async database session
         :param id: UUID primary key
         :param load: Relationship(s) to eagerly load
+        :param detail: 404 response detail text (default ``"Not found"``)
         :returns: The found instance
         :raises HTTPException: (FastAPI) If not found
         :raises RecordNotFoundError: (no FastAPI) If not found
         """
-        return await super().get_exist_one(session, id, load)
+        return await super().get_exist_one(session, id, load, detail=detail)

sqlmodel_ext/pagination.py

@@ -97,8 +97,8 @@ class PaginationRequest(SQLModelBase):
     offset: int | None = Field(default=0, ge=0)
     """Offset (skip first N records), must be non-negative"""
 
-    limit: int | None = Field(default=50, le=100)
-    """Page size (return at most N records), default 50, max 100"""
+    limit: int | None = Field(ge=1, default=50, le=100)
+    """Page size (return at most N records), min 1, default 50, max 100"""
 
     desc: bool | None = True
     """Sort descending (True: descending, False: ascending)"""

sqlmodel_ext/relation_load_checker.py

@@ -1093,8 +1093,15 @@ class RelationLoadChecker:
         """
         Check a model method (with self tracking and @requires_relations parsing).
 
-        self is marked as caller_provided; pre-commit access skips RLC003.
-        But self.save() followed by relationship access still triggers RLC002.
+        All method parameters (``self`` plus other model-typed arguments) are marked
+        as caller_provided — these objects are passed in by the caller, preloading
+        is the caller's contract (typically declared via a docstring "preload before
+        calling: ..." note), so the method body must not be flagged with RLC003 for
+        "missing load=". This matches ``_check_coroutine``'s policy of marking all
+        params as caller_provided.
+
+        Post-commit relation access still triggers RLC002 / RLC007 / RLC008
+        (caller_provided does not exempt those checks).
         """
         # Parse AST to extract @requires_relations
         source_file, tree, line_offset = self._parse_function_source(func)
@@ -1114,17 +1121,19 @@ class RelationLoadChecker:
         # Detect instance method or classmethod
         sig = python_inspect.signature(func)
         first_param = next(iter(sig.parameters), None)
-        caller_provided_params: set[str] = set()
 
         # cls -> class alias (classmethod's cls parameter doesn't enter tracked_vars,
         # only used for resolving class-level calls)
         class_aliases: dict[str, str] = {}
         if first_param == 'self':
             param_models['self'] = cls_name
-            caller_provided_params.add('self')
         elif first_param == 'cls':
             class_aliases['cls'] = cls_name
 
+        # All method params are caller-provided (self + other model-typed args
+        # are the caller's preload responsibility).
+        caller_provided_params: set[str] = set(param_models.keys())
+
         # @requires_relations declared rels as self's dep_loads
         dep_loads: dict[str, set[str]] = {}
         if 'self' in param_models and decorator_loads:
@@ -1225,7 +1234,15 @@ class RelationLoadChecker:
             model_rel_targets=self.model_rel_targets,
             refreshing_commit_methods=self.refreshing_commit_methods,
         )
-        analyzer.visit(func_node)
+        # Manually iterate ``func_node.body`` instead of ``analyzer.visit(func_node)``:
+        # ``visit_FunctionDef`` / ``visit_AsyncFunctionDef`` are no-ops (used to skip
+        # nested function bodies — see their docstrings). Calling ``visit(func_node)``
+        # on the top-level entry would also hit that no-op and swallow the entire
+        # function body. Manual iteration dispatches each top-level statement (Return /
+        # Assign / Expr / ...) to its visit_* handler, while nested ``def`` statements
+        # in the body still hit the no-op and are correctly skipped.
+        for stmt in func_node.body:
+            analyzer.visit(stmt)
 
         return list(analyzer.warnings), analyzer
 
@@ -1287,20 +1304,32 @@ class RelationLoadChecker:
         (e.g. TYPE_CHECKING forward references), falls back to per-parameter
         ``__annotations__`` parsing to ensure resolvable params aren't missed.
 
+        TYPE_CHECKING forward reference handling: passes ``self.model_classes``
+        (all mapped ORM classes) as ``localns`` to ``get_type_hints()`` so that
+        string annotations like ``llm: 'LLM'`` (where ``LLM`` is imported only
+        under ``if TYPE_CHECKING:``) resolve to actual classes instead of being
+        silently dropped — silent drops cause RLC007/RLC013 false negatives.
+
         :returns: param_name -> model_class_name
         """
         param_models: dict[str, str] = {}
 
+        # Provide model_classes as localns so TYPE_CHECKING forward references resolve.
+        localns: dict[str, Any] = dict(self.model_classes)
         try:
-            hints = typing.get_type_hints(func, include_extras=True)
+            hints = typing.get_type_hints(func, include_extras=True, localns=localns)
         except Exception:
-            # get_type_hints may fail due to TYPE_CHECKING forward references.
-            # Fall back to per-parameter __annotations__ (skip unresolvable string annotations)
+            # Even with model_classes in scope, get_type_hints may still fail on
+            # nested third-party ForwardRefs. Fall back to per-parameter __annotations__:
+            # try to eval string annotations against globals + model_classes.
             hints = {}
             annotations: dict[str, Any] = getattr(func, '__annotations__', {})
             for param_name, annotation in annotations.items():
                 if isinstance(annotation, str):
-                    continue  # Skip unresolvable string annotations
+                    resolved = self._eval_string_annotation(annotation, func)
+                    if resolved is not None:
+                        hints[param_name] = resolved
+                    continue
                 hints[param_name] = annotation
 
         for param_name, hint in hints.items():
@@ -1333,6 +1362,24 @@ class RelationLoadChecker:
 
         return param_models
 
+    def _eval_string_annotation(self, annotation: str, func: Any) -> Any:
+        """
+        Evaluate a string annotation that ``typing.get_type_hints`` couldn't resolve.
+
+        Typical case: a TYPE_CHECKING-only import is referenced as a forward reference
+        (e.g. ``llm: 'LLM'`` where ``LLM`` is imported only under ``if TYPE_CHECKING:``).
+        Evaluates against ``func.__globals__`` merged with the known ORM model classes.
+
+        Supported forms: ``'LLM'``, ``'LLM | None'``, ``'list[LLM]'`` etc.
+        Returns ``None`` on failure (silent skip, matches the original fallback).
+        """
+        globalns: dict[str, Any] = getattr(func, '__globals__', {}) or {}
+        localns: dict[str, Any] = dict(self.model_classes)
+        try:
+            return eval(annotation, globalns, localns)  # noqa: S307 — source-code literal, scoped namespace
+        except Exception:
+            return None
+
     def _extract_model_from_hint(self, hint: Any) -> str | None:
         """
         Extract a model class name from a type annotation.
@@ -2765,6 +2812,20 @@ class _FunctionAnalyzer(ast.NodeVisitor):
                 method_name = self._get_method_name(call)
                 loaded_rels = self._extract_load_from_call(call)
 
+                # RLC010: check whether ``return await Call(..., expired_arg)`` carries
+                # post-commit expired objects as call args. Previously visit_Return only
+                # checked relationship preloading (_check_return_loaded), leaving
+                # ``return await callee(..., expired_var)`` paths uncovered. Mirrors the
+                # symmetric checks in visit_Expr and _check_assign.
+                # Example scenario:
+                #     user_file = await cls._unchecked(...)  # commits → tracked vars expire
+                #     return await user_file._moderate(session, config=config)
+                #                                              ^^^^^^^^^^^^^
+                #                                              ``config`` expired; callee's
+                #                                              ``config.attr`` triggers
+                #                                              MissingGreenlet.
+                self._check_expired_call_args(call, node)
+
                 # return await obj.save/update/create_duplicate/... (commit methods)
                 if self._is_commit_for_call(call, method_name):
                     obj_name = self._get_call_object_name(call)
@@ -3383,6 +3444,33 @@ class _FunctionAnalyzer(ast.NodeVisitor):
         if self.has_session_param:
             self._expire_all_tracked_vars_for_yield()
 
+    @override
+    def visit_FunctionDef(self, node: ast.FunctionDef) -> None:
+        """
+        Do not recurse into nested function definitions.
+
+        AST default DFS would descend into nested ``def`` bodies and count
+        their yield/await statements as part of the outer function's flow,
+        producing false positives. Nested function bodies execute in their
+        own scope when invoked, not as part of the outer flow.
+
+        Typical false positive:
+            ``async def outer(...):
+                async def _inner():
+                    yield chunk``
+        The outer function has no yield, but ``_inner``'s yield was being
+        counted as the outer's, triggering RLC013.
+
+        Trade-off: nested closures are not analyzed under the current
+        scope. Independently scanning them would require a second pass
+        with closure capture analysis; in practice nested closures rarely
+        access ORM directly, so we accept the gap.
+        """
+
+    @override
+    def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef) -> None:
+        """Do not recurse into nested async function definitions (same as visit_FunctionDef)."""
+
     # ========================= Branch-aware state management =========================
 
     def _snapshot_tracked_vars(self) -> dict[str, _TrackedVar]:

{sqlmodel_ext-0.3.2.dist-info → sqlmodel_ext-0.3.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlmodel-ext
-Version: 0.3.2
+Version: 0.3.3
 Summary: Extended SQLModel infrastructure: smart metaclass, async CRUD mixins, polymorphic inheritance, optimistic locking, relation preloading, and reusable field types.
 Project-URL: Homepage, https://github.com/Foxerine/sqlmodel-ext
 Project-URL: Repository, https://github.com/Foxerine/sqlmodel-ext

{sqlmodel_ext-0.3.2.dist-info → sqlmodel_ext-0.3.3.dist-info}/RECORD

@@ -1,12 +1,12 @@
-sqlmodel_ext/__init__.py,sha256=elrg3UrCZ52B3WNO8uwDD8kff7TyIuxjZsVLKKjOzhU,2833
-sqlmodel_ext/_compat.py,sha256=keZBO_ZYEG1qpvzDAzGNaKXaxY9QUY4hx7JIaas9EDY,11302
+sqlmodel_ext/__init__.py,sha256=n0ulFKaNBxk5h8WYaxVDbJdhN3yD_ySR52ZYvRw7FZc,2833
+sqlmodel_ext/_compat.py,sha256=zia-2vSQqmzk6_4Y404IKzcip5n4fe7PrRAYntlY-Zg,12186
 sqlmodel_ext/_exceptions.py,sha256=2mC_BVvcreaFutR4UxIra238o1sr4zWv8vctBI6CL2o,413
 sqlmodel_ext/_sa_type.py,sha256=zDwXBR0O7dne3Y6j8V8CaMtfqZqcpvsPucZUxGh8dAk,4866
 sqlmodel_ext/_utils.py,sha256=cFrlQp1Uq-4ZAdvi_u79UbEI0IHZaAm5VkXadCXrBmI,174
-sqlmodel_ext/base.py,sha256=GuEcsFOUrDyKvXvAZdi0-KWI9Os66Qt0Cd4fCpzJ4FY,46255
-sqlmodel_ext/pagination.py,sha256=b9i0y3GwUfqQPDugI7gx4Y9IMhYAOtkQBEgCaJJDrmM,4598
-sqlmodel_ext/relation_load_checker.py,sha256=MI9Breb7_qwElDT8E0K09D7VPcF3TGwoWtxKZiEhMmA,167328
-sqlmodel_ext/field_types/__init__.py,sha256=vN7dnPIE5wXUqme38iD2n56bTZrjkeFPQIMW1CSA8_4,6579
+sqlmodel_ext/base.py,sha256=ADFwrEW5UJBSAVEEqLrWz_tIHpaj5iBCiBFRyd9jjc4,52848
+sqlmodel_ext/pagination.py,sha256=1JOzt51KvIZTyjgYsQTP0v7KDytIkQKlYN4vGkq9RH8,4611
+sqlmodel_ext/relation_load_checker.py,sha256=1W2vSdk_PVTqBRRcSyIffw-ECysJRfg1bJYVTmx9Wxs,172457
+sqlmodel_ext/field_types/__init__.py,sha256=dFnaZxQb6ItO3ZrQ1RyqAceykF_JyFrYnJvdjq7mFPE,7916
 sqlmodel_ext/field_types/_ssrf.py,sha256=QdrtwWMFN6xZkllyHGwvJ0nwL3rSBn2FkEoxv3L8kvs,2627
 sqlmodel_ext/field_types/ip_address.py,sha256=OeyOAVgDV7aGk56z0LUqgYCinthYYusmZSCR1BLkET4,1589
 sqlmodel_ext/field_types/url.py,sha256=1iAdu3A9uyMR3XJMs0b3NJ2_VeBAEAfja-_xbdjph5I,5209
@@ -21,13 +21,13 @@ sqlmodel_ext/field_types/dialects/postgresql/numpy_vector.py,sha256=q9eOCcFyaw4d
 sqlmodel_ext/field_types/mixins/__init__.py,sha256=d8L1AA1sBL2zrvJk6X38ArcZ2SoXnVpDbOQc36s4Yug,48
 sqlmodel_ext/field_types/mixins/module_name_mixin.py,sha256=CAn-DFo7LMQpgwuOpaYHo2ib1ehYz7-1NOOTgAAFxOg,1099
 sqlmodel_ext/mixins/__init__.py,sha256=DS9vPiPgcJFuT2PlUIP0EySbpcrxiB9dzJJOtd1caA0,906
-sqlmodel_ext/mixins/cached_table.py,sha256=tmXcwgx9C2ifc4xsG5EecKY5-shp6r6jlzZcEOVI18c,96838
+sqlmodel_ext/mixins/cached_table.py,sha256=ugyX8h-WP60gZP-hDR4eh6RUXtBgldPVzpeT9K5DnVo,99216
 sqlmodel_ext/mixins/info_response.py,sha256=Z8akOpN9wlhiq5_MbzEjwGpGDQ99jYvGQt9sItF43ek,1319
 sqlmodel_ext/mixins/optimistic_lock.py,sha256=XVjO6NgKYfpcsGlH1Yj8Ou9NkpCsqVN9AZyWxDBTb_k,2925
 sqlmodel_ext/mixins/polymorphic.py,sha256=rX2XER0s0kRhHnpmwWUUj6wEaImCM2KBzgkh2M1wRIk,27836
 sqlmodel_ext/mixins/relation_preload.py,sha256=SD9Nnc8zIbUqWqI85gr4XRpbPsmJwXQd7JPHj_EVrLs,15967
-sqlmodel_ext/mixins/table.py,sha256=hJPeQX1GDhLs9dTUnHVPhPbfZX6Pk3wQX49KIpDAJ9o,48826
-sqlmodel_ext-0.3.2.dist-info/METADATA,sha256=JOsJ_iUaija-jMpUPRP-LcELshEvtw0U7Ygm6E7_WqM,49387
-sqlmodel_ext-0.3.2.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-sqlmodel_ext-0.3.2.dist-info/licenses/LICENSE,sha256=8ek0ENxpcXcIhCC7MXetxiYLKflHqz2JbA-nwDqTsyI,1088
-sqlmodel_ext-0.3.2.dist-info/RECORD,,
+sqlmodel_ext/mixins/table.py,sha256=BsOoimqZwD64EjZpVHffXU_in7G2utS2CprdPXMSQQo,56444
+sqlmodel_ext-0.3.3.dist-info/METADATA,sha256=1S0wju_2F95t-ySh-GBNbH5X1qogPlTS2dkvNc8zujs,49387
+sqlmodel_ext-0.3.3.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+sqlmodel_ext-0.3.3.dist-info/licenses/LICENSE,sha256=8ek0ENxpcXcIhCC7MXetxiYLKflHqz2JbA-nwDqTsyI,1088
+sqlmodel_ext-0.3.3.dist-info/RECORD,,