sqlmodel-mypy-plugin 0.19.1__tar.gz → 0.21.2__tar.gz

{sqlmodel_mypy_plugin-0.19.1 → sqlmodel_mypy_plugin-0.21.2}/.pre-commit-config.yaml

@@ -1,6 +1,6 @@
 repos:
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.6.9
+    rev: v0.16.4
     hooks:
       - id: ruff
         args: [--fix]

{sqlmodel_mypy_plugin-0.19.1 → sqlmodel_mypy_plugin-0.21.2}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: sqlmodel-mypy-plugin
-Version: 0.19.1
+Version: 0.21.2
 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
@@ -38,6 +38,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Typing :: Typed
 Requires-Python: >=3.10
 Requires-Dist: mypy>=1.19.1
@@ -167,10 +168,12 @@ expressions, so you can write queries without `col()`:
 ```py
 from sqlmodel import Field, SQLModel, select
 
+
 class User(SQLModel, table=True):
     id: int = Field(primary_key=True)
     name: str = Field()
 
+
 stmt = select(User).where(User.name.like("%x%"))
 ```
 
@@ -228,6 +231,35 @@ stmt = select(Team).where(Team.heroes.contains(hero_obj))
 - **SQLAlchemy typing**: relied upon for core SQL/ORM typing wherever possible.
 - **Stub overlays**: only for upstream gaps that can’t be addressed cleanly via hooks (prefer upstream fixes first).
 
+## Database-generated columns are optional kwargs
+
+A field whose value the database (or SQLAlchemy) supplies on INSERT is not required in the generated
+`__init__` / `model_construct` signature. The plugin reads this off `Field(...)` syntactically, from
+`nullable=True`, `sa_column=Column(...)` and `sa_column_kwargs={...}`:
+
+| Form | Why it counts |
+| --- | --- |
+| `nullable=True` | column accepts `NULL` |
+| `default=` / `insert_default=` / `server_default=` (incl. `server_default=FetchedValue()`) | an explicit default |
+| positional `Computed(...)` | `GENERATED ALWAYS AS`, computed by the database |
+| positional `Sequence(...)` | becomes `Column.default`, identical to `default=Sequence(...)` |
+| positional `Identity(...)` | becomes `Column.server_default` (`GENERATED ... AS IDENTITY`) |
+| positional `FetchedValue()` | becomes `Column.server_default` |
+| `primary_key=True` **and** `autoincrement=True` | renders as `SERIAL`/`IDENTITY` |
+
+Markers are matched by their resolved module, so `Sequence` imported from `typing` or
+`collections.abc` is never mistaken for `sqlalchemy.Sequence`; `sqlmodel` re-exports of these
+constructs are recognized. A name the plugin cannot trace back to SQLAlchemy is left alone.
+
+Deliberately **not** covered:
+
+- a bare `primary_key=True`. SQLAlchemy's default `autoincrement="auto"` only generates a value for
+  a *single-column integer* primary key, and neither the column type nor the rest of the table's
+  primary key is knowable from one `Column(...)` call — composite or non-integer primary keys would
+  silently become optional. Use SQLModel's usual `Field(default=None, primary_key=True)`.
+- `autoincrement=True` **without** `primary_key=True`. SQLAlchemy ignores it there (the column
+  compiles to a plain `INTEGER`), so the value really is caller-supplied.
+
 ## Field aliases in constructor kwargs
 
 If you use `Field(alias=...)` (or `validation_alias=...` / `schema_extra={"validation_alias": ...}`), the plugin

{sqlmodel_mypy_plugin-0.19.1 → sqlmodel_mypy_plugin-0.21.2}/README.md

@@ -121,10 +121,12 @@ expressions, so you can write queries without `col()`:
 ```py
 from sqlmodel import Field, SQLModel, select
 
+
 class User(SQLModel, table=True):
     id: int = Field(primary_key=True)
     name: str = Field()
 
+
 stmt = select(User).where(User.name.like("%x%"))
 ```
 
