Backtestspydanticrun-20261002-175417#13780
Concurrent TypeAdapter construction raises RuntimeError on free-threaded Python
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 same way: `_decorator_infos_for_class` iterates `vars(typ).copy().items()`. `mappingproxy.copy()` delegates to an atomic `dict.copy()`, so a concurrent insertion of `__annotations_cache__` can no longer invalidate the iterator. Both also harden the second iteration site, the lazy namespace built from `vars(typ)`. Patch A copies at iteration time in `LazyLocalNamespace.data`. Patch B snapshots at push time in `NsResolver`. Both are reasonable, and B additionally covers `collect_known_metadata`. The key difference is scope and risk. Patch A also rewrites the `model_rebuild` logic, replacing conditional `delattr` of the core schema, validator and serializer with `set_model_mocks(cls)` when `already_complete`. That is a behavioral change to `BaseModel.model_rebuild`, unrelated to the reported TypedDict/TypeAdapter race. It carries regression risk and obscures the actual fix. On tests, Patch B adds a deterministic regression test (`test_class_namespace_mutated_during_decorator_collection`). It uses an object whose `__class__` property mutates the class dict during the `isinstance` check. This fails before the fix and passes after it on any Python build, so the regression is checked in normal CI. B also adds a concurrent stress test covering TypedDict, BaseModel and `PydanticMetadata`. Patch A's tests are all skipped unless running on a free-threaded build. They are probabilistic, so they give no coverage on standard CI. Part of them (`model_rebuild` with `force` plus instantiation) test the unrelated change. Patch B delivers an equally correct fix with better, deterministic tests and no unrelated behavioral changes.
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
8m 26s
Wall-clock time in the container
Full test suite
No new failures
12,713 passed · 509 skipped · 13,222 total
Contamination audit
Clean
No sign the agent saw the real fix
Patch size
85vs 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..56259e9d 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 snapshot of the class namespace: on free-threaded Python, another thread+ # may concurrently mutate it (e.g. lazy annotations evaluation adding `__annotations_cache__`).+ # `mappingproxy.copy()` delegates to the atomic `dict.copy()`, unlike iterating the proxy 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..44a2e67a 100644@@ -370,7 +370,9 @@ 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('_')})+ # Iterate over a snapshot of the class namespace, as it may be concurrently mutated+ # on free-threaded Python (e.g. by lazy annotations evaluation):+ 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..d5d70b60 100644@@ -273,7 +273,10 @@ class NsResolver: # TypeAliasType instances don't have a `__dict__` attribute, so the check # is necessary: if hasattr(typ, '__dict__'):- locals_list.append(vars(typ))+ # Take a snapshot of the class namespace, as it is iterated over lazily (see `LazyLocalNamespace.data`)+ # and may be concurrently mutated on free-threaded Python (e.g. by lazy annotations evaluation+ # adding `__annotations_cache__`). `mappingproxy.copy()` delegates to the atomic `dict.copy()`:+ locals_list.append(vars(typ).copy()) # The `len(self._types_stack) > 1` check above prevents this from being added twice: locals_list.append({typ.__name__: typ})tests/test_decorators.pyindex 667ff813..7ce48dab 100644@@ -1,6 +1,7 @@ import pytest+from typing_extensions import TypedDict -from pydantic import BaseModel, PydanticUserError, computed_field+from pydantic import BaseModel, PydanticUserError, TypeAdapter, computed_field from pydantic._internal._decorators import inspect_annotated_serializer, inspect_field_serializer, inspect_validator @@ -138,3 +139,25 @@ def test_decorator_info_not_mutated() -> None: assert A.__pydantic_decorators__.computed_fields['func'].info.title is None assert B.__pydantic_decorators__.computed_fields['func'].info.title == 'test'+++def test_class_namespace_mutated_during_decorator_collection() -> None:+ """The class namespace can be mutated while decorators are being collected (e.g. on free-threaded+ Python, lazy annotations evaluation in another thread adds `__annotations_cache__`).++ The mutation is simulated deterministically using an object whose `__class__` lookup+ (performed by `isinstance()` during collection) adds an attribute to the class.+ """++ class Record(TypedDict):+ value: int++ class Mutator:+ @property+ def __class__(self) -> type:+ setattr(Record, f'added_{len(vars(Record))}', 1)+ return Mutator++ Record.mutator = Mutator()++ assert TypeAdapter(Record).validate_python({'value': '42'}) == {'value': 42}tests/test_type_adapter.pyindex 1038a829..d6fefa67 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@@ -9,6 +12,7 @@ from typing_extensions import TypedDict from pydantic import BaseModel, Field, TypeAdapter, ValidationInfo, create_model, field_validator from pydantic._internal import _mock_val_ser+from pydantic._internal._fields import PydanticMetadata from pydantic._internal._typing_extra import annotated_type from pydantic.config import ConfigDict from pydantic.dataclasses import dataclass as pydantic_dataclass@@ -763,3 +767,45 @@ def test_validate_json_invalid_json(): 'ctx': {'error': 'trailing comma at line 3 column 3'}, } ]+++@pytest.mark.thread_unsafe(reason='Spawns its own threads')+@pytest.mark.skipif(sys.platform == 'emscripten', reason='no threading on emscripten')+def test_concurrent_type_adapter_construction() -> None:+ """Concurrently building schemas for the same new types must not fail, even if the class namespaces+ are mutated by another thread meanwhile (e.g. on free-threaded Python, where lazy annotations+ evaluation adds `__annotations_cache__`).++ Covers decorators collection, the types namespace used to evaluate forward annotations+ and uninitialized `PydanticMetadata` classes used as `Annotated` metadata.+ """+ n_threads = 8++ def run_round() -> None:+ class Record(TypedDict):+ value: 'int'++ class Model(BaseModel):+ value: 'int'++ class StrictMeta(PydanticMetadata):+ strict = True++ for cls in (Record, Model, StrictMeta):+ for index in range(1000):+ setattr(cls, f'_metadata_{index}', index)++ barrier = threading.Barrier(n_threads)++ def build(_: int) -> None:+ barrier.wait()+ assert TypeAdapter(Record).validate_python({'value': '42'}) == {'value': 42}+ assert TypeAdapter(Model).validate_python({'value': '42'}).value == 42+ with pytest.raises(ValidationError):+ TypeAdapter(Annotated[int, StrictMeta]).validate_python('42')++ with ThreadPoolExecutor(max_workers=n_threads) as executor:+ list(executor.map(build, range(n_threads)))++ 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)