Backtestspydanticrun-20261013-104308#13780

Issue #13780 Merged fix PR #13785 Run 13 Oct 2026 · run-20261013-104308 pydantic/pydantic

Concurrent TypeAdapter construction raises RuntimeError on free-threaded Python

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 root cause the issue identifies. Each snapshots the class namespace in `_decorator_infos_for_class` and in `LazyLocalNamespace.data`. A uses `.copy()` and B uses `list(...items())`; both take an atomic snapshot of the underlying dict on free-threaded CPython, so correctness at the reported site is equivalent. B also hardens a third `vars()` iteration in `_known_annotated_metadata`. That is harmless and consistent with the fix.

The difference is in tests and scope.

Tests: every test A adds is skipped unless the build is free-threaded. On a normal GIL build none of them run, so they show nothing about before/after behaviour there. B adds deterministic regression tests that mutate the namespace during iteration through a mutating classmethod descriptor, a `str` key subclass, and a hash side effect. These would raise `RuntimeError: dictionary changed size during iteration` before the change and pass after it on any build, which directly exercises each patched site. B also keeps a threaded reproduction of the issue's scenario.

Scope: A rewrites the `model_rebuild` logic in `main.py`, replacing the conditional `delattr` with `set_model_mocks` when `already_complete`. This is a separate thread-safety change to model rebuilding that the issue does not mention. It changes behaviour for force rebuilds and adds risk and review burden beyond the reported bug. B stays focused on the namespace-iteration race.

With equal correctness, B's portable, failing-before tests and tighter scope make it the better fix.

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

7m 5s

Wall-clock time in the container

Full test suite

No new failures

993 passed · 124 skipped · 1,117 total

Contamination audit

Clean

No sign the agent saw the real fix

Patch size

101vs 198 merged

Changed lines, ours vs merged

Initial Checks

  • I confirm that I'm using Pydantic V2

Description

Constructing separate TypeAdapter instances concurrently for the same new TypedDict can raise RuntimeError: dictionary changed size during iteration on free-threaded Python.

A full run produced 91 failures in 800 attempts with the GIL disabled and none with PYTHON_GIL=1. It also reproduces on Pydantic main at 1c8a330acc3077e77da64e3672c7c875fb4c6eaa.

Lazy annotation evaluation adds __annotations_cache__ while another thread iterates vars(typ).items() in _decorator_infos_for_class.

Example Code

from __future__ import annotations

import threading
from concurrent.futures import ThreadPoolExecutor

from pydantic import TypeAdapter
from typing_extensions import TypedDict


def run_round() -> None:
    class Record(TypedDict):
        value: int

    for index in range(1000):
        setattr(Record, f'metadata_{index}', index)

    barrier = threading.Barrier(8)

    def build(_: int) -> None:
        barrier.wait()
        TypeAdapter(Record).validate_python({'value': '42'})

    with ThreadPoolExecutor(max_workers=8) as executor:
        list(executor.map(build, range(8)))


for _ in range(100):
    run_round()

The synthetic attributes only widen the iteration window. They are not modified after the threads start.

Python, Pydantic & OS Version

pydantic version: 2.13.5
pydantic-core version: 2.46.5
python version: 3.14.3 free-threading build
platform: macOS-26.6.2-arm64
related packages: typing_extensions-4.15.0

The two patches

