Backtestspydanticrun-20261005-183002#13465

Issue #13465 Merged fix PR #13483 Run 5 Oct 2026 · run-20261005-183002 pydantic/pydantic

Generic pydantic_extra typevar substitution lost in non-generic subclasses of parametrized models

Better

Our patch was judged better than the merged fix.

In this judgment, Patch B = our agent, Patch A = the merged fix.

Both patches fix the reported case. For `class Sub(M[int])`, when `__pydantic_extra__` is only inherited, each reuses the parent's already-substituted `PydanticExtraInfo`, so `Sub` gets `dict[str, int]`, validates extras, and emits `additionalProperties: {'type': 'integer'}`.

The patches differ at the edges.

**Incomplete parent annotations.** Patch A reuses the parent's extra info even when it is incomplete, and only substitutes when `typevars_map` is non-empty. Take a parent with a forward reference that couldn't be resolved at its own definition time, such as `'dict[str, Later]'` defined in another module. A subclass created after `Later` exists would then inherit an incomplete info instead of re-evaluating the hint. On main today, the hint would be re-evaluated in the declaring class's namespace and resolve correctly. So Patch A risks a regression here, and it imports the #12000-style limitation into a path that currently works. Patch B explicitly falls back to `type_hints['__pydantic_extra__']` when the parent info is incomplete, avoiding this. It also adds a cross-module test for exactly that scenario.

**Choosing the parent.** Patch A takes the first direct base whose `getattr(base, '__pydantic_extra_info__')` is non-None. Patch B walks the MRO to find the class that actually declares the annotation, then takes the most-derived class at or before it that has its own `__pydantic_extra_info__`. This matches how annotation resolution works and is more robust under multiple inheritance and diamonds.

**Tests.** Patch A adds one test covering the basic case. Patch B covers the basic case, a two-level non-generic subclass (`SubSub`), extra-info inherited from a second base, and the cross-module incomplete case. Patch B's tests are broader and target real edge cases.

**Craft.** Patch B's helper adds some code but is well documented. It keeps the existing `replace_types` flow intact instead of branching on `typevars_map`.

Overall, Patch B is more correct at the edges and better tested.

The judge saw only the two patches, labelled A and B in random order, with issue links and version numbers removed. The reasoning above is shown verbatim.

Solve

9m 46s

Wall-clock time in the container

Full test suite

No new failures

12,270 passed · 501 skipped · 12,771 total

Contamination audit

Clean

No sign the agent saw the real fix

Patch size

93vs 56 merged

Changed lines, ours vs merged

Initial Checks

  • I confirm that I'm using Pydantic V2 (main @ 428b0dba8)
  • I have searched GitHub for a duplicate issue and I'm sure this is something new

Description

Follow-up to #13369 / #13391 (__pydantic_extra__ typevar substitution, currently main-only): the substitution works for direct parametrization (M[int]) but is lost in a plain (non-generic) subclass of a parametrized model (class Sub(M[int])). Extras on the subclass are silently unvalidated and the JSON schema loses the extras type.

