Backtestspydanticrun-20260930-183947#13780
Concurrent TypeAdapter construction raises RuntimeError on free-threaded Python
Our patch was judged better than the merged fix.
In this judgment, Patch A = our agent, Patch B = the merged fix.
Both patches fix the root cause the same way: they iterate over `vars(typ).copy()` in `_decorator_infos_for_class`, which is atomic, and they snapshot class namespaces in `LazyLocalNamespace.data`. Patch A is slightly broader. Its `_snapshot` helper also copies plain dicts, not just mapping proxies. It also hardens `collect_known_metadata`, a low-risk change. The decisive differences are tests and scope. Patch A's tests are deterministic and run on every interpreter. One uses a `__hash__` side effect to mutate a mapping proxy's backing dict during iteration. The other uses a `__class__` property, triggered by the `isinstance` checks during decorator collection, to add a class attribute mid-iteration. Both would raise 'dictionary changed size during iteration' before the fix and pass after it. Patch A also adds the issue's concurrent reproduction. Patch B's tests are all skipped unless the build is free-threaded. So in ordinary CI they give no regression protection, and even on free-threaded builds they are probabilistic. Patch B also rewrites `BaseModel.model_rebuild` in `main.py`. Instead of deleting non-mock core schema, validator and serializer attributes, it now calls `set_model_mocks` only when `already_complete`. That behavioral change is unrelated to the reported TypedDict/TypeAdapter race. It adds risk and makes the fix harder to read. Patch B's conftest addition is fine but only supports those skipped tests. Correctness on the reported issue is equivalent. Patch A wins on its reliable, deterministic tests and its tighter, lower-risk scope.
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
6m 33s
Wall-clock time in the container
Full test suite
No new failures
12,714 passed · 509 skipped · 13,223 total
Contamination audit
Clean
No sign the agent saw the real fix
Patch size
108vs 198 merged
Changed lines, ours vs merged
The issue
View on GitHubInitial 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.0The two patches
pydantic/_internal/_decorators.pyindex 160a18c0..3490e00b 100644@@ -535,7 +535,10 @@ 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 copy of the class namespace, as it can be mutated concurrently by another thread+ # (e.g. on Python 3.14+, lazy annotations evaluation sets `__annotations_cache__`). The `copy()` call+ # is atomic, unlike iterating over the namespace directly:+ 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/_known_annotated_metadata.pyindex dc18e579..617d746f 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 vars(annotation).copy().items() if not k.startswith('_')}) else: remaining.append(annotation) # Nones can sneak in but pydantic-core will reject thempydantic/_internal/_namespace_utils.pyindex d308f7e4..cec05d28 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@@ -61,6 +62,18 @@ def get_module_ns_of(obj: Any) -> dict[str, Any]: return {} +def _snapshot(namespace: MappingNamespace) -> MappingNamespace:+ """Return a copy of the namespace if it is a dictionary or a mapping proxy (e.g. a class `__dict__`).++ Such namespaces can be mutated concurrently by another thread (e.g. on Python 3.14+, lazy annotations+ evaluation sets `__annotations_cache__` in the class namespace). Unlike iterating over the namespace+ directly, the `copy()` call is atomic.+ """+ if isinstance(namespace, (dict, MappingProxyType)):+ return namespace.copy()+ return namespace++ # Note that this class is almost identical to `collections.ChainMap`, but need to enforce # immutable mappings here: class LazyLocalNamespace(Mapping[str, Any]):@@ -88,7 +101,7 @@ 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()}+ return {k: v for ns in self._namespaces for k, v in _snapshot(ns).items()} def __len__(self) -> int: return len(self.data)tests/test_forward_ref.pyindex 59ebb6a9..a58c5673 100644@@ -3,6 +3,7 @@ import platform import re import sys import typing+from types import MappingProxyType from typing import Annotated, Any, Generic, Optional, TypeVar, Union import pytest@@ -1144,6 +1145,36 @@ def test_lazy_local_namespace_len() -> None: assert len(namespace) == 2 +def test_lazy_local_namespace_class_namespace_mutated_during_evaluation() -> None:+ """The lazy local namespace should not fail if a class namespace (as exposed by `vars()`) is mutated concurrently.++ On free-threaded Python, another thread can add entries (e.g. `__annotations_cache__`) to the class+ namespace while the local namespace data is being computed. This is simulated by mutating the+ underlying dictionary while its items are being consumed.+ """+ underlying: dict[Any, Any] = {}+ namespace_proxy = MappingProxyType(underlying)++ class MutatingKey(str):+ armed = False++ def __hash__(self) -> int:+ if MutatingKey.armed:+ MutatingKey.armed = False+ underlying['__annotations_cache__'] = {}+ return super().__hash__()++ underlying[MutatingKey('a')] = int+ underlying['b'] = str+ MutatingKey.armed = True++ namespace = LazyLocalNamespace({'c': bytes}, namespace_proxy)++ assert namespace['a'] is int+ assert namespace['b'] is str+ assert namespace['c'] is bytes++ @pytest.mark.xfail( reason='While `get_cls_type_hints` uses the correct module ns for each base, `collect_model_fields` ' 'will still use the `FieldInfo` instances from each base (see the `parent_fields_lookup` logic). 'tests/test_type_adapter.pyindex 1038a829..f918c92e 100644@@ -1,4 +1,7 @@ import json+import sys+import threading+from concurrent.futures import ThreadPoolExecutor from dataclasses import dataclass from datetime import date, datetime from typing import Annotated, Any, ForwardRef, Generic, NamedTuple, TypeAlias, TypeVar, Union@@ -763,3 +766,55 @@ def test_validate_json_invalid_json(): 'ctx': {'error': 'trailing comma at line 3 column 3'}, } ]+++def test_typed_dict_namespace_mutated_during_decorators_collection() -> None:+ """Collecting decorators should not fail if the class namespace is mutated concurrently.++ On free-threaded Python, another thread can add entries (e.g. `__annotations_cache__` set by lazy+ annotations evaluation) to the class namespace while decorators are being collected. This is+ simulated here by mutating the class namespace while it is being inspected.+ """++ class Record(TypedDict):+ value: int++ class Mutator:+ armed = True++ @property+ def __class__(self) -> type:+ # Accessed by `isinstance()` checks performed during decorators collection:+ if Mutator.armed:+ Mutator.armed = False+ setattr(Record, 'added_concurrently', 1)+ return Mutator++ setattr(Record, 'mutator', Mutator())++ assert TypeAdapter(Record).validate_python({'value': '42'}) == {'value': 42}+ assert not Mutator.armed+++@pytest.mark.skipif(sys.platform == 'emscripten', reason='no threading on emscripten')+def test_concurrent_type_adapter_construction_for_typed_dict() -> None:+ """Concurrent `TypeAdapter` creation for the same new `TypedDict` should not raise on free-threaded Python."""++ 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) -> 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()
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)