Backtestspydanticrun-20261009-110034#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: they snapshot the class namespace in `_decorator_infos_for_class` before iterating. A uses `vars(typ).copy().items()` and B uses `list(vars(typ).items())`. On free-threaded CPython, both the dict copy and the list-extend fast path for dict items run under the dict's lock, so each snapshot is atomic. Both also harden `LazyLocalNamespace.data`. A copies only `MappingProxyType` namespaces; B snapshots every namespace with `list()`. Either is adequate. The differences are in tests and scope. B adds a deterministic regression test. A `Mutating` object's `__class__` property, which `isinstance` reaches as a fallback, mutates the TypedDict's namespace during iteration. That test fails before the fix and passes after it, on any build, without depending on thread timing. B also adds stress tests that run a concurrent mutator thread. A's tests all skip unless the build is free-threaded, and they are purely probabilistic. On a standard CI build they verify nothing. A also bundles an unrelated behavioral change to `BaseModel.model_rebuild`. It replaces the selective `delattr` of the schema, validator and serializer with `set_model_mocks(cls)` when the model is already complete. This changes rebuild semantics in core model code. That is outside the issue's ask, adds regression risk and obscures the fix. B's extra hardening in `_known_annotated_metadata` is small, low-risk and covered by its own test. B wins on tests (deterministic, would fail before the fix) and on scope (no risky unrelated change).
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 8s
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
102vs 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..78cabb7d 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():+ # Snapshot the class namespace: it may be mutated concurrently (e.g. lazy annotations evaluation adding+ # `__annotations_cache__` on free-threaded Python), which would otherwise make the iteration fail:+ 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..7ee81c95 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()}+ # Namespaces can be class namespaces (`vars(cls)`), which may be mutated concurrently+ # (e.g. on free-threaded Python), hence the snapshot with `list()`:+ 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_type_adapter.pyindex 1038a829..afd7b7f0 100644@@ -1,4 +1,8 @@ import json+import sys+import threading+from collections.abc import Callable+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 +13,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 +768,90 @@ def test_validate_json_invalid_json(): 'ctx': {'error': 'trailing comma at line 3 column 3'}, } ]+++def test_class_namespace_mutated_while_collecting_decorators() -> None:+ """The class namespace can be mutated while decorators are being collected.++ On free-threaded Python, another thread can mutate the class namespace concurrently (e.g. lazy annotations+ evaluation adding `__annotations_cache__`). This is reproduced deterministically here by mutating the class+ when its attributes are inspected.+ """++ class Mutating:+ @property+ def __class__(self) -> type:+ setattr(Record, f'added_{len(vars(Record))}', 1)+ return Mutating++ class Record(TypedDict):+ value: int++ Record.mutating = Mutating()++ ta = TypeAdapter(Record)+ assert ta.validate_python({'value': '42'}) == {'value': 42}+++def _run_concurrently(target: Callable[[], None], mutate: Callable[[int], None], n_threads: int = 8) -> None:+ barrier = threading.Barrier(n_threads + 1, timeout=30)+ stop = threading.Event()++ def mutator() -> None:+ barrier.wait()+ i = 0+ while not stop.is_set():+ mutate(i)+ i += 1++ def worker(_: int) -> None:+ barrier.wait()+ target()++ mutator_thread = threading.Thread(target=mutator)+ mutator_thread.start()+ try:+ with ThreadPoolExecutor(max_workers=n_threads) as executor:+ list(executor.map(worker, range(n_threads)))+ finally:+ stop.set()+ mutator_thread.join()+++@pytest.mark.skipif(sys.platform == 'emscripten', reason='no threading on emscripten')+def test_concurrent_type_adapter_typed_dict_class_namespace_mutation() -> None:+ """https://github.com/pydantic/pydantic/issues/13780"""++ for _ in range(10):++ class Record(TypedDict):+ value: 'int'++ for index in range(1000):+ setattr(Record, f'metadata_{index}', index)++ def build(Record: type[Any] = Record) -> None:+ assert TypeAdapter(Record).validate_python({'value': '42'}) == {'value': 42}++ _run_concurrently(build, lambda i, Record=Record: setattr(Record, f'_extra_{i}', i))+++@pytest.mark.skipif(sys.platform == 'emscripten', reason='no threading on emscripten')+def test_concurrent_type_adapter_metadata_class_namespace_mutation() -> None:+ """Uninitialized `PydanticMetadata` classes have their namespace iterated to collect constraints."""++ for _ in range(10):++ class MyStrict(PydanticMetadata):+ strict = True++ for index in range(1000):+ setattr(MyStrict, f'_metadata_{index}', index)++ def build(MyStrict: type[Any] = MyStrict) -> None:+ ta = TypeAdapter(Annotated[int, MyStrict])+ assert ta.validate_python(42) == 42+ with pytest.raises(ValidationError):+ ta.validate_python('42')++ _run_concurrently(build, lambda i, MyStrict=MyStrict: setattr(MyStrict, f'_extra_{i}', i))
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)