Our patch+98 −3
pydantic/_internal/_decorators.pyindex 160a18c0..e89054c0 100644@@ -535,7 +535,9 @@ def _decorator_infos_for_class(     res = DecoratorInfos()     to_replace: list[tuple[str, Any]] = [] -    for var_name, var_value in vars(typ).items():+    # Iterate over a snapshot of the class namespace, as it can be mutated concurrently+    # (e.g. lazy annotations evaluation adding `__annotations_cache__` on free-threaded Python):+    for var_name, var_value in list(vars(typ).items()):         if isinstance(var_value, PydanticDescriptorProxy):             info = var_value.decorator_info             if isinstance(info, ValidatorDecoratorInfo):pydantic/_internal/_known_annotated_metadata.pyindex dc18e579..d7cd4a3c 100644@@ -370,7 +370,7 @@ def collect_known_metadata(annotations: Iterable[Any]) -> tuple[dict[str, Any],         elif isinstance(annotation, type) and issubclass(annotation, PydanticMetadata):             # also support PydanticMetadata classes being used without initialisation,             # e.g. `Annotated[int, Strict]` as well as `Annotated[int, Strict()]`-            res.update({k: v for k, v in vars(annotation).items() if not k.startswith('_')})+            res.update({k: v for k, v in list(vars(annotation).items()) if not k.startswith('_')})         else:             remaining.append(annotation)     # Nones can sneak in but pydantic-core will reject thempydantic/_internal/_namespace_utils.pyindex d308f7e4..e380e791 100644@@ -88,7 +88,9 @@ class LazyLocalNamespace(Mapping[str, Any]):      @cached_property     def data(self) -> dict[str, Any]:-        return {k: v for ns in self._namespaces for k, v in ns.items()}+        # Iterate over snapshots of the namespaces, as they can be mutated concurrently+        # (e.g. class namespaces, on free-threaded Python):+        return {k: v for ns in self._namespaces for k, v in list(ns.items())}      def __len__(self) -> int:         return len(self.data)tests/test_annotated.pyindex 65b8d435..9efe992a 100644@@ -19,6 +19,7 @@ from pydantic import (     TypeAdapter,     ValidationError, )+from pydantic._internal._fields import PydanticMetadata from pydantic.errors import PydanticSchemaGenerationError from pydantic.fields import PrivateAttr from pydantic.functional_validators import AfterValidator@@ -662,3 +663,24 @@ def test_decimal_constraints_after_annotation(         with pytest.raises(ValidationError) as exc_info:             ta.validate_python(Decimal(input_value))         assert exc_info.value.errors()[0]['type'] == error_type+++def test_uninitialized_pydantic_metadata_class_namespace_mutated_during_iteration() -> None:+    """The class namespace of a `PydanticMetadata` subclass can be mutated concurrently while+    its constraints are being collected, e.g. on free-threaded Python."""++    class MutatingKey(str):+        __eq__ = str.__eq__+        __hash__ = str.__hash__++        def startswith(self, *args: Any) -> bool:+            setattr(MyStrict, f'_added_{len(vars(MyStrict))}', None)+            return super().startswith(*args)++    MyStrict = type('MyStrict', (PydanticMetadata,), {MutatingKey('strict'): True})++    ta = TypeAdapter(Annotated[int, MyStrict])++    assert ta.validate_python(1) == 1+    with pytest.raises(ValidationError):+        ta.validate_python('1')tests/test_forward_ref.pyindex 59ebb6a9..9bfa08d5 100644@@ -1731,3 +1731,23 @@ def test_string_annotation_union_type() -> None:      assert typing_objects.is_union(get_origin(annotation))     assert get_args(annotation)[0] is Main+++def test_lazy_local_namespace_mutated_during_iteration() -> None:+    """The namespaces (e.g. class namespaces) can be mutated concurrently while being merged,+    e.g. on free-threaded Python."""++    class MutatingKey(str):+        __eq__ = str.__eq__++        def __hash__(self) -> int:+            # Called when the key is inserted in the merged namespace:+            source[f'_added_{len(source)}'] = None+            return str.__hash__(self)++    source: dict[str, Any] = {'b': str}+    source[MutatingKey('a')] = int+    namespace = LazyLocalNamespace(source)++    assert namespace['a'] is int+    assert namespace['b'] is strtests/test_types_typeddict.pyindex 697913f2..b2c2f1db 100644@@ -3,7 +3,9 @@ Tests for TypedDict """  import sys+import threading import typing+from concurrent.futures import ThreadPoolExecutor from typing import Annotated, Any, Generic, Optional, TypeVar  import pytest@@ -1138,3 +1140,50 @@ def test_typeddict_validate_json_error_loc() -> None:             'input': 'wrong',         }     ]+++def test_typeddict_namespace_mutated_during_decorators_collection() -> None:+    """The class namespace can be mutated while decorators are being collected (e.g. by lazy+    annotations evaluation adding `__annotations_cache__` in another thread, on free-threaded Python).+    """++    class MutatingClassMethod(classmethod):+        def __get__(self, obj: Any, owner: Any = None) -> Any:+            setattr(owner, f'_added_{len(vars(owner))}', None)+            return super().__get__(obj, owner)++    class Record(TypedDict):+        value: int++        @field_validator('value')+        @MutatingClassMethod+        def double(cls, v: int) -> int:+            return v * 2++    assert TypeAdapter(Record).validate_python({'value': '21'}) == {'value': 42}+++@pytest.mark.skipif(sys.platform == 'emscripten', reason='no threading on emscripten')+@pytest.mark.thread_unsafe(reason='Spawns its own threads')+def test_typeddict_concurrent_type_adapter_construction() -> None:+    """https://github.com/pydantic/pydantic/issues/13780 (only reproducible on free-threaded Python)."""++    def run_round() -> None:+        class Record(TypedDict):+            value: int++        # Widen the iteration window over the class namespace:+        for index in range(1000):+            setattr(Record, f'metadata_{index}', index)++        barrier = threading.Barrier(8, timeout=10)++        def build(_: int) -> dict[str, int]:+            barrier.wait()+            return TypeAdapter(Record).validate_python({'value': '42'})++        with ThreadPoolExecutor(max_workers=8) as executor:+            assert list(executor.map(build, range(8))) == [{'value': 42}] * 8++    for _ in range(20):+        run_round() 
Merged fix · PR #13785+186 −12
pydantic/_internal/_decorators.pyindex 160a18c00..72b668c53 100644@@ -535,7 +535,12 @@ def _decorator_infos_for_class(     res = DecoratorInfos()     to_replace: list[tuple[str, Any]] = [] -    for var_name, var_value in vars(typ).items():+    # Iterate on the vars with a copy to avoid changes in dictionary size during iteration.+    # This can happen if a concurrent thread has Pydantic processing the same `typ` (e.g. two+    # concurrent threads doing `TypeAdapter(SomeClassType)`), and such thread reads annotations+    # for the first time during the iteration here in the other thread (since 3.14, reading annotations+    # can set attributes such as `__annotations_cache__` or `__annotate_func__` to the type).+    for var_name, var_value in vars(typ).copy().items():         if isinstance(var_value, PydanticDescriptorProxy):             info = var_value.decorator_info             if isinstance(info, ValidatorDecoratorInfo):pydantic/_internal/_namespace_utils.pyindex d308f7e4c..495f17da6 100644@@ -4,6 +4,7 @@ import sys from collections.abc import Callable, Generator, Iterator, Mapping from contextlib import contextmanager from functools import cached_property+from types import MappingProxyType from typing import Any, NamedTuple, TypeAlias, TypeVar  from typing_extensions import ParamSpec, TypeAliasType, TypeVarTuple@@ -88,7 +89,12 @@ class LazyLocalNamespace(Mapping[str, Any]):      @cached_property     def data(self) -> dict[str, Any]:-        return {k: v for ns in self._namespaces for k, v in ns.items()}+        # In rare scenarios, a race condition can happen when iterating over class namespaces (i.e. created with `var(SomeClass)`),+        # if another thread accesses the type annotations for the first time (since 3.14, reading annotations can set attributes+        # such as `__annotations_cache__` or `__annotate_func__` to the type).+        return {+            k: v for ns in self._namespaces for k, v in (ns.copy() if isinstance(ns, MappingProxyType) else ns).items()+        }      def __len__(self) -> int:         return len(self.data)pydantic/main.pyindex 1c0258c69..395c3c85f 100644@@ -711,16 +711,12 @@ class BaseModel(metaclass=_model_construction.ModelMetaclass):              cls.__pydantic_complete__ = False -            for attr in ('__pydantic_core_schema__', '__pydantic_validator__', '__pydantic_serializer__'):-                if attr in cls.__dict__ and not isinstance(-                    getattr(cls, attr), (_mock_val_ser.MockCoreSchema, _mock_val_ser.MockValSer)-                ):-                    # Deleting the validator/serializer is necessary as otherwise they can get reused in-                    # pydantic-core. Same applies for the core schema that can be reused in schema generation.-                    # We do so only if they aren't mock instances, otherwise concurrent reads of these attributes-                    # — performed without holding the rebuild lock (e.g. when instantiating the model) — can-                    # resolve them from the parent class.-                    delattr(cls, attr)+            if already_complete:+                # The existing validator/serializer must not be reused in pydantic-core, and the core schema+                # must not be reused in schema generation. If the model is already complete (i.e. `force=True`),+                # we set back mocks for the model (we could also delete the complete core schema/validator/serializer,+                # but this isn't thread-safe).+                _mock_val_ser.set_model_mocks(cls)              if _types_namespace is not None:                 rebuild_ns = _types_namespacetests/conftest.pyindex b066a013a..694c5855b 100644@@ -23,6 +23,11 @@ from pydantic import BaseModel from pydantic._internal._generate_schema import GenerateSchema from pydantic.json_schema import GenerateJsonSchema +try:+    is_free_threaded = not sys._is_gil_enabled()+except AttributeError:+    is_free_threaded = False+  def pytest_addoption(parser: pytest.Parser):     parser.addoption('--test-mypy', action='store_true', help='run mypy tests')tests/test_freethreaded.pynew file mode 100644index 000000000..af4ef4929@@ -0,0 +1,162 @@+import sys+import threading+from collections.abc import Callable+from concurrent.futures import ThreadPoolExecutor+from typing import Any++import pytest+from typing_extensions import TypedDict++import pydantic.dataclasses+from pydantic import BaseModel, TypeAdapter, field_validator++from .conftest import is_free_threaded++pytestmark = [+    pytest.mark.skipif(sys.platform == 'emscripten', reason='no threading on emscripten'),+    pytest.mark.skipif(not is_free_threaded, reason='only relevant on free-threaded builds'),+]+++def run_concurrently(+    setup: Callable[[], Any], target: Callable[[Any, int], Any], *, rounds: int = 100, threads: int = 8+):+    """Run `target` in `threads` threads at once, `rounds` times, with a fresh `setup()` result each round."""+    for _ in range(rounds):+        ctx = setup()+        barrier = threading.Barrier(threads)++        def work(index: int) -> None:+            barrier.wait()+            target(ctx, index)++        with ThreadPoolExecutor(max_workers=threads) as executor:+            for future in [executor.submit(work, i) for i in range(threads)]:+                future.result()+++def test_typed_dict_concurrent_type_adapter() -> None:+    def setup():+        class Record(TypedDict):+            value: int++        return Record++    def target(Record, _):+        assert TypeAdapter(Record).validate_python({'value': '42'}) == {'value': 42}++    run_concurrently(setup, target)+++def test_base_model_concurrent_creation_with_shared_base() -> None:+    def setup():+        class Mixin:+            a: int = 1++            @field_validator('a')+            @classmethod+            def val_a_1(cls, v: int) -> int:+                return v++            @field_validator('a')+            @classmethod+            def val_a_2(cls, v: int) -> int:+                return v++            @field_validator('a')+            @classmethod+            def val_a_3(cls, v: int) -> int:+                return v++        return Mixin++    def target(Mixin, _):+        class Model(BaseModel, Mixin):+            b: int++        assert Model(b='1').b == 1++    run_concurrently(setup, target)+++def test_dataclass_concurrent_creation_with_shared_base() -> None:+    def setup():+        class Base:+            a: int = 1++            @field_validator('a')+            @classmethod+            def val_a_1(cls, v: int) -> int:+                return v++            @field_validator('a')+            @classmethod+            def val_a_2(cls, v: int) -> int:+                return v++            @field_validator('a')+            @classmethod+            def val_a_3(cls, v: int) -> int:+                return v++        return Base++    def target(Base, _):+        @pydantic.dataclasses.dataclass+        class Sub(Base):+            b: int++        assert Sub(b='1').b == 1++    run_concurrently(setup, target)+++def test_model_rebuild_concurrent_subclass_creation(monkeypatch: pytest.MonkeyPatch) -> None:+    """Test targeted at our `LazyLocalNamespace.data` property implementation."""++    def setup():+        monkeypatch.delitem(globals(), 'Later', raising=False)++        class Model(BaseModel):+            # `Later` isn't defined yet, so the field is deferred and no annotations cache is set on the class:+            x: Later  # noqa: F821  # pyright: ignore[reportUndefinedVariable]++        # Widen the class dict so that iterating over it takes long enough for the race to happen:+        for i in range(3000):+            setattr(Model, f'attr_{i}', i)++        # Dynamically set the item in globals instead of a simple assignment to force `ForwardRef.evaluate()` into looking at the+        # provided namespace during evaluation (otherwise it doesn't look at globals/locals and uses `ForwardRef.__cell__` directly)+        monkeypatch.setitem(globals(), 'Later', int)+        return Model++    def target(Model, index: int):+        if index == 0:+            # Collecting the fields of the subclass reads the annotations of `Model` for the first time:+            class Sub(Model):+                pass++            assert Sub(x='1').x == 1+        else:+            Model.model_rebuild(force=True)++    run_concurrently(setup, target)+++def test_model_force_rebuild_concurrent_instantiation() -> None:+    """Test targeted at our logic in `model_rebuild()`, when we set back mocks on already complete models."""++    def setup():+        class Model(BaseModel):+            x: int++        assert Model(x=1).x == 1  # `Model` is complete, with a real validator set on the class+        return Model++    def target(Model, index):+        if index == 0:+            Model.model_rebuild(force=True)+        else:+            assert Model(x='1').x == 1++    run_concurrently(setup, target)