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

sqlmodel_ext/base.py

@@ -28,9 +28,15 @@ from sqlmodel.main import (
     is_table_model_class,
     get_relationship_to,
     FieldInfo as SQLModelFieldInfo,  # Internal API: stable since sqlmodel 0.0.22
+    FieldInfoMetadata,  # Internal API: pydantic-rebuild-safe sa_type carrier
     get_column_from_field,  # Internal API: stable since sqlmodel 0.0.22
 )
 
+# sqlmodel's FieldInfoMetadata fields default to sqlmodel's own Undefined
+# sentinel (distinct from pydantic_core PydanticUndefined imported above);
+# capture it to detect "sa_type not yet set" without importing sqlmodel internals.
+_FIM_UNSET_SA_TYPE = FieldInfoMetadata().sa_type
+
 # Import _compat for side effects (Python 3.14 monkey-patches)
 import sqlmodel_ext._compat  # noqa: F401
 
@@ -143,6 +149,49 @@ def _find_field_info_in_annotated(annotation: Any) -> SQLModelFieldInfo | None:
     return merged
 
 
+def _durably_set_sa_type(field_info: Any, sa_type: Any) -> None:
+    """
+    Inject ``sa_type`` so it survives Pydantic's model_fields rebuild.
+
+    Root cause this fixes: the metaclass extracts ``sa_type`` from
+    ``Array[T]`` / custom Annotated handlers and must hand it to SQLModel's
+    column builder. A plain ``setattr(field_info, 'sa_type', sa_type)`` is
+    LOST: ``SQLModelMetaclass.__new__`` (invoked from our ``super().__new__``)
+    runs ``get_column_from_field`` *before* step-7's SQLModelFieldInfo
+    restore, and Pydantic has by then rebuilt ``model_fields`` into fresh
+    FieldInfo objects that never saw the post-hoc attribute. The previous
+    code only fixed the no-``= Field(...)`` branch (c00696c); the explicit
+    ``Array[T] = Field(default_factory=list)`` form still raised
+    ``<class 'list'> has no matching SQLAlchemy type``.
+
+    Fix: write ``sa_type`` into a ``FieldInfoMetadata`` entry inside the
+    FieldInfo's pydantic ``metadata`` list — the exact channel SQLModel's
+    own ``Field(sa_type=...)`` uses and which ``get_sqlalchemy_type``
+    (via ``_get_sqlmodel_field_value``) reads *first*. Pydantic preserves
+    the ``metadata`` list across rebuilds, so the type survives into the
+    column build. The instance attribute is also set as a belt-and-braces
+    fallback for any direct ``getattr(field_info, 'sa_type')`` reader.
+
+    :param field_info: target FieldInfo (user's Field or recovered Annotated FI)
+    :param sa_type: SQLAlchemy type extracted from the annotation handler
+    """
+    md = list(getattr(field_info, 'metadata', None) or [])
+    existing = next(
+        (m for m in md if isinstance(m, FieldInfoMetadata)), None
+    )
+    if existing is not None:
+        if existing.sa_type is _FIM_UNSET_SA_TYPE:
+            existing.sa_type = sa_type
+    else:
+        md.append(FieldInfoMetadata(sa_type=sa_type))
+        field_info.metadata = md
+    if getattr(field_info, 'sa_type', Undefined) is Undefined:
+        try:
+            field_info.sa_type = sa_type
+        except (AttributeError, TypeError):
+            pass
+
+
 def _make_annotation_optional(annotation: typing.Any) -> typing.Any:
     """
     Convert type annotation to optional: ``T → T | None``
@@ -602,14 +651,16 @@ class __DeclarativeMeta(SQLModelMetaclass):
                     # 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)
+                        _durably_set_sa_type(annotated_fi, 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)
+                    # Explicit ``Array[T] = Field(default_factory=list)`` form.
+                    # Must inject sa_type via the pydantic-rebuild-safe
+                    # FieldInfoMetadata channel — plain setattr is dropped
+                    # before SQLModel's column build (see _durably_set_sa_type).
+                    _durably_set_sa_type(field_value, sa_type)
 
         # 5. Save SQLModel FieldInfo from Annotated fields before super().__new__(),
         # because Pydantic rebuilds model_fields with plain FieldInfo that lacks

{sqlmodel_ext-0.3.4.dist-info → sqlmodel_ext-0.3.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlmodel-ext
-Version: 0.3.4
+Version: 0.3.5
 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
@@ -170,10 +170,12 @@ async def demo(session: AsyncSession):
 A complete REST API -- models, DTOs, and five endpoints:
 
 ```python
+from collections.abc import AsyncGenerator
 from typing import Annotated
 from uuid import UUID
 
 from fastapi import APIRouter, Depends
+from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine
 from sqlmodel import Field
 from sqlmodel.ext.asyncio.session import AsyncSession
 from sqlmodel_ext import (
@@ -181,17 +183,37 @@ from sqlmodel_ext import (
     ListResponse, TableViewRequest, UUIDIdDatetimeInfoMixin,
 )
 
-# ── Dependencies (defined once, reused everywhere) ────────────────
+# ── Dependency-injection layer: declare once (e.g. in a shared
+#    deps module), every router imports the type aliases ────────────
+
+_engine = create_async_engine("postgresql+asyncpg://localhost/app")
+_Session = async_sessionmaker(_engine, expire_on_commit=True)
+
+async def get_session() -> AsyncGenerator[AsyncSession, None]:
+    async with _Session() as session:
+        yield session
 
 SessionDep = Annotated[AsyncSession, Depends(get_session)]
-TableViewDep = Annotated[TableViewRequest, Depends()]
+"""Request-scoped AsyncSession. The single way endpoints touch the DB."""
 
-# ── Models ────────────────────────────────────────────────────────
+# TableViewRequest is a Pydantic model → FastAPI binds its fields as
+# query params automatically. No hand-written offset/limit/order plumbing.
+TableViewRequestDep = Annotated[TableViewRequest, Depends()]
+
+async def get_current_user(session: SessionDep) -> "User":
+    ...  # decode the bearer token, load the user — your auth, unchanged
+
+CurrentUserDep = Annotated["User", Depends(get_current_user)]
+
+# ── Models: the DTO ladder (Base → Create → Update → Response) ─────
 
 class ArticleBase(SQLModelBase):
     title: Str64
+    """Article title"""
     body: Text10K
+    """Article body (max 10k chars)"""
     is_published: bool = False
+    """Whether the article is publicly visible"""
 
 class Article(ArticleBase, UUIDTableBaseMixin, table=True):
     author_id: UUID = Field(foreign_key='user.id')
@@ -199,14 +221,24 @@ class Article(ArticleBase, UUIDTableBaseMixin, table=True):
 class ArticleCreate(ArticleBase):
     pass
 
-class ArticleUpdate(ArticleBase):
-    title: Str64 | None = None       # Override to optional,
-    body: Text10K | None = None      # preserving the original
-    is_published: bool | None = None  # type constraints from Base
+# all_fields_optional flips every inherited field to ``T | None = None``
+# while preserving its Annotated constraints AND attribute docstrings —
+# no hand-maintained per-field overrides.
+class ArticleUpdate(ArticleBase, all_fields_optional=True):
+    pass
 
 class ArticleResponse(ArticleBase, UUIDIdDatetimeInfoMixin):
     author_id: UUID
 
+# ── Resource-as-dependency: wrap "load by id or 404" once, then the
+#    fetched ORM instance is just another injected parameter ────────
+
+async def get_article(session: SessionDep, article_id: UUID) -> Article:
+    return await Article.get_exist_one(session, article_id)
+
+ArticleDep = Annotated[Article, Depends(get_article)]
+"""The Article for {article_id}, or 404 — fetched before the handler runs."""
+
 # ── Endpoints ─────────────────────────────────────────────────────
 
 router = APIRouter(prefix="/articles", tags=["articles"])
@@ -220,7 +252,7 @@ async def create_article(
 
 @router.get("", response_model=ListResponse[ArticleResponse])
 async def list_articles(
-        session: SessionDep, table_view: TableViewDep,
+        session: SessionDep, table_view: TableViewRequestDep,
 ) -> ListResponse[Article]:
     return await Article.get_with_count(
         session,
@@ -228,24 +260,24 @@ async def list_articles(
         table_view=table_view,
     )
 
+# article: ArticleDep — the 404 + fetch is the dependency's job, so the
+# single-resource handlers carry no lookup boilerplate at all.
 @router.get("/{article_id}", response_model=ArticleResponse)
-async def get_article(session: SessionDep, article_id: UUID) -> Article:
-    return await Article.get_exist_one(session, article_id)
+async def get_article_detail(article: ArticleDep) -> Article:
+    return article
 
 @router.patch("/{article_id}", response_model=ArticleResponse)
 async def update_article(
-        session: SessionDep, article_id: UUID, data: ArticleUpdate,
+        session: SessionDep, article: ArticleDep, data: ArticleUpdate,
 ) -> Article:
-    article = await Article.get_exist_one(session, article_id)
     return await article.update(session, data)
 
 @router.delete("/{article_id}")
-async def delete_article(session: SessionDep, article_id: UUID) -> None:
-    article = await Article.get_exist_one(session, article_id)
+async def delete_article(session: SessionDep, article: ArticleDep) -> None:
     await Article.delete(session, article)
 ```
 
-No manual SQL, no hand-written pagination logic, no boilerplate session management. The `TableViewDep` gives clients `offset`, `limit`, `desc`, `order`, and four time filters out of the box.
+No manual SQL, no hand-written pagination logic, no boilerplate session management. The `TableViewRequestDep` gives clients `offset`, `limit`, `desc`, `order`, and four time filters out of the box.
 
 **What the client gets from `GET /articles?offset=0&limit=10&desc=true`:**
 
@@ -440,7 +472,7 @@ class PushNotification(NotifSubclassId, Notification, AutoPolymorphicIdentityMix
 
 @router.get("/notifications", response_model=ListResponse[NotificationBase])
 async def list_notifications(
-        session: SessionDep, user: CurrentUserDep, table_view: TableViewDep,
+        session: SessionDep, user: CurrentUserDep, table_view: TableViewRequestDep,
 ) -> ListResponse[Notification]:
     return await Notification.get_with_count(
         session,

{sqlmodel_ext-0.3.4.dist-info → sqlmodel_ext-0.3.5.dist-info}/RECORD

@@ -1,9 +1,9 @@
-sqlmodel_ext/__init__.py,sha256=PbFopnDRXl6y3Raas4VuePuQPpY5TQMGAyqe4P7AZiM,2862
+sqlmodel_ext/__init__.py,sha256=2X2Dpu8wC5e5w8uygvc0ZNAC-P_t9OnWQd4mfM9mYKY,2862
 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=ADFwrEW5UJBSAVEEqLrWz_tIHpaj5iBCiBFRyd9jjc4,52848
+sqlmodel_ext/base.py,sha256=J--AdnXPxHoZ_uOoxuIQIhAoHwkrfnBIObTSQT977d0,55481
 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
@@ -27,7 +27,7 @@ sqlmodel_ext/mixins/optimistic_lock.py,sha256=XVjO6NgKYfpcsGlH1Yj8Ou9NkpCsqVN9AZ
 sqlmodel_ext/mixins/polymorphic.py,sha256=rX2XER0s0kRhHnpmwWUUj6wEaImCM2KBzgkh2M1wRIk,27836
 sqlmodel_ext/mixins/relation_preload.py,sha256=SD9Nnc8zIbUqWqI85gr4XRpbPsmJwXQd7JPHj_EVrLs,15967
 sqlmodel_ext/mixins/table.py,sha256=BsOoimqZwD64EjZpVHffXU_in7G2utS2CprdPXMSQQo,56444
-sqlmodel_ext-0.3.4.dist-info/METADATA,sha256=D13ATIqAPkZ3qbzI4nBTtuCPx9oPdMjIH_D_OeP1gm4,49387
-sqlmodel_ext-0.3.4.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-sqlmodel_ext-0.3.4.dist-info/licenses/LICENSE,sha256=8ek0ENxpcXcIhCC7MXetxiYLKflHqz2JbA-nwDqTsyI,1088
-sqlmodel_ext-0.3.4.dist-info/RECORD,,
+sqlmodel_ext-0.3.5.dist-info/METADATA,sha256=RrQXH6fYG872w349elyjSErryB3u_R7xuH7dF1Pv0Ow,50709
+sqlmodel_ext-0.3.5.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+sqlmodel_ext-0.3.5.dist-info/licenses/LICENSE,sha256=8ek0ENxpcXcIhCC7MXetxiYLKflHqz2JbA-nwDqTsyI,1088
+sqlmodel_ext-0.3.5.dist-info/RECORD,,