Backtestspydanticrun-20261005-183002#13520

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

Generic model parametrization drops field defaults and typevar substitution after __annotations__ is read on a metaclass (Python <= 3.13)

Better

Our patch was judged better than the merged fix.

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

Both patches make the same root-cause fix. On Python <= 3.13, when `obj` is a class, `safe_get_annotations` reads own annotations from `obj.__dict__` instead of using `getattr`. This avoids the inherited-annotations leak that happens when a metaclass's `__dict__` holds a plain `__annotations__` dict shadowing the `type.__annotations__` descriptor. The issue suggests exactly this approach, so on correctness of the core fix they are essentially equal.

Patch A adds one extra guard. If the `__dict__` entry is a `GetSetDescriptorType` (the case where `obj` is `type` itself), it returns `{}` rather than the descriptor object. It also documents the rationale in the docstring. This edge case is unlikely in practice, but it makes the function robust for any class input.

On tests, Patch A is clearly stronger:
- Its generic test reproduces the reported scenario end-to-end. It defines a custom `ModelMetaclass` subclass, reads its `__annotations__`, and parametrizes `G[str]`. It then checks that defaults are kept, the typevar is substituted, invalid input is rejected, and generic and non-generic subclasses still work. This would fail before the fix.
- It also adds a pydantic dataclass inheritance test, confirming that parent fields keep their parent-namespace evaluation and `FieldInfo` metadata under the same poisoning.

Patch B adds only a direct unit test of `safe_get_annotations` on a plain-metaclass hierarchy. That test is valid and would fail before the fix, but it does not exercise the user-visible symptom (dropped defaults and missing typevar substitution in generic parametrization).

Scope is comparable and minimal in both. Patch A wins on test coverage of the actual reported behavior and slightly better edge-case handling and documentation.

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

13m 39s

Wall-clock time in the container

Full test suite

No new failures

12,275 passed · 501 skipped · 12,776 total

Contamination audit

Clean

No sign the agent saw the real fix

Patch size

98vs 26 merged

Changed lines, ours vs merged

Initial Checks

  • I confirm that I'm using Pydantic V2

Description

This is a regression on main (2.14.0a1); I could not reproduce it on any released version (checked 2.13.4 and 2.10.6 under the same conditions). It affects Python 3.10–3.13 (verified on 3.10, 3.12 and 3.13); Python 3.14 is unaffected.

If __annotations__ has ever been read on a metaclass appearing in a model's metatype MRO (e.g. ModelMetaclass itself, or abc.ABCMeta), then any generic model parametrized for the first time afterwards gets a broken schema:

  • type variables are not substituted (x: T ends up with an any schema), and
  • field defaults are dropped (fields with defaults become required).

Parametrizations built before the read keep working, since their schemas are already cached — which makes this very order-dependent and confusing to track down in a real test suite.

Reading an attribute sounds like an odd trigger, but it happens in the wild: on CPython ≤ 3.13, reading __annotations__ on a (heap) class that has none auto-creates a plain __annotations__ = {} entry in that class's __dict__ (see the annotations HOWTO). langgraph does such a read at import time (get_cached_annotated_keys in langgraph/_internal/_fields.py has a getattr(base, "__annotations__", None) fallback — added for Python 3.14 compat, ironically — which ends up planting {} on abc.ABCMeta). So a plain import langgraph.prebuilt breaks all subsequently-parametrized generic models. We found this via the pydantic/logfire weekly CI job testing against pydantic main, where pydantic_evals.Dataset.from_dict() fails with 3 validation errors for _DatasetModel[...] — Field required for exactly its three defaulted fields — but only in test runs where a langchain test ran first (failing run).

Mechanism:

  1. The planted {} lives in the metaclass's __dict__. For a model class M, attribute lookup of M.__annotations__ searches type(M).__mro__ (e.g. (ModelMetaclass, ABCMeta, type, object)) and now finds the plain dict before reaching the type.__annotations__ getset descriptor. A plain dict is not a data descriptor, so lookup falls back to M's own MRO — and for a class with no own __annotations__ (like a freshly created generic submodel), this returns the parent's annotations. (Normally the type.__annotations__ data descriptor intercepts the lookup and auto-creates/returns the class's own empty dict, which is what makes getattr look safe.)
  2. safe_get_annotations() in pydantic/_internal/_typing_extra.py uses getattr(obj, '__annotations__', {}) on < 3.14, so for the new submodel G[str] it returns the origin's annotations instead of {}: clean: safe_get_annotations(G[str]) == {} poisoned: safe_get_annotations(G[str]) == {'x': ~T, 'a': <class 'int'>}
  3. In collect_model_fields(), cls_annotations is "only used to determine if an annotation comes from a parent class". The leak makes ann_name in cls_annotations true for every inherited field, so instead of copying the parent FieldInfo and applying typevars_map (via _recreate_field_info), it takes the plain FieldInfo.from_annotation(ann_type) branch: no typevar substitution, and no default — the origin's class-attribute default is long gone because it was delattr'd during the origin's own field collection.

