sqlmodel-mypy-plugin 0.12.2__tar.gz → 0.12.3__tar.gz

{sqlmodel_mypy_plugin-0.12.2 → sqlmodel_mypy_plugin-0.12.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlmodel-mypy-plugin
-Version: 0.12.2
+Version: 0.12.3
 Summary: Mypy plugin for SQLModel (better constructor/Field typing).
 Project-URL: Homepage, https://github.com/sertione/sqlmodel-mypy-plugin
 Project-URL: Repository, https://github.com/sertione/sqlmodel-mypy-plugin
@@ -168,6 +168,18 @@ You can also use SQLAlchemy table metadata attributes without `attr-defined` noi
 tbl = User.__table__
 ```
 
+### `getattr(Model, "field")` support
+
+If you build query filters dynamically, `getattr(Model, "field")` with a **string literal** is typed the same as
+direct `Model.field` access on `table=True` models:
+
+```py
+stmt = select(User).where(getattr(User, "name").like("%x%"))
+```
+
+Non-literal names (runtime strings) are intentionally left as `Any` (you’ll still need a cast or a different
+pattern).
+
 ### Relationship comparator typing
 
 Relationship attributes declared via `Relationship(...)` are typed as SQLAlchemy expressions at class level,
@@ -181,9 +193,11 @@ stmt = select(Team).where(Team.heroes.contains(hero_obj))
 
 ### Out of scope
 
-- **`column_property(...)` and similar SQLAlchemy helpers**: this plugin doesn’t try to “fix” the *declaration-site*
-  typing for SQLAlchemy-only APIs that aren’t part of SQLModel’s surface area. Prefer SQLAlchemy-typed patterns like
-  `Mapped[...]` / `InstrumentedAttribute[...]` (or local casts/`# type: ignore` if needed).
+- **Most SQLAlchemy-only declaration helpers**: this plugin doesn’t try to “fix” the full *declaration-site* typing
+  for SQLAlchemy ORM APIs that aren’t part of SQLModel’s surface area.
+  - Exception: best-effort return typing for `column_property(...)` (infers `Mapped[T]` from `ScalarSelect[T]` /
+    `ColumnElement[T]`) to support patterns like `Model._foo = column_property(...)` combined with
+    `getattr(Model, "_foo")` in query builders.
 - **Pydantic `@computed_field`**: not touched by this plugin (it should type-check via normal property typing / Pydantic
   typing).
 

{sqlmodel_mypy_plugin-0.12.2 → sqlmodel_mypy_plugin-0.12.3}/README.md

@@ -122,6 +122,18 @@ You can also use SQLAlchemy table metadata attributes without `attr-defined` noi
 tbl = User.__table__
 ```
 
+### `getattr(Model, "field")` support
+
+If you build query filters dynamically, `getattr(Model, "field")` with a **string literal** is typed the same as
+direct `Model.field` access on `table=True` models:
+
+```py
+stmt = select(User).where(getattr(User, "name").like("%x%"))
+```
+
+Non-literal names (runtime strings) are intentionally left as `Any` (you’ll still need a cast or a different
+pattern).
+
 ### Relationship comparator typing
 
 Relationship attributes declared via `Relationship(...)` are typed as SQLAlchemy expressions at class level,
@@ -135,9 +147,11 @@ stmt = select(Team).where(Team.heroes.contains(hero_obj))
 
 ### Out of scope
 
-- **`column_property(...)` and similar SQLAlchemy helpers**: this plugin doesn’t try to “fix” the *declaration-site*
-  typing for SQLAlchemy-only APIs that aren’t part of SQLModel’s surface area. Prefer SQLAlchemy-typed patterns like
-  `Mapped[...]` / `InstrumentedAttribute[...]` (or local casts/`# type: ignore` if needed).
+- **Most SQLAlchemy-only declaration helpers**: this plugin doesn’t try to “fix” the full *declaration-site* typing
+  for SQLAlchemy ORM APIs that aren’t part of SQLModel’s surface area.
+  - Exception: best-effort return typing for `column_property(...)` (infers `Mapped[T]` from `ScalarSelect[T]` /
+    `ColumnElement[T]`) to support patterns like `Model._foo = column_property(...)` combined with
+    `getattr(Model, "_foo")` in query builders.
 - **Pydantic `@computed_field`**: not touched by this plugin (it should type-check via normal property typing / Pydantic
   typing).
 

{sqlmodel_mypy_plugin-0.12.2 → sqlmodel_mypy_plugin-0.12.3}/ROADMAP.md

@@ -22,7 +22,12 @@
   - Ensure common SQLModel re-exports (`select`, `and_`, `or_`, `col`, etc.) preserve SQLAlchemy typing.
   - Decide approach: plugin hooks vs stub overlays vs relying on SQLAlchemy typing (documented trade-offs).
 - Compatibility matrix CI across mypy/SQLModel versions (and pin policy).
-- Avoid forcing users to order plugins (`sqlmodel_mypy.plugin` vs `pydantic.mypy`) for correct SQLModel resolution.
+- **Plugin ordering guardrails (mypy limitation)**
+  - **Reality check**: mypy generally uses the **first plugin that claims a hook**, so true “order independence”
+    between `sqlmodel_mypy.plugin` and `pydantic.mypy` is not realistically achievable today.
+  - Enforce and clearly explain that `sqlmodel_mypy.plugin` must be listed **before** `pydantic.mypy`:
+    - Source: `src/sqlmodel_mypy/plugin.py` (`SQLModelMypyPlugin.__init__`, `_sqlmodel_metaclass_callback()`).
+    - User-facing docs: `README.md` (plugin ordering section).
 
 ## v0.4 (Docs-aligned relationship constructors) - DONE
 
@@ -200,3 +205,85 @@ models do provide this at runtime for `table=True`, but type checkers can miss i
 - **Tests**
   - Add mypy integration coverage for `Model.__table__` and `Session.get` / `AsyncSession.get` with SQLModel
     table models.
+
+## v0.12.4 (Dynamic query-builder helpers) - DONE
+
+- Type `getattr(Model, "field")` like `Model.field` for `table=True` SQLModel models (string-literal names only).
+- Best-effort typing for `column_property(...)` return type (infer `Mapped[T]`) to support
+  `Model._foo = column_property(...)` patterns.
+
+## v0.13 (SQLModel docs parity suite) - TODO
+
+**Motivation**: the north star is “SQLModel as documented works under `mypy --strict` with minimal casts/ignores”.
+We should lock this down with a dedicated docs-parity integration suite (beyond the current focused unit-style
+mypy modules).
+
+- **Add docs-derived mypy integration modules**
+  - Create minimal, type-focused modules under `tests/mypy/modules/` that mirror official docs patterns (as close
+    as possible, but stripped of runtime/demo noise).
+  - Add them to `tests/mypy/test_mypy.py` and commit golden outputs under `tests/mypy/outputs/**`.
+  - Target doc pages / patterns:
+    - Connected-data joins and outer-joins:
+      - Docs: `https://sqlmodel.tiangolo.com/tutorial/connect/read-connected-data/`
+    - Relationship attribute creation/update patterns (constructor kwargs + mutation):
+      - Docs: `https://sqlmodel.tiangolo.com/tutorial/relationship-attributes/create-and-update-relationships/`
+    - Many-to-many relationship creation patterns:
+      - Docs: `https://sqlmodel.tiangolo.com/tutorial/many-to-many/create-data/`
+    - Update patterns using `sqlmodel_update()` / `model_dump(exclude_unset=True)`:
+      - Docs: `https://sqlmodel.tiangolo.com/tutorial/fastapi/update/`
+      - Source: `https://github.com/fastapi/sqlmodel/blob/main/sqlmodel/main.py` (`SQLModel.sqlmodel_update`)
+  - Ensure strict-mode expectations are explicit (via `# MYPY:` comments and/or `reveal_type(...)` assertions).
+
+## v0.14 (`typing.Annotated[...]` field metadata support) - TODO
+
+**Motivation**: SQLModel (Pydantic v2) supports `Annotated`-driven typing patterns, and users will naturally try to
+use them to reduce `= Field(...)` assignment noise. Under `--strict`, we should still generate correct constructor
+signatures (required/optional + alias kwargs) when `Field(...)` metadata lives inside `Annotated[...]`.
+
+- **Support `Annotated[T, Field(...)]` for constructor/signature generation**
+  - Examples we should handle (at least best-effort):
+    - `id: Annotated[int | None, Field(default=None, primary_key=True)]`
+    - `name: Annotated[str, Field(alias="full_name")]`
+    - The historical SQLModel edge-case: `Optional[Annotated[T, ...]]` (see upstream release notes).
+  - Implementation sketch:
+    - Extend semantic-phase collection in `src/sqlmodel_mypy/transform.py` to extract Field metadata from the
+      annotation when there is no `= Field(...)` call in the class body.
+    - Mirror the same logic in checker-time signature collection in `src/sqlmodel_mypy/plugin.py`
+      (`_collect_member_from_stmt`) so class-call signatures stay consistent with generated `__init__`.
+  - Source references:
+    - SQLModel `Field()` overloads + alias precedence: `https://github.com/fastapi/sqlmodel/blob/main/sqlmodel/main.py`
+    - `Annotated` handling in SQLModel’s type parsing: `https://github.com/fastapi/sqlmodel/blob/main/sqlmodel/_compat.py`
+    - Release note: “Fix support for types with `Optional[Annotated[x, f()]]`…” (PR #1093):
+      `https://github.com/fastapi/sqlmodel/pull/1093`
+
+## v0.15 (Outer-join `None` propagation for relationship-attribute joins) - TODO
+
+**Motivation**: we currently propagate `None` on outer-joins only when the join target is a direct model class
+(e.g. `.join(Team, isouter=True)`). A common ORM pattern is to join via relationship attributes
+(e.g. `.join(Hero.team, isouter=True)`), and the result tuple should still reflect that the joined entity may be
+`None`.
+
+- **Expand join-target detection**
+  - Extend `src/sqlmodel_mypy/plugin.py` (`_sqlalchemy_select_join_like_return_type`) to also detect join targets
+    expressed as relationship attributes (e.g. `Hero.team`, `Team.heroes`) and map them to the target model type
+    for `None` propagation.
+  - References:
+    - SQLModel outer-join behavior (baseline example): `https://sqlmodel.tiangolo.com/tutorial/connect/read-connected-data/`
+    - SQLAlchemy relationship-attribute joins (`select(User).join(User.addresses)`): `https://docs.sqlalchemy.org/en/20/orm/queryguide/select.html#simple-relationship-joins`
+  - Add mypy integration coverage under `tests/mypy/modules/` for relationship-attribute joins, including the SQLModel
+    docs pattern of `Team: None` on outer-joins.
+
+## v0.16 (Strict typing ergonomics add-ons, opt-in) - TODO
+
+**Motivation**: strict typing + SQLModel often means the database populates values “later” (after flush/commit/
+refresh), especially primary keys (`id: int | None`). Mypy can’t infer those runtime effects, and users end up with
+repeated `assert obj.id is not None` (type clutter).
+
+- **Provide a tiny opt-in narrowing helper**
+  - Docs context (why `id` starts as `None` and is populated after commit/refresh):
+    - `https://sqlmodel.tiangolo.com/tutorial/automatic-id-none-refresh/`
+  - Ship a small helper in this package (runtime-free or near-zero runtime) that helps users narrow “persisted” models
+    without `cast(...)`/`# type: ignore`, e.g.:
+    - `assert_persisted(obj)` / `require_id(obj)` / `ensure_persisted(obj)` returning a `TypeGuard[...]` or using
+      overloads to narrow `id` to `int`.
+  - Keep it optional and well-documented; default plugin behavior should remain conservative.

{sqlmodel_mypy_plugin-0.12.2 → sqlmodel_mypy_plugin-0.12.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "sqlmodel-mypy-plugin"
-version = "0.12.2"
+version = "0.12.3"
 description = "Mypy plugin for SQLModel (better constructor/Field typing)."
 readme = "README.md"
 requires-python = ">=3.10"

{sqlmodel_mypy_plugin-0.12.2 → sqlmodel_mypy_plugin-0.12.3}/src/sqlmodel_mypy/__init__.py

@@ -1,3 +1,3 @@
 __all__ = ["__version__"]
 
-__version__ = "0.12.2"
+__version__ = "0.12.3"

{sqlmodel_mypy_plugin-0.12.2 → sqlmodel_mypy_plugin-0.12.3}/src/sqlmodel_mypy/plugin.py

@@ -27,6 +27,7 @@ from mypy.nodes import (
     MemberExpr,
     NameExpr,
     RefExpr,
+    StrExpr,
     SymbolTableNode,
     TypeInfo,
     Var,
@@ -81,6 +82,8 @@ ERROR_PLUGIN_ORDER = ErrorCode(
     "SQLModel",
 )
 
+BUILTINS_GETATTR_FULLNAME = "builtins.getattr"
+
 SQLMODEL_COL_FULLNAME = "sqlmodel.sql.expression.col"
 # SQLModel's `select()` is implemented in a generated module and re-exported.
 SQLMODEL_SELECT_GEN_FULLNAME = "sqlmodel.sql._expression_select_gen.select"
@@ -95,6 +98,13 @@ SQLALCHEMY_INSTRUMENTED_ATTRIBUTE_FULLNAMES = {
     "sqlalchemy.orm.attributes.InstrumentedAttribute",
 }
 
+SQLALCHEMY_COLUMN_PROPERTY_FULLNAMES = {
+    # Imported from `sqlalchemy.orm` (common user import).
+    "sqlalchemy.orm.column_property",
+    # May resolve to the internal defining module depending on stubs/version.
+    "sqlalchemy.orm._orm_constructors.column_property",
+}
+
 SQLALCHEMY_SELECT_FULLNAME = "sqlalchemy.sql.selectable.Select"
 SQLALCHEMY_SELECT_JOIN_FULLNAME = f"{SQLALCHEMY_SELECT_FULLNAME}.join"
 SQLALCHEMY_SELECT_JOIN_FROM_FULLNAME = f"{SQLALCHEMY_SELECT_FULLNAME}.join_from"
@@ -144,7 +154,7 @@ SQLMODEL_SESSION_EXEC_FULLNAME = "sqlmodel.orm.session.Session.exec"
 SQLMODEL_ASYNC_SESSION_EXEC_FULLNAME = "sqlmodel.ext.asyncio.session.AsyncSession.exec"
 
 # Increment when plugin changes should invalidate mypy cache.
-__version__ = 16
+__version__ = 17
 
 
 class _CollectedField(NamedTuple):
@@ -456,6 +466,10 @@ class SQLModelMypyPlugin(Plugin):
     def get_function_hook(self, fullname: str) -> Callable[[FunctionContext], Type] | None:
         if fullname == SQLMODEL_COL_FULLNAME:
             return self._sqlmodel_col_return_type_callback
+        if fullname == BUILTINS_GETATTR_FULLNAME:
+            return self._sqlmodel_getattr_return_type_callback
+        if fullname in SQLALCHEMY_COLUMN_PROPERTY_FULLNAMES:
+            return self._sqlalchemy_column_property_return_type_callback
         return None
 
     def report_config_data(self, ctx: ReportConfigContext) -> dict[str, Any]:
@@ -1159,6 +1173,196 @@ class SQLModelMypyPlugin(Plugin):
                 return Instance(info, [value_type])
         return ctx.default_return_type
 
+    @staticmethod
+    def _lookup_var_in_mro(info: TypeInfo, name: str) -> Var | None:
+        """Find a `Var` named `name` in `info` or its MRO (best-effort)."""
+        for base in info.mro:
+            sym = base.names.get(name)
+            if sym is not None and isinstance(sym.node, Var):
+                return sym.node
+        return None
+
+    @staticmethod
+    def _is_sqlalchemy_expressionish(tp: Type) -> bool:
+        """Return True if `tp` already looks like a SQLAlchemy expression/descriptor type."""
+        proper = get_proper_type(tp)
+        if not isinstance(proper, Instance):
+            return False
+        if proper.type.fullname in SQLALCHEMY_MAPPED_FULLNAMES:
+            return True
+        if proper.type.fullname in SQLALCHEMY_INSTRUMENTED_ATTRIBUTE_FULLNAMES:
+            return True
+        if proper.type.fullname == "sqlalchemy.orm.attributes.QueryableAttribute":
+            return True
+        if proper.type.fullname in {
+            "sqlalchemy.sql.elements.ColumnElement",
+            "sqlalchemy.sql.expression.ColumnElement",
+        }:
+            return True
+        return False
+
+    def _sqlalchemy_instrumented_attribute_type(self, api: Any, value_type: Type) -> Type | None:
+        for fullname in (
+            "sqlalchemy.orm.attributes.InstrumentedAttribute",
+            "sqlalchemy.orm.InstrumentedAttribute",
+        ):
+            try:
+                return cast(Type, api.named_generic_type(fullname, [value_type]))
+            except Exception:
+                continue
+        return None
+
+    def _sqlalchemy_column_element_type(self, api: Any, value_type: Type) -> Type | None:
+        for fullname in (
+            "sqlalchemy.sql.elements.ColumnElement",
+            "sqlalchemy.sql.expression.ColumnElement",
+        ):
+            try:
+                return cast(Type, api.named_generic_type(fullname, [value_type]))
+            except Exception:
+                continue
+        return None
+
+    def _sqlalchemy_expr_type_for_class_attr(self, api: Any, declared_type: Type) -> Type:
+        """Return the type of `Model.attr` in SQL expressions, given declared instance type.
+
+        This mirrors `_sqlmodel_class_attr_type_callback` but works from a `Type`.
+        """
+        proper = get_proper_type(declared_type)
+        if isinstance(proper, Instance):
+            # If the attribute is already typed as an ORM descriptor/expression, keep it.
+            if proper.type.fullname in SQLALCHEMY_INSTRUMENTED_ATTRIBUTE_FULLNAMES:
+                return declared_type
+            if proper.type.fullname == "sqlalchemy.orm.attributes.QueryableAttribute":
+                return declared_type
+            if proper.type.fullname in {
+                "sqlalchemy.sql.elements.ColumnElement",
+                "sqlalchemy.sql.expression.ColumnElement",
+            }:
+                return declared_type
+
+            # `Mapped[T]` is a descriptor; class-level access behaves like an instrumented attribute.
+            if proper.type.fullname in SQLALCHEMY_MAPPED_FULLNAMES and proper.args:
+                value_type = proper.args[0]
+                inst = self._sqlalchemy_instrumented_attribute_type(api, value_type)
+                if inst is not None:
+                    return inst
+
+        inst = self._sqlalchemy_instrumented_attribute_type(api, declared_type)
+        if inst is not None:
+            return inst
+        col = self._sqlalchemy_column_element_type(api, declared_type)
+        if col is not None:
+            return col
+        return declared_type
+
+    def _sqlmodel_getattr_return_type_callback(self, ctx: FunctionContext) -> Type:
+        """Type `getattr(Model, \"field\")` like `Model.field` for SQLModel table models."""
+        if not ctx.args or len(ctx.args) < 2:
+            return ctx.default_return_type
+        if not ctx.args[0] or not ctx.args[1]:
+            return ctx.default_return_type
+
+        name_expr = ctx.args[1][0]
+        if not isinstance(name_expr, StrExpr):
+            return ctx.default_return_type
+        attr_name = name_expr.value
+
+        if not ctx.arg_types or not ctx.arg_types[0]:
+            return ctx.default_return_type
+        obj_type = get_proper_type(ctx.arg_types[0][0])
+
+        owner_info: TypeInfo | None = None
+        if isinstance(obj_type, TypeType):
+            item = get_proper_type(obj_type.item)
+            if isinstance(item, Instance):
+                owner_info = item.type
+        if owner_info is None:
+            return ctx.default_return_type
+        if owner_info.fullname == SQLMODEL_BASEMODEL_FULLNAME:
+            return ctx.default_return_type
+        if not owner_info.has_base(SQLMODEL_BASEMODEL_FULLNAME):
+            return ctx.default_return_type
+        if not _is_table_model(owner_info):
+            return ctx.default_return_type
+
+        # Mirror `Model.__table__` support.
+        if attr_name == "__table__":
+            return self._sqlalchemy_table_type(ctx.api)
+
+        # Prefer SQLModel members (fields/relationships): treat as SQLAlchemy expressions.
+        var = self._lookup_var_in_mro(owner_info, attr_name)
+        if (
+            var is not None
+            and var.type is not None
+            and self._declares_sqlmodel_member(owner_info, attr_name)
+        ):
+            tp = self._sqlalchemy_expr_type_for_class_attr(ctx.api, var.type)
+        # For non-SQLModel attributes, only special-case SQLAlchemy expression-like descriptors.
+        elif (
+            var is not None and var.type is not None and self._is_sqlalchemy_expressionish(var.type)
+        ):
+            tp = self._sqlalchemy_expr_type_for_class_attr(ctx.api, var.type)
+        else:
+            return ctx.default_return_type
+
+        # If a default value is provided, union it in (best-effort).
+        if len(ctx.arg_types) >= 3 and ctx.arg_types[2]:
+            default_t = ctx.arg_types[2][0]
+            return UnionType.make_union([tp, default_t])
+        return tp
+
+    def _sqlalchemy_mapped_type(self, api: Any, value_type: Type) -> Type | None:
+        for fullname in ("sqlalchemy.orm.base.Mapped", "sqlalchemy.orm.Mapped"):
+            try:
+                return cast(Type, api.named_generic_type(fullname, [value_type]))
+            except Exception:
+                continue
+        return None
+
+    def _sqlalchemy_column_property_return_type_callback(self, ctx: FunctionContext) -> Type:
+        """Best-effort typing for `sqlalchemy.orm.column_property(...)`.
+
+        This is primarily used to support patterns like:
+            `Model._ticketscount = column_property(select(...).scalar_subquery())`
+        where users later want `getattr(Model, "_ticketscount")` to behave like an ORM attribute.
+        """
+        default = ctx.default_return_type
+        if not ctx.arg_types or not ctx.arg_types[0]:
+            return default
+
+        # If SQLAlchemy stubs already provide a precise mapped type, keep it.
+        proper_default = get_proper_type(default)
+        if (
+            isinstance(proper_default, Instance)
+            and proper_default.type.fullname in SQLALCHEMY_MAPPED_FULLNAMES
+            and proper_default.args
+            and not isinstance(get_proper_type(proper_default.args[0]), AnyType)
+        ):
+            return default
+
+        # Infer `T` from the first argument type.
+        arg0 = get_proper_type(ctx.arg_types[0][0])
+        value_type: Type | None = None
+        if isinstance(arg0, Instance) and arg0.args:
+            if arg0.type.fullname in {
+                "sqlalchemy.sql.selectable.ScalarSelect",
+                "sqlalchemy.sql.expression.ScalarSelect",
+                "sqlalchemy.sql.selectable.ScalarSubquery",
+            }:
+                value_type = arg0.args[0]
+            if arg0.type.fullname in {
+                "sqlalchemy.sql.elements.ColumnElement",
+                "sqlalchemy.sql.expression.ColumnElement",
+            }:
+                value_type = arg0.args[0]
+
+        if value_type is None:
+            return default
+
+        mapped = self._sqlalchemy_mapped_type(ctx.api, value_type)
+        return mapped or default
+
     def _sqlmodel_model_class_callback(self, ctx: ClassDefContext) -> None:
         # SQLModel is built on Pydantic v2; users commonly override `model_config`
         # with `ConfigDict(...)`. SQLModel's own config typing may be narrower

sqlmodel_mypy_plugin-0.12.3/tests/mypy/modules/getattr_column_property.py

@@ -0,0 +1,45 @@
+# ruff: noqa: B009
+from __future__ import annotations
+
+from sqlalchemy import func
+from sqlalchemy.orm import column_property, selectinload
+from sqlmodel import Field, Relationship, SQLModel, select
+
+
+class Team(SQLModel, table=True):
+    id: int | None = Field(default=None, primary_key=True)
+    name: str = Field()
+    heroes: list[Hero] = Relationship(back_populates="team")
+
+
+class Hero(SQLModel, table=True):
+    id: int | None = Field(default=None, primary_key=True)
+    name: str = Field()
+    team_id: int | None = Field(default=None, foreign_key="team.id")
+    team: Team | None = Relationship(back_populates="heroes")
+
+
+stmt_team = select(Team).options(selectinload(getattr(Team, "heroes")))
+
+# `getattr(Model, "rel")` should be an ORM attribute (not the plain annotation type).
+bad_heroes: list[Hero] = getattr(Team, "heroes")
+
+
+class User(SQLModel, table=True):
+    id: int = Field(primary_key=True)
+    name: str = Field()
+
+
+stmt_user = select(User).where(getattr(User, "name").like("%x%"))
+
+# `getattr(Model, "field")` should be a SQL expression (not the plain value type).
+bad_id: int = getattr(User, "id")
+
+
+# Dynamic column_property assigned to a SQLModel class (common pattern for computed columns).
+User._order_count = column_property(  # noqa: SLF001
+    select(func.count(Hero.id)).where(Hero.team_id == Team.id).scalar_subquery()
+)
+
+stmt_count = select(User).where(getattr(User, "_order_count").between(1, 2))
+bad_count: int = getattr(User, "_order_count")

{sqlmodel_mypy_plugin-0.12.2 → sqlmodel_mypy_plugin-0.12.3}/tests/mypy/test_mypy.py

@@ -53,6 +53,8 @@ cases: list[tuple[str, str]] = [
     ("mypy-plugin.ini", "relationship_comparators.py"),
     ("mypy-plugin.ini", "selectinload.py"),
     ("mypy-plugin-strict.ini", "selectinload.py"),
+    ("mypy-plugin.ini", "getattr_column_property.py"),
+    ("mypy-plugin-strict.ini", "getattr_column_property.py"),
     ("mypy-plugin.ini", "execution_options.py"),
     ("mypy-plugin-strict.ini", "execution_options.py"),
     ("mypy-plugin.ini", "aliases.py"),

{sqlmodel_mypy_plugin-0.12.2 → sqlmodel_mypy_plugin-0.12.3}/tests/test_plugin_unit.py

@@ -17,6 +17,7 @@ from mypy.nodes import (
     IfStmt,
     MemberExpr,
     NameExpr,
+    StrExpr,
     SymbolTable,
     SymbolTableNode,
     TypeInfo,
@@ -905,6 +906,298 @@ def test_col_function_hook_returns_mapped_value_type() -> None:
     assert t.args and isinstance(t.args[0], Instance) and t.args[0].type.fullname == "builtins.int"
 
 
+def test_getattr_function_hook_types_sqlmodel_table_members() -> None:
+    p = plugin_mod.SQLModelMypyPlugin(Options())
+    api = DummyCheckerAPI()
+
+    model_info = make_sqlmodel_class("m.User")
+    model_info.defn.keywords["table"] = NameExpr("True")
+    model_info.metadata[plugin_mod.METADATA_KEY] = {"fields": {"id": {}}, "relationships": {}}
+
+    int_t = Instance(make_typeinfo("builtins.int"), [])
+    model_info.names["id"] = SymbolTableNode(0, Var("id", int_t))
+
+    hook = p.get_function_hook(plugin_mod.BUILTINS_GETATTR_FULLNAME)
+    assert hook is not None
+
+    user_type = TypeType(Instance(model_info, []))
+    ctx = FunctionContext(
+        arg_types=[[user_type], [Instance(make_typeinfo("builtins.str"), [])]],
+        arg_kinds=[[ARG_POS], [ARG_POS]],
+        callee_arg_names=["object", "name"],
+        arg_names=[[None], [None]],
+        default_return_type=AnyType(TypeOfAny.explicit),
+        args=[[NameExpr("User")], [StrExpr("id")]],
+        context=NameExpr("x"),
+        api=api,
+    )
+    t = hook(ctx)
+    assert isinstance(t, Instance)
+    assert t.type.fullname == "sqlalchemy.orm.attributes.InstrumentedAttribute"
+    assert t.args and isinstance(get_proper_type(t.args[0]), Instance)
+
+
+def test_getattr_function_hook_handles_table_dunder_table() -> None:
+    p = plugin_mod.SQLModelMypyPlugin(Options())
+    api = DummyCheckerAPI()
+
+    model_info = make_sqlmodel_class("m.User")
+    model_info.defn.keywords["table"] = NameExpr("True")
+    model_info.metadata[plugin_mod.METADATA_KEY] = {"fields": {"id": {}}, "relationships": {}}
+    model_info.names["id"] = SymbolTableNode(
+        0, Var("id", Instance(make_typeinfo("builtins.int"), []))
+    )
+
+    user_type = TypeType(Instance(model_info, []))
+    ctx = FunctionContext(
+        arg_types=[[user_type], [Instance(make_typeinfo("builtins.str"), [])]],
+        arg_kinds=[[ARG_POS], [ARG_POS]],
+        callee_arg_names=["object", "name"],
+        arg_names=[[None], [None]],
+        default_return_type=AnyType(TypeOfAny.explicit),
+        args=[[NameExpr("User")], [StrExpr("__table__")]],
+        context=NameExpr("x"),
+        api=api,
+    )
+    t = p._sqlmodel_getattr_return_type_callback(ctx)
+    assert isinstance(t, Instance)
+    assert t.type.fullname == "sqlalchemy.sql.schema.Table"
+
+
+def test_getattr_function_hook_types_expressionish_non_member() -> None:
+    p = plugin_mod.SQLModelMypyPlugin(Options())
+    api = DummyCheckerAPI()
+
+    model_info = make_sqlmodel_class("m.User")
+    model_info.defn.keywords["table"] = NameExpr("True")
+    model_info.metadata[plugin_mod.METADATA_KEY] = {"fields": {}, "relationships": {}}
+
+    int_t = Instance(make_typeinfo("builtins.int"), [])
+    mapped_t = Instance(make_typeinfo("sqlalchemy.orm.base.Mapped"), [int_t])
+    model_info.names["_ticketscount"] = SymbolTableNode(0, Var("_ticketscount", mapped_t))
+
+    user_type = TypeType(Instance(model_info, []))
+    ctx = FunctionContext(
+        arg_types=[[user_type], [Instance(make_typeinfo("builtins.str"), [])]],
+        arg_kinds=[[ARG_POS], [ARG_POS]],
+        callee_arg_names=["object", "name"],
+        arg_names=[[None], [None]],
+        default_return_type=AnyType(TypeOfAny.explicit),
+        args=[[NameExpr("User")], [StrExpr("_ticketscount")]],
+        context=NameExpr("x"),
+        api=api,
+    )
+    t = p._sqlmodel_getattr_return_type_callback(ctx)
+    assert isinstance(t, Instance)
+    assert t.type.fullname == "sqlalchemy.orm.attributes.InstrumentedAttribute"
+
+
+def test_column_property_return_type_callback_infers_scalar_select() -> None:
+    p = plugin_mod.SQLModelMypyPlugin(Options())
+    api = DummyCheckerAPI()
+
+    int_t = Instance(make_typeinfo("builtins.int"), [])
+    scalar_select_t = Instance(make_typeinfo("sqlalchemy.sql.selectable.ScalarSelect"), [int_t])
+    ctx = FunctionContext(
+        arg_types=[[scalar_select_t]],
+        arg_kinds=[[ARG_OPT]],
+        callee_arg_names=["column"],
+        arg_names=[[None]],
+        default_return_type=AnyType(TypeOfAny.explicit),
+        args=[[NameExpr("x")]],
+        context=NameExpr("x"),
+        api=api,
+    )
+    t = p._sqlalchemy_column_property_return_type_callback(ctx)
+    assert isinstance(t, Instance)
+    assert t.type.fullname == "sqlalchemy.orm.base.Mapped"
+    assert t.args and isinstance(get_proper_type(t.args[0]), Instance)
+
+
+def test_column_property_return_type_callback_infers_column_element() -> None:
+    p = plugin_mod.SQLModelMypyPlugin(Options())
+    api = DummyCheckerAPI()
+
+    int_t = Instance(make_typeinfo("builtins.int"), [])
+    col_t = Instance(make_typeinfo("sqlalchemy.sql.elements.ColumnElement"), [int_t])
+    ctx = FunctionContext(
+        arg_types=[[col_t]],
+        arg_kinds=[[ARG_OPT]],
+        callee_arg_names=["column"],
+        arg_names=[[None]],
+        default_return_type=AnyType(TypeOfAny.explicit),
+        args=[[NameExpr("x")]],
+        context=NameExpr("x"),
+        api=api,
+    )
+    t = p._sqlalchemy_column_property_return_type_callback(ctx)
+    assert isinstance(t, Instance)
+    assert t.type.fullname == "sqlalchemy.orm.base.Mapped"
+
+
+def test_column_property_return_type_callback_preserves_precise_mapped_default() -> None:
+    p = plugin_mod.SQLModelMypyPlugin(Options())
+    api = DummyCheckerAPI()
+
+    int_t = Instance(make_typeinfo("builtins.int"), [])
+    scalar_select_t = Instance(make_typeinfo("sqlalchemy.sql.selectable.ScalarSelect"), [int_t])
+    default_mapped = Instance(make_typeinfo("sqlalchemy.orm.base.Mapped"), [int_t])
+    ctx = FunctionContext(
+        arg_types=[[scalar_select_t]],
+        arg_kinds=[[ARG_OPT]],
+        callee_arg_names=["column"],
+        arg_names=[[None]],
+        default_return_type=default_mapped,
+        args=[[NameExpr("x")]],
+        context=NameExpr("x"),
+        api=api,
+    )
+    assert p._sqlalchemy_column_property_return_type_callback(ctx) is default_mapped
+
+
+def test_getattr_return_type_callback_returns_default_for_missing_member() -> None:
+    p = plugin_mod.SQLModelMypyPlugin(Options())
+    api = DummyCheckerAPI()
+
+    model_info = make_sqlmodel_class("m.User")
+    model_info.defn.keywords["table"] = NameExpr("True")
+    model_info.metadata[plugin_mod.METADATA_KEY] = {"fields": {"id": {}}, "relationships": {}}
+    model_info.names["id"] = SymbolTableNode(
+        0, Var("id", Instance(make_typeinfo("builtins.int"), []))
+    )
+
+    user_type = TypeType(Instance(model_info, []))
+    ctx = FunctionContext(
+        arg_types=[[user_type], [Instance(make_typeinfo("builtins.str"), [])]],
+        arg_kinds=[[ARG_POS], [ARG_POS]],
+        callee_arg_names=["object", "name"],
+        arg_names=[[None], [None]],
+        default_return_type=AnyType(TypeOfAny.explicit),
+        args=[[NameExpr("User")], [StrExpr("missing")]],
+        context=NameExpr("x"),
+        api=api,
+    )
+    assert p._sqlmodel_getattr_return_type_callback(ctx).type_of_any == TypeOfAny.explicit  # type: ignore[attr-defined]
+
+
+def test_is_sqlalchemy_expressionish_covers_non_instance_and_other_fullnames() -> None:
+    p = plugin_mod.SQLModelMypyPlugin(Options())
+
+    union = UnionType.make_union([Instance(make_typeinfo("builtins.int"), []), NoneType()])
+    assert p._is_sqlalchemy_expressionish(union) is False
+
+    inst_attr = Instance(
+        make_typeinfo("sqlalchemy.orm.attributes.InstrumentedAttribute"), [plugin_mod._plugin_any()]
+    )
+    assert p._is_sqlalchemy_expressionish(inst_attr) is True
+
+    queryable = Instance(
+        make_typeinfo("sqlalchemy.orm.attributes.QueryableAttribute"), [plugin_mod._plugin_any()]
+    )
+    assert p._is_sqlalchemy_expressionish(queryable) is True
+
+    col = Instance(
+        make_typeinfo("sqlalchemy.sql.elements.ColumnElement"), [plugin_mod._plugin_any()]
+    )
+    assert p._is_sqlalchemy_expressionish(col) is True
+
+
+def test_sqlalchemy_expr_type_for_class_attr_keeps_existing_expression_types() -> None:
+    p = plugin_mod.SQLModelMypyPlugin(Options())
+    api = DummyCheckerAPI()
+
+    inst_attr = Instance(
+        make_typeinfo("sqlalchemy.orm.attributes.InstrumentedAttribute"), [plugin_mod._plugin_any()]
+    )
+    assert p._sqlalchemy_expr_type_for_class_attr(api, inst_attr) is inst_attr
+
+    queryable = Instance(
+        make_typeinfo("sqlalchemy.orm.attributes.QueryableAttribute"), [plugin_mod._plugin_any()]
+    )
+    assert p._sqlalchemy_expr_type_for_class_attr(api, queryable) is queryable
+
+    col = Instance(
+        make_typeinfo("sqlalchemy.sql.elements.ColumnElement"), [plugin_mod._plugin_any()]
+    )
+    assert p._sqlalchemy_expr_type_for_class_attr(api, col) is col
+
+
+def test_sqlalchemy_expr_type_for_class_attr_falls_back_to_column_element() -> None:
+    p = plugin_mod.SQLModelMypyPlugin(Options())
+
+    class NoInstrumentedAPI(DummyCheckerAPI):
+        def named_generic_type(self, name: str, args: list[Type]) -> Instance:
+            if name in {
+                "sqlalchemy.orm.attributes.InstrumentedAttribute",
+                "sqlalchemy.orm.InstrumentedAttribute",
+            }:
+                raise RuntimeError("missing")
+            return super().named_generic_type(name, args)
+
+    api = NoInstrumentedAPI()
+    int_t = Instance(make_typeinfo("builtins.int"), [])
+    t = p._sqlalchemy_expr_type_for_class_attr(api, int_t)
+    assert isinstance(t, Instance)
+    assert t.type.fullname == "sqlalchemy.sql.elements.ColumnElement"
+
+
+def test_getattr_return_type_callback_unions_default_value() -> None:
+    p = plugin_mod.SQLModelMypyPlugin(Options())
+    api = DummyCheckerAPI()
+
+    model_info = make_sqlmodel_class("m.User")
+    model_info.defn.keywords["table"] = NameExpr("True")
+    model_info.metadata[plugin_mod.METADATA_KEY] = {"fields": {"id": {}}, "relationships": {}}
+    model_info.names["id"] = SymbolTableNode(
+        0, Var("id", Instance(make_typeinfo("builtins.int"), []))
+    )
+
+    user_type = TypeType(Instance(model_info, []))
+    ctx = FunctionContext(
+        arg_types=[[user_type], [Instance(make_typeinfo("builtins.str"), [])], [NoneType()]],
+        arg_kinds=[[ARG_POS], [ARG_POS], [ARG_OPT]],
+        callee_arg_names=["object", "name", "default"],
+        arg_names=[[None], [None], [None]],
+        default_return_type=AnyType(TypeOfAny.explicit),
+        args=[[NameExpr("User")], [StrExpr("id")], [NameExpr("None")]],
+        context=NameExpr("x"),
+        api=api,
+    )
+    t = p._sqlmodel_getattr_return_type_callback(ctx)
+    assert isinstance(get_proper_type(t), UnionType)
+
+
+def test_column_property_return_type_callback_guard_and_value_type_none_paths() -> None:
+    p = plugin_mod.SQLModelMypyPlugin(Options())
+    api = DummyCheckerAPI()
+
+    # No args -> no-op.
+    ctx = FunctionContext(
+        arg_types=[],
+        arg_kinds=[],
+        callee_arg_names=[],
+        arg_names=[],
+        default_return_type=AnyType(TypeOfAny.explicit),
+        args=[],
+        context=NameExpr("x"),
+        api=api,
+    )
+    assert isinstance(p._sqlalchemy_column_property_return_type_callback(ctx), AnyType)
+
+    # Unknown arg type -> value_type stays None -> no-op.
+    ctx = FunctionContext(
+        arg_types=[[Instance(make_typeinfo("builtins.int"), [])]],
+        arg_kinds=[[ARG_OPT]],
+        callee_arg_names=["column"],
+        arg_names=[[None]],
+        default_return_type=AnyType(TypeOfAny.explicit),
+        args=[[NameExpr("x")]],
+        context=NameExpr("x"),
+        api=api,
+    )
+    assert isinstance(p._sqlalchemy_column_property_return_type_callback(ctx), AnyType)
+
+
 def test_get_function_signature_hook_returns_none_for_missing_symbol() -> None:
     p = plugin_mod.SQLModelMypyPlugin(Options())
     p.lookup_fully_qualified = lambda _full: None  # type: ignore[method-assign]