M[int](x='nope')  -> ValidationError (correct, fixed by #13391)
Sub(x='nope')     -> accepted; m.x == 'nope'          # BUG
Sub(x='5').x      -> '5' (str)  vs  M[int](x='5').x == 5

M[int].model_json_schema()['additionalProperties']  -> {'type': 'integer'}
Sub.model_json_schema()['additionalProperties']     -> {}                  # BUG
Sub.__pydantic_extra_info__                          -> PydanticExtraInfo(annotation=dict[str, ~T], complete=True)

Root cause (from stepping through collect_model_fields in pydantic/_internal/_fields.py): for Sub, typevars_map is empty (its own __pydantic_generic_metadata__ is empty) and the inherited hint for __pydantic_extra__ is the parent's raw annotation dict[str, T] — so _generics.replace_types(ann, typevars_map) is a no-op and the raw ~T survives, producing extras_schema = {'type': 'any'}. Regular fields don't have this problem because they're copied from the parent's already-substituted model_fields; the extra-info path never consults the parent's __pydantic_extra_info__ (which on M[int] correctly holds dict[str, int]).

Note the 2-level generic chain (class Mid(M[T], Generic[T]); Mid[int]) works on main — only the plain-subclass case is broken.

I have a small fix working locally (reuse the parent's substituted PydanticExtraInfo annotation when __pydantic_extra__ is only inherited, mirroring how fields inherit; brings extra-info to exact parity with fields, including the same known deferred-annotation limitation as #12000), with a regression test in the style of test_extra_generic_class — it passes the test_main.py / test_generics.py / test_forward_ref.py / test_edge_cases.py suites with no new failures. Per the contributing guidelines I'd like to be assigned before opening the PR — happy to submit it right away.

Example Code

from typing import Generic, TypeVar
from pydantic import BaseModel, ConfigDict

T = TypeVar('T')

class M(BaseModel, Generic[T]):
    model_config = ConfigDict(extra='allow')
    __pydantic_extra__: dict[str, T]
    y: T

class Sub(M[int]):
    pass

print(Sub(y=1, x='not_an_int').x)  # 'not_an_int' — should raise ValidationError
print(Sub.model_json_schema().get('additionalProperties'))  # {} — should be {'type': 'integer'}

Python, Pydantic & OS Version

pydantic version: 2.14.0a1
pydantic-core version: 2.47.0
python version: 3.14.4
platform: macOS-26.5-arm64
commit: 428b0dba8 (main)

The two patches

Our patch+92 −1
pydantic/_internal/_fields.pyindex 59c7f8d7..3ab5c1ce 100644@@ -423,7 +423,16 @@ def collect_model_fields(  # noqa: C901      pydantic_extra_info: PydanticExtraInfo | None = None     if '__pydantic_extra__' in type_hints:-        ann, complete = type_hints['__pydantic_extra__']+        parent_extra_info = _get_inherited_extra_info(cls) if '__pydantic_extra__' not in cls_annotations else None+        if parent_extra_info is not None and parent_extra_info.complete:+            # Similar to fields, the annotation is inherited from one of the bases: we reuse the parent's+            # `PydanticExtraInfo` instance, as its annotation may have already been substituted (e.g. if+            # the parent is a parametrized generic model, such as in `class Sub(MyGenericModel[int]): ...`).+            # If the parent's annotation is incomplete, it wasn't substituted yet, so we evaluate the type+            # hint again instead (as it may be resolvable now, in the namespace of the declaring class).+            ann, complete = parent_extra_info.annotation, parent_extra_info.complete+        else:+            ann, complete = type_hints['__pydantic_extra__']         if complete:             # If not complete, `rebuild_model_fields()` takes care of it:             ann = _generics.replace_types(ann, typevars_map)@@ -435,6 +444,27 @@ def collect_model_fields(  # noqa: C901     return fields, pydantic_extra_info, class_vars  +def _get_inherited_extra_info(cls: type[BaseModel]) -> PydanticExtraInfo | None:+    """Get the `PydanticExtraInfo` of the parent from which the `__pydantic_extra__` annotation is inherited.++    The annotation is declared on the first class of the MRO that has it in its own annotations. However, the+    `PydanticExtraInfo` instance to reuse is the one of the first class in the MRO that is a subclass of this+    declaring class, as it may have its annotation substituted (e.g. a parametrized generic model).+    """+    mro = cls.__mro__[1:]+    for declaring_idx, base in enumerate(mro):+        if '__pydantic_extra__' in _typing_extra.safe_get_annotations(base):+            break+    else:+        return None++    declaring_cls = mro[declaring_idx]+    for base in mro[: declaring_idx + 1]:+        if issubclass(base, declaring_cls) and (extra_info := base.__dict__.get('__pydantic_extra_info__')) is not None:+            return extra_info+    return None++ def rebuild_model_fields(     cls: type[BaseModel],     *,tests/test_main.pyindex f924cec9..5ac9feed 100644@@ -3507,6 +3507,67 @@ def test_extra_generic_class() -> None:     assert Mint(extra_value='1').model_extra == {'extra_value': 1}  +def test_extra_generic_class_non_generic_subclass() -> None:+    """https://github.com/pydantic/pydantic/issues/13465"""++    T = TypeVar('T')++    class Model(BaseModel, Generic[T], extra='allow'):+        __pydantic_extra__: dict[str, T]+        y: T++    class Sub(Model[int]):+        pass++    class SubSub(Sub):+        pass++    for cls in (Sub, SubSub):+        assert cls.model_json_schema()['additionalProperties'] == {'type': 'integer'}++        with pytest.raises(ValidationError):+            cls(y=1, x='not_an_int')++        m = cls(y=1, x='5')+        assert m.x == 5+        assert m.model_extra == {'x': 5}+++def test_extra_inherited_from_second_base() -> None:+    class A(BaseModel):+        a: int = 1++    class B(BaseModel, extra='allow'):+        __pydantic_extra__: dict[str, int]++    class C(A, B):+        pass++    assert C.model_json_schema()['additionalProperties'] == {'type': 'integer'}++    with pytest.raises(ValidationError):+        C(x='not_an_int')++    assert C(x='5').model_extra == {'x': 5}+++def test_extra_incomplete_parent_subclass_other_module(create_module) -> None:+    @create_module+    def module_a():+        from pydantic import BaseModel++        class Model(BaseModel, extra='allow'):+            __pydantic_extra__: 'dict[str, Later]'++        class Later(BaseModel):+            v: int++    class Sub(module_a.Model):+        pass++    assert Sub(x={'v': '1'}).model_extra == {'x': module_a.Later(v=1)}++ def test_super_getattr_extra():     class Model(BaseModel):         model_config = {'extra': 'allow'} 
Merged fix · PR #13483+48 −8
pydantic/_internal/_fields.pyindex 59c7f8d79..af78e98db 100644@@ -423,14 +423,35 @@ def collect_model_fields(  # noqa: C901      pydantic_extra_info: PydanticExtraInfo | None = None     if '__pydantic_extra__' in type_hints:-        ann, complete = type_hints['__pydantic_extra__']-        if complete:-            # If not complete, `rebuild_model_fields()` takes care of it:-            ann = _generics.replace_types(ann, typevars_map)-        pydantic_extra_info = PydanticExtraInfo(-            annotation=ann,-            complete=complete,-        )+        parent_extra_info: PydanticExtraInfo | None = None+        if '__pydantic_extra__' not in cls_annotations:+            # The annotation is only present on parent classes. As with fields, we make use of the parent's+            # extra info, where type variables are already substituted:+            for base in bases:+                parent_extra_info = getattr(base, '__pydantic_extra_info__', None)+                if parent_extra_info is not None:+                    break++        if parent_extra_info is not None:+            # As with fields, the only case where substituting the type variables is relevant (i.e. when+            # `typevars_map` is not empty) is when a generic class is parameterized:+            if typevars_map and parent_extra_info.complete:+                # If not complete, `rebuild_model_fields()` takes care of it:+                pydantic_extra_info = PydanticExtraInfo(+                    annotation=_generics.replace_types(parent_extra_info.annotation, typevars_map),+                    complete=True,+                )+            else:+                pydantic_extra_info = parent_extra_info+        else:+            ann, complete = type_hints['__pydantic_extra__']+            if complete:+                # If not complete, `rebuild_model_fields()` takes care of it:+                ann = _generics.replace_types(ann, typevars_map)+            pydantic_extra_info = PydanticExtraInfo(+                annotation=ann,+                complete=complete,+            )      return fields, pydantic_extra_info, class_vars tests/test_main.pyindex f924cec99..b6511f5c2 100644@@ -3507,6 +3507,25 @@ def test_extra_generic_class() -> None:     assert Mint(extra_value='1').model_extra == {'extra_value': 1}  +def test_extra_generic_class_subclass() -> None:+    """https://github.com/pydantic/pydantic/issues/13465"""++    T = TypeVar('T')++    class Model(BaseModel, Generic[T], extra='allow'):+        __pydantic_extra__: dict[str, T]++    class Sub(Model[int]):+        pass++    assert Sub.model_json_schema()['additionalProperties'] == {'type': 'integer'}++    with pytest.raises(ValidationError):+        Sub(extra_value='not_an_int')++    assert Sub(extra_value='1').model_extra == {'extra_value': 1}++ def test_super_getattr_extra():     class Model(BaseModel):         model_config = {'extra': 'allow'}