Possible fix: for classes on ≤ 3.13, read own annotations via obj.__dict__.get('__annotations__', {}) (what inspect.get_annotations() does) rather than getattr. Both call sites of safe_get_annotations() seem to want own-class annotations anyway: get_model_type_hints() iterates the MRO itself and calls it per base, and cls_annotations in collect_model_fields() is explicitly meant to be the current class's own annotations.

Example Code

from typing import Generic, TypeVar

from pydantic import BaseModel

# The trigger: any read of `__annotations__` on a metaclass. On CPython <= 3.13 this
# auto-creates a plain `__annotations__ = {}` entry in the metaclass's `__dict__`,
# which shadows the `type.__annotations__` data descriptor for every model class.
# `abc.ABCMeta.__annotations__` has the same effect, and `import langgraph.prebuilt`
# performs an equivalent read at import time.
type(BaseModel).__annotations__

T = TypeVar('T')


class G(BaseModel, Generic[T]):
    x: T
    a: int = 5


G[str].model_validate({'x': 'hi'})
pydantic_core._pydantic_core.ValidationError: 1 validation error for G[str]
a
  Field required [type=missing, input_value={'x': 'hi'}, input_type=dict]
    For further information visit https://errors.pydantic.dev/2.14/v/missing

Removing the type(BaseModel).__annotations__ line — or moving the G[str] parametrization above it — makes it pass. To run against main:

uv run --isolated --no-project --python 3.13 --with "pydantic @ git+https://github.com/pydantic/pydantic.git" repro.py

Python, Pydantic & OS Version

             pydantic version: 2.14.0a1
        pydantic-core version: 2.47.0
          pydantic-core build: profile=release pgo=false
               python version: 3.13.0 (main, Oct 12 2024, 20:24:27) [Clang 15.0.0 (clang-1500.3.9.4)]
                     platform: macOS-26.5.1-arm64-arm-64bit-Mach-O
             related packages: mypy-2.3.0 pyright-1.1.411 email-validator-2.3.0 fastapi-0.139.2 pydantic-settings-2.14.2 typing_extensions-4.16.0
                       commit: a187a65467a588ccc00761d80f325b45381ca819

Selected Assignee: @Viicos

The two patches

