sqlmodel-mypy-plugin 0.19.0__tar.gz → 0.20.0__tar.gz

{sqlmodel_mypy_plugin-0.19.0 → sqlmodel_mypy_plugin-0.20.0}/.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.0 → sqlmodel_mypy_plugin-0.20.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: sqlmodel-mypy-plugin
-Version: 0.19.0
+Version: 0.20.0
 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
@@ -52,8 +53,6 @@ Mypy plugin that improves type checking for [`SQLModel`](https://github.com/fast
 
 Early/experimental. Implemented scope (supported today):
 
-Planned work is tracked in [`ROADMAP.md`](ROADMAP.md).
-
 - Generate correct `__init__` / `model_construct` signatures for SQLModel models:
   - treat `sqlmodel.Field(...)` required/optional correctly
   - accept `sqlmodel.Relationship(...)` kwargs for `table=True` models
@@ -169,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%"))
 ```
 
@@ -230,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.0 → sqlmodel_mypy_plugin-0.20.0}/README.md

@@ -6,8 +6,6 @@ Mypy plugin that improves type checking for [`SQLModel`](https://github.com/fast
 
 Early/experimental. Implemented scope (supported today):
 
-Planned work is tracked in [`ROADMAP.md`](ROADMAP.md).
-
 - Generate correct `__init__` / `model_construct` signatures for SQLModel models:
   - treat `sqlmodel.Field(...)` required/optional correctly
   - accept `sqlmodel.Relationship(...)` kwargs for `table=True` models
@@ -123,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%"))
 ```
 
@@ -184,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.0 → sqlmodel_mypy_plugin-0.20.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "sqlmodel-mypy-plugin"
-version = "0.19.0"
+version = "0.20.0"
 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",

{sqlmodel_mypy_plugin-0.19.0 → sqlmodel_mypy_plugin-0.20.0}/src/sqlmodel_mypy/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.19.0"
+__version__ = "0.19.1"
 
 from .persisted import HasId, HasOptionalId, has_id, require_id
 

{sqlmodel_mypy_plugin-0.19.0 → sqlmodel_mypy_plugin-0.20.0}/src/sqlmodel_mypy/plugin.py

@@ -171,7 +171,7 @@ SQLALCHEMY_INSPECT_FULLNAMES = {
 }
 
 # Increment when plugin changes should invalidate mypy cache.
-__version__ = 25
+__version__ = 27
 
 
 class _CollectedField(NamedTuple):
@@ -1275,34 +1275,6 @@ class SQLModelMypyPlugin(Plugin):
                 return any(_contains_instance_fullname(item, fullname) for item in proper.items)
             return False
 
-        # Accept SQLAlchemy `Select[...]` in `Session.exec(...)`.
-        #
-        # SQLModel defines its own `Select[...]` wrapper class and types `Session.exec` to accept it,
-        # but users often import and use SQLAlchemy's `select()` directly. Runtime supports it, and
-        # with this adjustment we preserve a correctly-shaped `TupleResult[...]` return type.
-        sqlmodel_select_info = _lookup_typeinfo(self, SQLMODEL_SELECT_CLS_FULLNAME)
-        sqlalchemy_select_info = _lookup_typeinfo(self, SQLALCHEMY_SELECT_FULLNAME)
-        if sqlmodel_select_info is not None and sqlalchemy_select_info is not None:
-            if _contains_instance_fullname(default.arg_types[0], sqlmodel_select_info.fullname):
-                # Idempotency: if upstream stubs already accept SQLAlchemy Select, keep unchanged.
-                if not _contains_instance_fullname(
-                    default.arg_types[0], sqlalchemy_select_info.fullname
-                ):
-                    proper_arg0 = get_proper_type(default.arg_types[0])
-                    if isinstance(proper_arg0, Instance) and proper_arg0.args:
-                        row_type = proper_arg0.args[0]
-                    else:
-                        row_type = _plugin_any()
-                    sqlalchemy_select = Instance(
-                        sqlalchemy_select_info,
-                        [row_type] * len(sqlalchemy_select_info.defn.type_vars),
-                    )
-                    new_arg_types = list(default.arg_types)
-                    new_arg_types[0] = UnionType.make_union(
-                        [default.arg_types[0], sqlalchemy_select]
-                    )
-                    return default.copy_modified(arg_types=new_arg_types)
-
         # Only adjust the broad overload; keep Select/SelectOfScalar overloads precise.
         broad = False
         if sqlmodel_executable_info is not None and _contains_instance_fullname(

{sqlmodel_mypy_plugin-0.19.0 → sqlmodel_mypy_plugin-0.20.0}/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
@@ -717,10 +845,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 +856,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 +1173,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.
 
@@ -1198,11 +1329,25 @@ def add_method(
     """
     info = cls.info
 
-    # Remove previously generated methods.
+    def _remove_stmt(stmt: Statement) -> None:
+        # `list.remove(...)` raises ValueError if not present; ignore.
+        try:
+            cls.defs.body.remove(stmt)
+        except ValueError:
+            return
+
+    # Remove previously generated methods (handle both FuncDef and Decorator nodes).
     if name in info.names:
         sym = info.names[name]
-        if sym.plugin_generated and isinstance(sym.node, FuncDef):
-            cls.defs.body.remove(sym.node)
+        if sym.plugin_generated:
+            node = sym.node
+            if isinstance(node, Decorator):
+                # NOTE: older buggy versions appended the underlying FuncDef instead of the
+                # Decorator; remove both to be safe.
+                _remove_stmt(node)
+                _remove_stmt(node.func)
+            elif isinstance(node, FuncDef):
+                _remove_stmt(node)
 
     # Keep existing definition for semantic analysis by renaming it.
     if name in info.names:
@@ -1248,9 +1393,13 @@ def add_method(
         dec = Decorator(func, [NameExpr("classmethod")], v)
         dec.line = info.line
         sym = SymbolTableNode(MDEF, dec)
+        # NOTE: keep the class body node as a plain FuncDef (this matches the
+        # previous plugin behavior and avoids override-check churn).
+        body_node: Statement = func
     else:
         sym = SymbolTableNode(MDEF, func)
+        body_node = func
 
     sym.plugin_generated = True
     info.names[name] = sym
-    info.defn.defs.body.append(func)
+    info.defn.defs.body.append(body_node)