@@ -182,6 +184,35 @@ stmt = select(Team).where(Team.heroes.contains(hero_obj))
 - **SQLAlchemy typing**: relied upon for core SQL/ORM typing wherever possible.
 - **Stub overlays**: only for upstream gaps that can’t be addressed cleanly via hooks (prefer upstream fixes first).
 
+## Database-generated columns are optional kwargs
+
+A field whose value the database (or SQLAlchemy) supplies on INSERT is not required in the generated
+`__init__` / `model_construct` signature. The plugin reads this off `Field(...)` syntactically, from
+`nullable=True`, `sa_column=Column(...)` and `sa_column_kwargs={...}`:
+
+| Form | Why it counts |
+| --- | --- |
+| `nullable=True` | column accepts `NULL` |
+| `default=` / `insert_default=` / `server_default=` (incl. `server_default=FetchedValue()`) | an explicit default |
+| positional `Computed(...)` | `GENERATED ALWAYS AS`, computed by the database |
+| positional `Sequence(...)` | becomes `Column.default`, identical to `default=Sequence(...)` |
+| positional `Identity(...)` | becomes `Column.server_default` (`GENERATED ... AS IDENTITY`) |
+| positional `FetchedValue()` | becomes `Column.server_default` |
+| `primary_key=True` **and** `autoincrement=True` | renders as `SERIAL`/`IDENTITY` |
+
+Markers are matched by their resolved module, so `Sequence` imported from `typing` or
+`collections.abc` is never mistaken for `sqlalchemy.Sequence`; `sqlmodel` re-exports of these
+constructs are recognized. A name the plugin cannot trace back to SQLAlchemy is left alone.
+
+Deliberately **not** covered:
+
+- a bare `primary_key=True`. SQLAlchemy's default `autoincrement="auto"` only generates a value for
+  a *single-column integer* primary key, and neither the column type nor the rest of the table's
+  primary key is knowable from one `Column(...)` call — composite or non-integer primary keys would
+  silently become optional. Use SQLModel's usual `Field(default=None, primary_key=True)`.
+- `autoincrement=True` **without** `primary_key=True`. SQLAlchemy ignores it there (the column
+  compiles to a plain `INTEGER`), so the value really is caller-supplied.
+
 ## Field aliases in constructor kwargs
 
 If you use `Field(alias=...)` (or `validation_alias=...` / `schema_extra={"validation_alias": ...}`), the plugin