Our patch+98 −0
pydantic/_internal/_typing_extra.pyindex ab6a1397..fb47f18f 100644@@ -290,9 +290,22 @@ def safe_get_annotations(obj: Any) -> dict[str, Any]:     Starting with Python 3.14, accessing the `__annotations__` attribute might raise a `NameError` if     a referenced symbol isn't defined yet. In this case, we return the annotation in the *forward ref*     format.++    For classes, only the annotations defined on the class itself are returned (not the ones from+    parent classes). On Python 3.13 and below, the annotations are read from the class `__dict__`+    (as `inspect.get_annotations()` does) instead of using `getattr()`: if a metaclass of `obj`+    has an `__annotations__` entry in its own `__dict__` (which can happen by simply *reading*+    `__annotations__` on the metaclass), it shadows the `type.__annotations__` descriptor and+    `getattr()` would return the annotations of a parent class.     """     if sys.version_info >= (3, 14):         return annotationlib.get_annotations(obj, format=annotationlib.Format.FORWARDREF)+    elif isinstance(obj, type):+        ann = obj.__dict__.get('__annotations__')+        # `type.__dict__['__annotations__']` is the getset descriptor itself:+        if ann is None or isinstance(ann, types.GetSetDescriptorType):+            return {}+        return ann     else:         return getattr(obj, '__annotations__', {}) tests/test_dataclasses.pyindex a32bc7ae..cbe439f0 100644@@ -3345,3 +3345,48 @@ def test_polymorphic_serialization_with_model_serializer(config: bool, runtime:     else:         assert serializer.to_python(ClassB(a=123, b='test'), **kwargs) == 'ClassA'         assert serializer.to_json(ClassB(a=123, b='test'), **kwargs) == b'"ClassA"'+++def test_inherited_fields_with_metaclass_annotations_read(create_module: Any) -> None:+    """https://github.com/pydantic/pydantic/issues/13520++    On Python 3.13 and below, reading `__annotations__` on a metaclass shadows the+    `type.__annotations__` descriptor for classes using this metaclass. Fields from parent+    dataclasses should still be evaluated in the namespace of the parent class.+    """++    parent_module = create_module(+        """+import pydantic++class Meta(type):+    pass++Meta.__annotations__++Alias = int++@pydantic.dataclasses.dataclass+class Parent(metaclass=Meta):+    a: 'Alias' = pydantic.Field(default=1, description='a')+"""+    )++    child_module = create_module(+        f"""+import pydantic+from {parent_module.__name__} import Parent++# `Child` should not re-evaluate the annotation of `a` in this module:+Alias = str++@pydantic.dataclasses.dataclass+class Child(Parent):+    pass+"""+    )++    Child = child_module.Child+    assert Child.__pydantic_fields__['a'].annotation is int+    assert Child.__pydantic_fields__['a'].description == 'a'+    assert Child(a='2').a == 2tests/test_generics.pyindex a0c46632..adfc5eef 100644@@ -63,6 +63,7 @@ from pydantic._internal._generics import (     recursively_defined_type_refs,     replace_types, )+from pydantic._internal._model_construction import ModelMetaclass from pydantic.warnings import GenericBeforeBaseModelWarning  @@ -3271,3 +3272,42 @@ def test_slots_forwarded_from_generic_class() -> None:         with pytest.raises(TypeError):             # As per https://docs.python.org/3/reference/datamodel.html#slots:             weakref.ref(BaseInt())+++def test_parametrization_with_metaclass_annotations_read() -> None:+    """https://github.com/pydantic/pydantic/issues/13520++    On Python 3.13 and below, reading `__annotations__` on a metaclass creates a plain dict+    entry in the metaclass `__dict__`, shadowing the `type.__annotations__` descriptor for+    classes using this metaclass (making `getattr(cls, '__annotations__')` return the+    annotations of a parent class).+    """++    class Meta(ModelMetaclass):+        pass++    Meta.__annotations__++    T = TypeVar('T')++    class G(BaseModel, Generic[T], metaclass=Meta):+        x: T+        a: int = 5++    GStr = G[str]+    assert GStr.model_validate({'x': 'hi'}).model_dump() == {'x': 'hi', 'a': 5}+    assert GStr.model_fields['x'].annotation is str+    assert not GStr.model_fields['a'].is_required()++    with pytest.raises(ValidationError):+        G[int].model_validate({'x': 'not an int'})++    class Sub(G[int]):+        b: str = 'b'++    assert Sub(x=1).model_dump() == {'x': 1, 'a': 5, 'b': 'b'}++    class NonGenericSub(GStr):+        pass++    assert NonGenericSub(x='hi').model_dump() == {'x': 'hi', 'a': 5} 
Merged fix · PR #13521+25 −1
pydantic/_internal/_typing_extra.pyindex ab6a1397c..d68c792af 100644@@ -294,7 +294,10 @@ def safe_get_annotations(obj: Any) -> dict[str, Any]:     if sys.version_info >= (3, 14):         return annotationlib.get_annotations(obj, format=annotationlib.Format.FORWARDREF)     else:-        return getattr(obj, '__annotations__', {})+        if isinstance(obj, type):+            return obj.__dict__.get('__annotations__', {})+        else:+            return getattr(obj, '__annotations__', {})   def get_model_type_hints(tests/test_edge_cases.pyindex 3e8e38e7d..df52288cc 100644@@ -51,6 +51,7 @@ from pydantic import (     validator, ) from pydantic._internal._model_construction import ModelMetaclass+from pydantic._internal._typing_extra import safe_get_annotations from pydantic.fields import Field, computed_field from pydantic.functional_serializers import (     field_serializer,@@ -3161,3 +3162,23 @@ def test_model_fields_set_includes_extra_after_assignment():     m.extra_after_init = 3     assert m.model_fields_set == {'field', 'extra_at_init', 'extra_after_init'}     assert m.model_extra == {'extra_at_init': 2, 'extra_after_init': 3}+++def test_safe_get_annotations_from_dict() -> None:+    """https://github.com/pydantic/pydantic/issues/13520"""++    class Meta(type):+        pass++    Meta.__annotations__++    class Base(metaclass=Meta):+        pass++    class Main(Base):+        f: int++    class Sub(Main):+        pass++    assert safe_get_annotations(Sub) == {}