Propose change for subclass inherited_fields override when include_fk=False (#657)

* fix: propose change for inheriting override in the presence of include_fk=False

* Improve naming

* Update changelog

---------

Co-authored-by: Steven Loria <[email protected]>

Author: carterjc

CHANGELOG.rst

@@ -1,6 +1,15 @@
 Changelog
 ---------
 
+(unreleased)
+++++++++++++
+
+Bug fixes:
+
+* Fix inheritance of declared fields that match then name of a foreign key column
+  when the ``include_fk`` option is set to ``False`` (:pr:`657`).
+  Thanks :user:`carterjc` for the PR.
+
 1.4.0 (2025-01-19)
 ++++++++++++++++++
 

src/marshmallow_sqlalchemy/schema.py

@@ -1,10 +1,11 @@
 from __future__ import annotations
 
+import inspect
 from typing import TYPE_CHECKING, Any, cast
 
 import sqlalchemy as sa
 from marshmallow.fields import Field
-from marshmallow.schema import Schema, SchemaMeta, SchemaOpts
+from marshmallow.schema import Schema, SchemaMeta, SchemaOpts, _get_fields
 
 from .convert import ModelConverter
 from .exceptions import IncorrectSchemaTypeError
@@ -118,7 +119,7 @@ def get_declared_fields(
             cls_fields,
             # Filter out fields generated from foreign key columns
             # if include_fk is set to False in the options
-            mcs._maybe_filter_foreign_keys(inherited_fields, opts=opts),
+            mcs._maybe_filter_foreign_keys(inherited_fields, opts=opts, klass=klass),
             dict_cls,
         )
         fields.update(mcs.get_declared_sqla_fields(fields, converter, opts, dict_cls))
@@ -159,6 +160,7 @@ def _maybe_filter_foreign_keys(
         fields: list[tuple[str, Field]],
         *,
         opts: SQLAlchemySchemaOpts,
+        klass: SchemaMeta,
     ) -> list[tuple[str, Field]]:
         if opts.model is not None or opts.table is not None:
             if not hasattr(opts, "include_fk") or opts.include_fk is True:
@@ -168,13 +170,39 @@ def _maybe_filter_foreign_keys(
                 for column in sa.inspect(opts.model or opts.table).columns  # type: ignore[union-attr]
                 if column.foreign_keys
             }
-            return [(name, field) for name, field in fields if name not in foreign_keys]
+
+            non_auto_schema_bases = [
+                base
+                for base in inspect.getmro(klass)
+                if issubclass(base, Schema)
+                and not issubclass(base, SQLAlchemyAutoSchema)
+            ]
+
+            def is_declared_field(field: str) -> bool:
+                return any(
+                    field
+                    in [
+                        name
+                        for name, _ in _get_fields(
+                            getattr(base, "_declared_fields", base.__dict__)
+                        )
+                    ]
+                    for base in non_auto_schema_bases
+                )
+
+            return [
+                (name, field)
+                for name, field in fields
+                if name not in foreign_keys or is_declared_field(name)
+            ]
         return fields
 
 
 class SQLAlchemyAutoSchemaMeta(SQLAlchemySchemaMeta):
     @classmethod
-    def get_declared_sqla_fields(cls, base_fields, converter, opts, dict_cls):
+    def get_declared_sqla_fields(
+        cls, base_fields, converter: ModelConverter, opts, dict_cls
+    ):
         fields = dict_cls()
         if opts.table is not None:
             fields.update(

tests/test_sqlalchemy_schema.py

@@ -681,6 +681,36 @@ class Meta(TeacherSchema.Meta):
     assert "current_school_id" in schema2.fields
 
 
+def test_auto_schema_with_model_can_inherit_declared_field_for_foreign_key_column_when_include_fk_is_false(
+    models,
+):
+    class BaseTeacherSchema(Schema):
+        current_school_id = fields.Integer()
+
+    class TeacherSchema(BaseTeacherSchema, SQLAlchemyAutoSchema):
+        class Meta:
+            model = models.Teacher
+            include_fk = False
+
+    schema = TeacherSchema()
+    assert "current_school_id" in schema.fields
+
+
+def test_auto_schema_with_table_can_inherit_declared_field_for_foreign_key_column_when_include_fk_is_false(
+    models,
+):
+    class BaseTeacherSchema(Schema):
+        current_school_id = fields.Integer()
+
+    class TeacherSchema(BaseTeacherSchema, SQLAlchemyAutoSchema):
+        class Meta:
+            table = models.Teacher.__table__
+            include_fk = False
+
+    schema = TeacherSchema()
+    assert "current_school_id" in schema.fields
+
+
 def test_auto_field_does_not_accept_arbitrary_kwargs(models):
     if int(version("marshmallow")[0]) < 4:
         from marshmallow.warnings import RemovedInMarshmallow4Warning
@@ -695,6 +725,7 @@ class Meta:
                     model = models.Course
 
                 name = auto_field(description="A course name")
+
     else:
         with pytest.raises(TypeError, match="unexpected keyword argument"):