{sqlmodel_mypy_plugin-0.19.1 → sqlmodel_mypy_plugin-0.21.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "sqlmodel-mypy-plugin"
-version = "0.19.1"
+version = "0.21.2"
 description = "Mypy plugin for SQLModel (better constructor/Field typing)."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -20,6 +20,7 @@ classifiers = [
   "Programming Language :: Python :: 3.11",
   "Programming Language :: Python :: 3.12",
   "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
   "Typing :: Typed",
 ]
 dependencies = [
@@ -52,7 +53,6 @@ include = [
   "/src",
   "/tests",
   "/README.md",
-  "/ROADMAP.md",
   "/AGENTS.md",
   "/LICENSE",
   "/pyproject.toml",
@@ -64,6 +64,9 @@ line-length = 100
 target-version = "py310"
 exclude = ["tests/mypy/outputs"]
 
+[tool.ruff.per-file-target-version]
+"tests/mypy/modules/recursive_aliases_pep695.py" = "py312"
+
 [tool.ruff.lint]
 select = [
   "E",  # pycodestyle errors

{sqlmodel_mypy_plugin-0.19.1 → sqlmodel_mypy_plugin-0.21.2}/src/sqlmodel_mypy/plugin.py

@@ -58,6 +58,7 @@ from mypy.types import (
     TypeOfAny,
     TypeType,
     UnionType,
+    UnpackType,
     get_proper_type,
 )
 from mypy.typevars import fill_typevars
@@ -171,7 +172,7 @@ SQLALCHEMY_INSPECT_FULLNAMES = {
 }
 
 # Increment when plugin changes should invalidate mypy cache.
-__version__ = 26
+__version__ = 29
 
 
 class _CollectedField(NamedTuple):
@@ -926,7 +927,7 @@ class SQLModelMypyPlugin(Plugin):
 
         SQLModel's generated stubs traditionally cap `select()` overloads at 4 entities.
         For 5+ entities, fall back to a conservative signature that accepts the call and
-        returns `Select[tuple[Any, ...]]` (represented as a fixed-length tuple of `Any`s).
+        returns a Select with one unknown value per selected entity.
         """
         call = ctx.context
         if not isinstance(call, CallExpr):
@@ -977,7 +978,7 @@ class SQLModelMypyPlugin(Plugin):
         any_t = _plugin_any()
         tuple_fallback = ctx.api.named_generic_type("builtins.tuple", [any_t])
         row_type = TupleType([any_t] * positional_count, tuple_fallback)
-        ret_type = Instance(select_info, [row_type])
+        ret_type = self._instance_with_row_type(select_info, row_type)
 
         fallback = default_items[0].fallback if default_items else tuple_fallback
         arg_types = [any_t] * positional_count
@@ -990,7 +991,7 @@ class SQLModelMypyPlugin(Plugin):
 
         Our signature hook for 5+ args deliberately uses `Any` to avoid "no overload matches"
         errors. Here, once mypy has inferred argument expression types, we recover a more precise
-        `Select[tuple[...]]` element type for the common cases (models + column expressions).
+        row element types for the common cases (models + column expressions).
         """
         call = ctx.context
         if not isinstance(call, CallExpr):
@@ -1012,7 +1013,7 @@ class SQLModelMypyPlugin(Plugin):
         proper_default = get_proper_type(default)
         if not isinstance(proper_default, Instance) or not proper_default.args:
             return default
-        proper_row = get_proper_type(proper_default.args[0])
+        proper_row = get_proper_type(self._instance_row_type(proper_default, ctx.api))
         if not isinstance(proper_row, TupleType):
             return default
 
@@ -1036,7 +1037,7 @@ class SQLModelMypyPlugin(Plugin):
         any_t = _plugin_any()
         tuple_fallback = ctx.api.named_generic_type("builtins.tuple", [any_t])
         row_type = TupleType(items, tuple_fallback)
-        return Instance(proper_default.type, [row_type])
+        return self._instance_with_row_type(proper_default.type, row_type)
 
     def _sqlmodel_select_entity_result_type(self, typ: Type) -> Type:
         """Return the value type produced by an entity passed to `select(...)`.
@@ -1054,6 +1055,9 @@ class SQLModelMypyPlugin(Plugin):
             return UnionType.make_union(
                 [self._sqlmodel_select_entity_result_type(item) for item in proper.items]
             )
+        if isinstance(proper, FunctionLike) and proper.is_type_obj():
+            # Mypy represents a model class expression by its constructor overloads.
+            return UnionType.make_union([item.ret_type for item in proper.items])
         if isinstance(proper, TypeType):
             item = get_proper_type(proper.item)
             if isinstance(item, Instance):
@@ -1371,6 +1375,23 @@ class SQLModelMypyPlugin(Plugin):
         coro = _named_generic_type_or_none(ctx.api, "typing.Coroutine", [any_t, any_t, result_type])
         return coro or default
 
+    @staticmethod
+    def _instance_row_type(instance: Instance, api: Any) -> Type:
+        """Read a row from SQLAlchemy 2.0's tuple or 2.1's variadic arguments."""
+        if instance.type.has_type_var_tuple_type:
+            tuple_fallback = api.named_generic_type("builtins.tuple", [_plugin_any()])
+            return TupleType(list(instance.args), tuple_fallback)
+        return instance.args[0]
+
+    @staticmethod
+    def _instance_with_row_type(info: TypeInfo, row_type: Type) -> Instance:
+        """Use the installed class's generic shape, without guessing package versions."""
+        if info.has_type_var_tuple_type:
+            proper_row = get_proper_type(row_type)
+            args = proper_row.items if isinstance(proper_row, TupleType) else [UnpackType(row_type)]
+            return Instance(info, args)
+        return Instance(info, [row_type])
+
     def _row_tuple_type_from_typed_statement(self, statement: Type, api: Any) -> Type | None:
         """Infer the row tuple type produced by a SQL statement (best-effort)."""
         proper = get_proper_type(statement)
@@ -1385,12 +1406,12 @@ class SQLModelMypyPlugin(Plugin):
             tuple_fallback = api.named_generic_type("builtins.tuple", [any_t])
             return TupleType([scalar_t], tuple_fallback)
 
-        # SQLModel Select[T] and SQLAlchemy Select[_TP] both store the row parameter in the first type argument.
+        # SQLAlchemy 2.1 and SQLModel 0.0.48 use variadic row parameters.
         if proper.type.fullname in {
             SQLMODEL_SELECT_CLS_FULLNAME,
             SQLALCHEMY_SELECT_FULLNAME,
         } or proper.type.has_base(SQLALCHEMY_SELECT_FULLNAME):
-            return proper.args[0]
+            return self._instance_row_type(proper, api)
 
         return None
 
@@ -1399,11 +1420,10 @@ class SQLModelMypyPlugin(Plugin):
         for fullname in ("sqlalchemy.engine.Result", "sqlalchemy.engine.result.Result"):
             inst = _named_generic_type_or_none(api, fullname, [row_tuple_type])
             if inst is not None:
-                return inst
+                return self._instance_with_row_type(inst.type, row_tuple_type)
             info = _lookup_typeinfo(self, fullname)
             if info is not None:
-                args = [row_tuple_type] * len(info.defn.type_vars)
-                return Instance(info, args)
+                return self._instance_with_row_type(info, row_tuple_type)
         return None
 
     def _sqlalchemy_select_join_return_type_callback(self, ctx: MethodContext) -> Type:
@@ -1661,7 +1681,7 @@ class SQLModelMypyPlugin(Plugin):
         if not receiver.args:
             return ctx.default_return_type
 
-        tp = get_proper_type(receiver.args[0])
+        tp = get_proper_type(self._instance_row_type(receiver, ctx.api))
         if not isinstance(tp, TupleType):
             return ctx.default_return_type
 
@@ -1682,7 +1702,7 @@ class SQLModelMypyPlugin(Plugin):
             return ctx.default_return_type
 
         new_tp = tp.copy_modified(items=new_items)
-        return Instance(receiver.type, [new_tp])
+        return self._instance_with_row_type(receiver.type, new_tp)
 
     def _sqlmodel_class_attr_type_callback(self, ctx: AttributeContext) -> Type:
         if ctx.is_lvalue:

{sqlmodel_mypy_plugin-0.19.1 → sqlmodel_mypy_plugin-0.21.2}/src/sqlmodel_mypy/transform.py

@@ -11,8 +11,8 @@ from __future__ import annotations
 
 import ast
 import keyword
-from collections.abc import Iterator
-from typing import Any, Protocol
+from collections.abc import Callable, Iterable, Iterator
+from typing import Any, Protocol, TypeVar
 
 from mypy.errorcodes import ErrorCode
 from mypy.expandtype import expand_type
@@ -85,6 +85,19 @@ SQLMODEL_RELATIONSHIP_FULLNAME = "sqlmodel.main.Relationship"
 
 SQLALCHEMY_MAPPED_FULLNAMES = {"sqlalchemy.orm.Mapped", "sqlalchemy.orm.base.Mapped"}
 
+# `Column(...)` keywords whose presence means the value does not have to be supplied by the caller.
+# All of them end up as `Column.default` / `Column.server_default`, i.e. the value is produced by
+# SQLAlchemy or by the database on INSERT.
+SQLALCHEMY_DEFAULTISH_COLUMN_KWARGS = frozenset({"server_default", "default", "insert_default"})
+
+# SQLAlchemy schema constructs that are passed to `Column(...)` *positionally* and install a
+# default/server-default on the column via `SchemaEventTarget._set_parent`:
+# - `Computed(...)`     -> GENERATED ALWAYS AS, value is computed by the database
+# - `Sequence(...)`     -> becomes `Column.default` (identical to `default=Sequence(...)`)
+# - `Identity(...)`     -> becomes `Column.server_default` (GENERATED ... AS IDENTITY)
+# - `FetchedValue()`    -> becomes `Column.server_default` (value fetched after INSERT)
+SQLALCHEMY_COLUMN_DEFAULT_MARKERS = frozenset({"Computed", "Sequence", "Identity", "FetchedValue"})
+
 
 def _plugin_any() -> AnyType:
     """Return an Any that should not trigger `disallow_any_explicit`."""
@@ -94,6 +107,109 @@ def _plugin_any() -> AnyType:
 ERROR_FIELD = ErrorCode("sqlmodel-field", "SQLModel field error", "SQLModel")
 
 
+_ExprT = TypeVar("_ExprT")
+
+
+def _is_sqlalchemy_module(module: str | None) -> bool:
+    """True for `sqlalchemy` and any of its submodules."""
+    if not module:
+        return False
+    return module.split(".", 1)[0] == "sqlalchemy"
+
+
+def _is_sqlalchemy_marker_source_module(module: str | None) -> bool:
+    """Modules an import may legitimately pull a SQLAlchemy default marker out of.
+
+    `sqlmodel/__init__.py` re-exports `Computed` / `Sequence` / `Identity` / `FetchedValue`
+    straight from `sqlalchemy.schema` (`from sqlalchemy.schema import X as X`), so
+    `from sqlmodel import Sequence` binds the very same class.
+    """
+    if not module:
+        return False
+    return module.split(".", 1)[0] in {"sqlalchemy", "sqlmodel"}
+
+
+def _column_args_are_defaultish(
+    args: Iterable[tuple[str | None, _ExprT]],
+    *,
+    is_marker_call: Callable[[_ExprT], bool],
+    is_true: Callable[[_ExprT], bool],
+    is_none: Callable[[_ExprT], bool],
+) -> bool:
+    """Shared `Column(...)` rule: does this column get its value without the caller supplying one?
+
+    `args` is the argument list normalised to `(keyword_name_or_None, value)` pairs, so the same
+    rule can be driven both from raw `ast` nodes (`Annotated[...]` metadata) and from mypy
+    `Expression` nodes (`x: T = Field(...)`), and from `sa_column_kwargs={...}` dicts (which only
+    ever produce keyword entries).
+
+    Deliberately *not* covered: a bare `primary_key=True`. SQLAlchemy's default
+    `autoincrement="auto"` only generates a value for a *single-column integer* primary key, and
+    neither the column type nor the rest of the table's primary key is knowable from one
+    `Column(...)` call, so composite or non-integer primary keys would silently become optional.
+    An explicit `autoincrement=True` *on a primary key* is different: it is the author stating that
+    the database generates the value, it renders as SERIAL/IDENTITY, and SQLAlchemy rejects it at
+    DDL time on an incompatible column type.
+    """
+    saw_autoincrement_true = False
+    saw_primary_key_true = False
+
+    for arg_name, arg in args:
+        if arg_name is None:
+            # Positional schema constructs, e.g. `Column(BigInteger, Sequence("s"))`.
+            if is_marker_call(arg):
+                return True
+            continue
+
+        if arg_name == "nullable" and is_true(arg):
+            return True
+        if arg_name in SQLALCHEMY_DEFAULTISH_COLUMN_KWARGS and not is_none(arg):
+            return True
+        if arg_name == "autoincrement" and is_true(arg):
+            saw_autoincrement_true = True
+        elif arg_name == "primary_key" and is_true(arg):
+            saw_primary_key_true = True
+
+    return saw_autoincrement_true and saw_primary_key_true
+
+
+def _ast_dotted_name(expr: ast.expr) -> str | None:
+    """Flatten `a.b.C` into `"a.b.C"`; return None for anything that is not a plain dotted name."""
+    if isinstance(expr, ast.Name):
+        return expr.id
+    if isinstance(expr, ast.Attribute):
+        base = _ast_dotted_name(expr.value)
+        return None if base is None else f"{base}.{expr.attr}"
+    return None
+
+
+def _collect_sqlalchemy_marker_bindings(tree: ast.Module) -> tuple[set[str], set[str]]:
+    """Return `(marker names, module aliases)` bound by the module's imports.
+
+    Import-aware on purpose: `Sequence` is also `typing.Sequence` / `collections.abc.Sequence`, so
+    matching the bare name would misread `x: Sequence[int]`-style code as a SQLAlchemy sequence.
+    Names we cannot trace back to a `sqlalchemy` / `sqlmodel` import are not treated as markers.
+    """
+    marker_names: set[str] = set()
+    module_aliases: set[str] = set()
+
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Import):
+            for alias in node.names:
+                if not _is_sqlalchemy_marker_source_module(alias.name):
+                    continue
+                # `import sqlalchemy.orm` binds the top-level package name.
+                module_aliases.add(alias.asname or alias.name.split(".", 1)[0])
+        elif isinstance(node, ast.ImportFrom):
+            if node.level or not _is_sqlalchemy_marker_source_module(node.module):
+                continue
+            for alias in node.names:
+                if alias.name in SQLALCHEMY_COLUMN_DEFAULT_MARKERS:
+                    marker_names.add(alias.asname or alias.name)
+
+    return marker_names, module_aliases
+
+
 def _parse_annotated_field_metadata_by_line(source: str) -> dict[int, tuple[bool, list[str]]]:
     """Return mapping of line -> (has_default, aliases) for Annotated Field metadata.
 
@@ -103,6 +219,13 @@ def _parse_annotated_field_metadata_by_line(source: str) -> dict[int, tuple[bool
 
     Only handles class-body `AnnAssign` nodes with **no assignment value** (i.e. `x: ...`).
     """
+    out: dict[int, tuple[bool, list[str]]] = {}
+    try:
+        tree = ast.parse(source)
+    except SyntaxError:
+        return out
+
+    marker_names, sqlalchemy_module_aliases = _collect_sqlalchemy_marker_bindings(tree)
 
     def _call_func_name(expr: ast.expr) -> str | None:
         if isinstance(expr, ast.Name):
@@ -175,6 +298,20 @@ def _parse_annotated_field_metadata_by_line(source: str) -> dict[int, tuple[bool
             aliases.append(candidate)
         return aliases
 
+    def _is_marker_call(expr: ast.expr) -> bool:
+        if not isinstance(expr, ast.Call):
+            return False
+        name = _ast_dotted_name(expr.func)
+        if name is None:
+            return False
+        head, _, attr = name.rpartition(".")
+        if not head:
+            return name in marker_names
+        return (
+            attr in SQLALCHEMY_COLUMN_DEFAULT_MARKERS
+            and head.split(".", 1)[0] in sqlalchemy_module_aliases
+        )
+
     def _column_expr_is_defaultish(expr: ast.expr) -> bool:
         if not isinstance(expr, ast.Call):
             return False
@@ -183,32 +320,29 @@ def _parse_annotated_field_metadata_by_line(source: str) -> dict[int, tuple[bool
         if callee_name is not None and not callee_name.endswith("Column"):
             return False
 
-        for arg in expr.args:
-            if isinstance(arg, ast.Call):
-                computed_name = _call_func_name(arg.func)
-                if computed_name is not None and computed_name.endswith("Computed"):
-                    return True
-
-        for kw in expr.keywords:
-            if kw.arg == "nullable" and _is_true(kw.value):
-                return True
-            if kw.arg in {"server_default", "default", "insert_default"} and not _is_none(kw.value):
-                return True
-        return False
+        args: list[tuple[str | None, ast.expr]] = [(None, arg) for arg in expr.args]
+        args += [(kw.arg, kw.value) for kw in expr.keywords if kw.arg is not None]
+        return _column_args_are_defaultish(
+            args,
+            is_marker_call=_is_marker_call,
+            is_true=_is_true,
+            is_none=_is_none,
+        )
 
     def _sa_column_kwargs_are_defaultish(expr: ast.expr) -> bool:
         if not isinstance(expr, ast.Dict):
             return False
-        for key_expr, val_expr in zip(expr.keys, expr.values, strict=True):
-            if not (isinstance(key_expr, ast.Constant) and isinstance(key_expr.value, str)):
-                continue
-            if key_expr.value == "nullable" and _is_true(val_expr):
-                return True
-            if key_expr.value in {"server_default", "default", "insert_default"} and not _is_none(
-                val_expr
-            ):
-                return True
-        return False
+        items: list[tuple[str | None, ast.expr]] = [
+            (key_expr.value, val_expr)
+            for key_expr, val_expr in zip(expr.keys, expr.values, strict=True)
+            if isinstance(key_expr, ast.Constant) and isinstance(key_expr.value, str)
+        ]
+        return _column_args_are_defaultish(
+            items,
+            is_marker_call=_is_marker_call,
+            is_true=_is_true,
+            is_none=_is_none,
+        )
 
     def _field_has_default_from_call(call: ast.Call) -> bool:
         # Explicit default always wins.
@@ -263,12 +397,6 @@ def _parse_annotated_field_metadata_by_line(source: str) -> dict[int, tuple[bool
 
         return None
 
-    out: dict[int, tuple[bool, list[str]]] = {}
-    try:
-        tree = ast.parse(source)
-    except SyntaxError:
-        return out
-
     class _Visitor(ast.NodeVisitor):
         def __init__(self) -> None:
             self.class_depth = 0
@@ -320,8 +448,9 @@ class ForceInvariantTypeVars(TypeTranslator):
         return modified
 
     def visit_type_alias_type(self, t: TypeAliasType) -> Type:  # noqa: D102
-        # Expand type aliases and then continue translation.
-        return get_proper_type(t).accept(self)
+        # Alias targets can refer back to themselves. Preserve their graph and
+        # translate only the supplied arguments, like mypy's ExpandTypeVisitor.
+        return t.copy_modified(args=[arg.accept(self) for arg in t.args])
 
 
 class SQLModelField:
@@ -717,10 +846,8 @@ class SQLModelTransformer:
             def _column_expr_is_defaultish(value: Expression) -> bool:
                 """Best-effort detection of SQLAlchemy-generated/defaultable columns.
 
-                We treat these as "optional" constructor kwargs:
-                - nullable=True
-                - server_default / default / insert_default
-                - Computed(...) columns
+                Shares `_column_args_are_defaultish` with the `Annotated[...]` `ast` reader; see
+                that function for what counts as "the caller need not supply this value".
                 """
                 if not isinstance(value, CallExpr):
                     return False
@@ -730,38 +857,28 @@ class SQLModelTransformer:
                     # Be conservative: avoid interpreting non-Column calls.
                     return False
 
-                for c_arg, c_arg_name in zip(value.args, value.arg_names, strict=True):
-                    # Positional Computed(...) (common in declarative).
-                    if c_arg_name is None and isinstance(c_arg, CallExpr):
-                        computed_fullname = _callee_fullname(c_arg)
-                        if computed_fullname is not None and computed_fullname.endswith(
-                            ".Computed"
-                        ):
-                            return True
-
-                    # Keyword hints.
-                    if c_arg_name == "nullable" and _is_bool_nameexpr(c_arg, True):
-                        return True
-                    if c_arg_name in {"server_default", "default", "insert_default"}:
-                        if not _is_none_expr(c_arg):
-                            return True
-
-                return False
+                return _column_args_are_defaultish(
+                    zip(value.arg_names, value.args, strict=True),
+                    is_marker_call=_is_sqlalchemy_marker_call,
+                    is_true=lambda e: _is_bool_nameexpr(e, True),
+                    is_none=_is_none_expr,
+                )
 
             def _sa_column_kwargs_are_defaultish(value: Expression) -> bool:
                 """Best-effort for `Field(sa_column_kwargs={...})`."""
                 if not isinstance(value, DictExpr):
                     return False
 
-                for key_expr, val_expr in value.items:
-                    if not isinstance(key_expr, StrExpr):
-                        continue
-                    if key_expr.value == "nullable" and _is_bool_nameexpr(val_expr, True):
-                        return True
-                    if key_expr.value in {"server_default", "default", "insert_default"}:
-                        if not _is_none_expr(val_expr):
-                            return True
-                return False
+                return _column_args_are_defaultish(
+                    [
+                        (key_expr.value, val_expr)
+                        for key_expr, val_expr in value.items
+                        if isinstance(key_expr, StrExpr)
+                    ],
+                    is_marker_call=_is_sqlalchemy_marker_call,
+                    is_true=lambda e: _is_bool_nameexpr(e, True),
+                    is_none=_is_none_expr,
+                )
 
             saw_nullable_true = False
             sa_column_expr: Expression | None = None
@@ -1057,6 +1174,21 @@ def _callee_fullname(call: CallExpr) -> str | None:
     return None
 
 
+def _is_sqlalchemy_marker_call(value: Expression) -> bool:
+    """True for a call to a SQLAlchemy schema construct that installs a column default.
+
+    Matching is by resolved fullname, so `Sequence` imported from `typing` /
+    `collections.abc` does not qualify. An unresolved callee is not treated as a marker.
+    """
+    if not isinstance(value, CallExpr):
+        return False
+    fullname = _callee_fullname(value)
+    if fullname is None:
+        return False
+    module, _, attr = fullname.rpartition(".")
+    return attr in SQLALCHEMY_COLUMN_DEFAULT_MARKERS and _is_sqlalchemy_module(module)
+
+
 def _unwrap_mapped_type(typ: Type) -> Type:
     """Convert SQLAlchemy `Mapped[T]` annotations to `T` for constructor signatures.
 

sqlmodel_mypy_plugin-0.21.2/tests/mypy/configs/mypy-plugin-recursive.ini

@@ -0,0 +1,10 @@
+[mypy]
+plugins = sqlmodel_mypy.plugin
+follow_imports = silent
+strict = true
+python_version = 3.12
+
+[sqlmodel-mypy]
+init_forbid_extra = true
+init_typed = true
+warn_untyped_fields = true

{sqlmodel_mypy_plugin-0.19.1 → sqlmodel_mypy_plugin-0.21.2}/tests/mypy/modules/execution_options.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 from sqlmodel import Field, Session, SQLModel, create_engine, select
-from sqlmodel.sql._expression_select_cls import Select as SQLModelSelect
 
 
 class Team(SQLModel, table=True):
@@ -21,7 +20,7 @@ stmt = select(Hero, Team).join(Team, isouter=True).execution_options(populate_ex
 
 # `execution_options()` should preserve the `Select[...]` generic, including outer-join `None`
 # propagation for the joined entity.
-ok_stmt: SQLModelSelect[tuple[Hero, Team | None]] = stmt
+ok_stmt = stmt
 
 with Session(engine) as session:
     for hero, team in session.exec(stmt):