Backtestspydanticrun-20260923-170312#13419
"dictionary changed size during iteration" during model_rebuild
The merged fix was judged better than our patch.
In this judgment, Patch B = our agent, Patch A = the merged fix.
Patch A fixes the root cause; Patch B only masks the two visible symptoms. The reported issue has three intertwined manifestations of one underlying problem: model_rebuild() is not thread-safe — it mutates class attributes (delattr/setattr of __pydantic_core_schema__/__pydantic_validator__/__pydantic_serializer__) while other threads read those same attributes and iterate vars(cls) during annotation evaluation. This yields (1) 'dictionary changed size during iteration', (2) the intermittent 'no attribute __pydantic_core_schema__' AttributeError, and (3) the noted data-corruption risk of a parent's validator being reused. Patch A introduces a global reentrant lock serializing all rebuilds, so no thread mutates the class __dict__ while another rebuild reads/iterates it — closing all three at their source. The reentrancy (nested rebuild during generic parametrization in __class_getitem__) and global-not-per-class rationale (to avoid deadlock) are correctly reasoned, and the double-checked-locking with an unlocked fast-path plus in-lock recheck is careful and correct. It also adds MockCoreSchema to the mock check and mirrors the guard in dataclasses.py for consistency. Patch B (a) snapshots vars(typ).copy() to dodge the iteration error and (b) wraps delattr in try/except AttributeError — but leaves the fundamental non-thread-safety intact: two threads can still run complete_model_class concurrently, racing on setattr of the validator/serializer, so an instantiating thread can still observe a half-built or parent validator. It patches symptoms 1 and 2 while symptom 3 (which the existing in-code comment already flags) persists. On tests, A's are decisively stronger: a deterministic event-coordinated two-thread test that proves the lock serializes and that the waiting thread returns None without re-firing the on_complete hook, plus a reentrancy regression test — versus B's stochastic 15-second hammer loop whose passing is probabilistic and weakly diagnostic. A's method re-indentation adds churn, but it is inherent to wrapping the body in a `with` block and is justified. Correctness, tests, and craft all favor A.
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
12m 37s12 turns
Wall-clock time in the container
Full test suite
No new failures
6,414 passed · 368 skipped · 6,782 total
Contamination audit
Unknown
See the audit notes for this run
Patch size
132vs 168 merged
Changed lines, ours vs merged
The issue
View on GitHubInitial Checks
- I confirm that I'm using Pydantic V2
Description
This just hit us in production:
Traceback (most recent call last):
...
File "fastapi/routing.py", line 120, in app
response = await f(request)
File "fastapi/routing.py", line 674, in app
raw_response = await run_endpoint_function(
File "fastapi/routing.py", line 330, in run_endpoint_function
return await run_in_threadpool(dependant.call, **values)
File "starlette/concurrency.py", line 34, in run_in_threadpool
return await anyio.to_thread.run_sync(func)
File "anyio/to_thread.py", line 63, in run_sync
return await get_async_backend().run_sync_in_worker_thread(
File "anyio/_backends/_asyncio.py", line 2518, in run_sync_in_worker_thread
return await future
File "anyio/_backends/_asyncio.py", line 1002, in run
result = context.run(func, *args)
...
File "...", line 157, in ...
MyPydanticClass(
File "pydantic/_internal/_mock_val_ser.py", line 165, in handler
if cls.model_rebuild(raise_errors=False, _parent_namespace_depth=5) is not False:
File "pydantic/main.py", line 683, in model_rebuild
return _model_construction.complete_model_class(
File "pydantic/_internal/_model_construction.py", line 642, in complete_model_class
cls.__pydantic_fields__, cls.__pydantic_extra_info__ = rebuild_model_fields(
File "pydantic/_internal/_fields.py", line 464, in rebuild_model_fields
new_field = _recreate_field_info(
File "pydantic/_internal/_fields.py", line 502, in _recreate_field_info
ann = _typing_extra.eval_type(
File "pydantic/_internal/_typing_extra.py", line 442, in eval_type
return eval_type_backport(value, globalns, localns)
File "pydantic/_internal/_typing_extra.py", line 474, in eval_type_backport
return _eval_type_backport(value, globalns, localns, type_params)
File "pydantic/_internal/_typing_extra.py", line 511, in _eval_type_backport
return _eval_type(value, globalns, localns, type_params)
File "pydantic/_internal/_typing_extra.py", line 543, in _eval_type
evaluated = typing._eval_type( # type: ignore
File "typing.py", line 461, in _eval_type
return evaluate_forward_ref(t, globals=globalns, locals=localns,
File "typing.py", line 1000, in evaluate_forward_ref
value = forward_ref.evaluate(globals=globals, locals=locals,
File "annotationlib.py", line 207, in evaluate
return eval(code, globals=globals, locals=locals)
File "<string>", line 1, in <module>
from __future__ import annotations
File "pydantic/_internal/_namespace_utils.py", line 97, in __getitem__
return self.data[key]
File "functools.py", line 1126, in __get__
val = self.func(instance)
File "pydantic/_internal/_namespace_utils.py", line 91, in data
return {k: v for ns in self._namespaces for k, v in ns.items()}
RuntimeError: dictionary changed size during iteration
Reproducer below.
Example Code
"""
NOTE: Repro script generated with Claude Fable
Repro: concurrent lazy `model_rebuild()` raises
`RuntimeError: dictionary changed size during iteration`.
Setup: a module using `from __future__ import annotations` defines models whose
field types are only defined *later* in the same module. Building such a model's
schema fails during class creation, so pydantic leaves it incomplete (mock
validator) and defers the build to the first instantiation via
`model_rebuild(raise_errors=False)`.
If the first instantiations happen concurrently (e.g. FastAPI's threadpool
serving the first requests after process start), multiple threads enter
`model_rebuild()` for the same class simultaneously. `model_rebuild()` mutates
the class `__dict__` (delattr/setattr of `__pydantic_core_schema__`,
`__pydantic_validator__`, `__pydantic_serializer__`), while
`NsResolver.types_namespace` includes the live `vars(cls)` of that class in the
`LazyLocalNamespace` another thread is iterating during annotation evaluation
(`LazyLocalNamespace.data`). Result:
RuntimeError: dictionary changed size during iteration
The same race also intermittently produces
AttributeError: type object 'Box0' has no attribute '__pydantic_core_schema__'
from the delattr block at the top of `model_rebuild()`.
Each round executes the module source into a fresh module (fresh, incomplete
classes -- like a freshly started process) and races threads instantiating the
models. Typically fires within a few dozen rounds (< 1 min).
Run: python pydantic_rebuild_race_repro.py
"""
import sys
import threading
import time
import traceback
import types
import pydantic
print(f"python {sys.version}")
print(f"pydantic {pydantic.VERSION}")
sys.setswitchinterval(1e-5) # more frequent thread preemption; widens the race window
N_GENERICS = 2 # generic origins shared by all models (parametrizing triggers origin.model_rebuild)
N_LEAVES = 16 # leaf models, defined at the end of the module so everything before stays incomplete
N_MODELS = 4 # top-level models, the ones instantiated by the racing threads
N_METHODS = 60 # dummy methods to enlarge each class __dict__ (the dict iterated during annotation eval)
N_THREADS = 32
ROUNDS = 200
RACE_WINDOW_S = 0.5
def make_module_source() -> str:
boxes = " | ".join(f"Box{g}[Leaf{l}]" for g in range(N_GENERICS) for l in range(N_LEAVES))
methods = [f" def method{m}(self) -> None: ..." for m in range(N_METHODS)]
lines = ["from __future__ import annotations", "from pydantic import BaseModel", ""]
# Top-level models come first: all their field types are still undefined here,
# so their schema build is deferred until first instantiation.
for i in range(N_MODELS):
lines += [f"class Model{i}(BaseModel):", f" items: list[{boxes}] = []", *methods, ""]
for g in range(N_GENERICS):
lines += [f"class Box{g}[T](BaseModel):", " value: T | None = None", " ref: Leaf0 | None = None", *methods, ""]
for l in range(N_LEAVES):
lines += [f"class Leaf{l}(BaseModel):", " x: int = 0", ""]
return "\n".join(lines)
MODULE_SOURCE = make_module_source()
errors: list[str] = []
errors_lock = threading.Lock()
def worker(barrier: threading.Barrier, model: type) -> None:
barrier.wait()
end = time.monotonic() + RACE_WINDOW_S
while time.monotonic() < end:
try:
model() # first call hits the mock validator -> lazy model_rebuild()
except Exception:
with errors_lock:
errors.append(traceback.format_exc())
for rnd in range(ROUNDS):
# Fresh module => fresh incomplete classes, like a freshly started process.
mod = types.ModuleType(f"repro_generated_{rnd}")
sys.modules[mod.__name__] = mod
exec(compile(MODULE_SOURCE, mod.__name__, "exec"), mod.__dict__)
models = [getattr(mod, f"Model{i}") for i in range(N_MODELS)]
assert not models[0].__pydantic_complete__
barrier = threading.Barrier(N_THREADS)
threads = [threading.Thread(target=worker, args=(barrier, models[i % N_MODELS])) for i in range(N_THREADS)]
for t in threads:
t.start()
for t in threads:
t.join()
hits = [tb for tb in errors if "changed size during iteration" in tb]
if hits:
print(hits[0], file=sys.stderr)
print(f"REPRODUCED in round {rnd}: RuntimeError: dictionary changed size during iteration")
sys.exit(1)
if errors:
first_line = errors[0].strip().splitlines()[-1]
print(f"round {rnd}: {len(errors)} sibling race errors (e.g. {first_line})")
errors.clear()
print("not reproduced")
Python, Pydantic & OS Version
In Prod: Ubuntu Docker, in Dev:
pydantic version: 2.13.4
pydantic-core version: 2.46.4
pydantic-core build: profile=release pgo=false
python version: 3.14.6 | packaged by conda-forge | (main, Jun 12 2026, 08:47:56) [Clang 20.1.8 ]
platform: macOS-26.5.1-arm64-arm-64bit-Mach-O
related packages: pyright-1.1.410 fastapi-0.136.3 pydantic-extra-types-2.11.1 email-validator-2.3.0 pydantic-settings-2.14.1 typing_extensions-4.15.0
commit: unknownThe two patches
pydantic/_internal/_namespace_utils.pyindex d308f7e4..659b63d8 100644@@ -273,7 +273,15 @@ 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 an atomic snapshot of the class `__dict__` rather than appending the live+ # `mappingproxy`. `LazyLocalNamespace.data` lazily iterates this mapping, and a+ # concurrent `model_rebuild()` in another thread may mutate the same class `__dict__`+ # (e.g. delattr/setattr of `__pydantic_core_schema__`, `__pydantic_validator__`, etc.),+ # which would otherwise raise `RuntimeError: dictionary changed size during iteration`.+ # `mappingproxy.copy()` delegates to `dict.copy`, a single GIL-held C operation, so it+ # yields a stable snapshot. Only pydantic-internal attributes are mutated during rebuild,+ # and those aren't needed for annotation evaluation, so snapshotting is safe here.+ 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})pydantic/main.pyindex 758a839c..06e2be72 100644@@ -693,7 +693,12 @@ class BaseModel(metaclass=_model_construction.ModelMetaclass): # pydantic-core. We do so only if they aren't mock instances, otherwise — as `model_rebuild()` # isn't thread-safe — concurrent model instantiations can lead to the parent validator being used. # Same applies for the core schema that can be reused in schema generation.- delattr(cls, attr)+ try:+ delattr(cls, attr)+ except AttributeError:+ # As `model_rebuild()` isn't thread-safe, a concurrent `model_rebuild()`+ # for the same class may have already removed the attribute.+ pass if _types_namespace is not None: rebuild_ns = _types_namespacetests/test_edge_cases.pyindex 3e8e38e7..a2dde3d2 100644@@ -3130,6 +3130,121 @@ def test_validator_and_serializer_not_reused_during_rebuild() -> None: assert m.model_dump() == {} +def test_concurrent_lazy_model_rebuild_no_dict_mutation_error() -> None:+ """Regression test for a concurrency bug in the lazy `model_rebuild()` path.++ When several threads trigger the lazy `model_rebuild()` of the same incomplete+ model concurrently (e.g. a FastAPI threadpool serving its first requests after+ startup), `NsResolver.types_namespace` appends the *live* `vars(typ)`+ (a mapping proxy over the class `__dict__`) into a `LazyLocalNamespace`, which+ later iterates it. Meanwhile another thread's `model_rebuild()` mutates that same+ class `__dict__` (delattr/setattr of `__pydantic_core_schema__` &co.), so the+ iteration raises ``RuntimeError: dictionary changed size during iteration``.++ We reproduce it by building fresh, initially-incomplete models (their field types+ are defined *later* in the module, so the schema build is deferred to first+ instantiation) and hammering them from many threads.+ """+ import textwrap+ import threading+ import time+ import traceback+ import types++ # Build a module source in which the top-level models reference generic boxes and+ # leaf types that are defined *later*, so the models start incomplete and defer+ # their schema build to first instantiation. Lots of dummy methods enlarge each+ # class `__dict__` to widen the race window.+ def _dummy_methods(n: int) -> str:+ return '\n'.join(+ textwrap.indent(f'def _dummy_{i}(self):\n return {i}', ' ') for i in range(n)+ )++ n_models = 8+ n_methods = 50+ model_defs = '\n\n'.join(+ textwrap.dedent(+ f"""+ class Top{i}(BaseModel):+ a: 'Box[Leaf{i}]'+ b: 'Leaf{i}'+ c: int+ {{methods}}+ """+ ).format(methods=_dummy_methods(n_methods))+ for i in range(n_models)+ )+ leaf_defs = '\n\n'.join(+ f'class Leaf{i}(BaseModel):\n x: int = {i}\n' + _dummy_methods(n_methods)+ for i in range(n_models)+ )+ module_source = (+ 'from __future__ import annotations\n'+ 'from typing import Generic, TypeVar\n'+ 'from pydantic import BaseModel\n'+ 'T = TypeVar("T")\n\n'+ + model_defs+ + '\n\n'+ + 'class Box(BaseModel, Generic[T]):\n value: T\n'+ + _dummy_methods(n_methods)+ + '\n\n'+ + leaf_defs+ + '\n'+ )+ code = compile(module_source, '<concurrent_rebuild_test>', 'exec')++ old_switch = sys.getswitchinterval()+ sys.setswitchinterval(1e-5)+ errors_seen: list[str] = []+ try:+ deadline = time.monotonic() + 15.0+ round_num = 0+ while time.monotonic() < deadline and not errors_seen:+ round_num += 1+ module = types.ModuleType(f'_concurrent_rebuild_mod_{round_num}')+ sys.modules[module.__name__] = module+ try:+ exec(code, module.__dict__)++ model = getattr(module, f'Top{round_num % n_models}')+ # Sanity: the model must start incomplete so instantiation triggers the+ # lazy rebuild we are racing on.+ assert model.__pydantic_complete__ is False++ n_threads = 24+ barrier = threading.Barrier(n_threads)++ def worker() -> None:+ barrier.wait()+ stop = time.monotonic() + 0.4+ while time.monotonic() < stop:+ try:+ model(a={'value': {'x': 1}}, b={'x': 2}, c=3)+ except RuntimeError:+ errors_seen.append(traceback.format_exc())+ return+ except AttributeError as e:+ if '__pydantic_core_schema__' in str(e):+ errors_seen.append(traceback.format_exc())+ return+ raise++ threads = [threading.Thread(target=worker) for _ in range(n_threads)]+ for t in threads:+ t.start()+ for t in threads:+ t.join()+ finally:+ sys.modules.pop(module.__name__, None)+ finally:+ sys.setswitchinterval(old_switch)++ assert not any('changed size during iteration' in tb for tb in errors_seen), (+ 'Concurrent lazy model_rebuild raced on the class __dict__:\n' + '\n'.join(errors_seen)+ )+ assert not errors_seen, 'Unexpected concurrency error during model instantiation:\n' + '\n'.join(errors_seen)++ @pytest.mark.filterwarnings('ignore:.*`__get_validators__`.*:DeprecationWarning') def test_get_schema_on_classes_with_both_v1_and_v2_apis() -> None: class Model(BaseModel):
pydantic/dataclasses.pyindex 62d380f54..474289ec3 100644@@ -330,9 +330,13 @@ def rebuild_dataclass( return None for attr in ('__pydantic_core_schema__', '__pydantic_validator__', '__pydantic_serializer__'):- if attr in cls.__dict__ and not isinstance(getattr(cls, attr), _mock_val_ser.MockValSer):+ 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+ # (e.g. when instantiating the dataclass in another thread) can resolve them from the parent class. delattr(cls, attr) cls.__pydantic_complete__ = Falsepydantic/main.pyindex 758a839c6..6bb1554e5 100644@@ -8,6 +8,7 @@ from __future__ import annotations as _annotations import operator import sys+import threading import types import warnings from collections.abc import Generator, Mapping@@ -78,6 +79,18 @@ IncEx: TypeAlias = set[int] | set[str] | Mapping[int, Union['IncEx', bool]] | Ma _object_setattr = _model_construction.object_setattr +_rebuild_lock = threading.RLock()+"""+A lock used to make model rebuilds thread-safe when first instantiating an incomplete model.++Rebuilding a model isn't thread-safe (the class attributes are mutated during the rebuild,+while other threads may be reading them to perform validation/serialization), so `model_rebuild()`+calls are serialized using this lock. The lock is reentrant, as rebuilding a model can trigger the+rebuild of another one (e.g. when a generic origin is rebuilt during parametrization in+`__class_getitem__()`). For the same reason, the lock is global and not per-class: two threads+holding their own class's lock could otherwise request the other's and deadlock.+"""+ def _check_frozen(model_cls: type[BaseModel], name: str, value: Any) -> None: if model_cls.model_config.get('frozen'):@@ -681,42 +694,54 @@ class BaseModel(metaclass=_model_construction.ModelMetaclass): Returns `None` if the schema is already "complete" and rebuilding was not required. If rebuilding _was_ required, returns `True` if rebuilding was successful, otherwise `False`. """- already_complete = cls.__pydantic_complete__- if already_complete and not force:+ # As the rebuild lock is global (not per model class), avoid needlessly holding it if the model is+ # already complete:+ if cls.__pydantic_complete__ and not force: return None - cls.__pydantic_complete__ = False+ with _rebuild_lock:+ # Re-check inside the lock, as another thread may have rebuilt the model while we were waiting:+ already_complete = cls.__pydantic_complete__+ if already_complete and not force:+ return None - for attr in ('__pydantic_core_schema__', '__pydantic_validator__', '__pydantic_serializer__'):- if attr in cls.__dict__ and not isinstance(getattr(cls, attr), _mock_val_ser.MockValSer):- # Deleting the validator/serializer is necessary as otherwise they can get reused in- # pydantic-core. We do so only if they aren't mock instances, otherwise — as `model_rebuild()`- # isn't thread-safe — concurrent model instantiations can lead to the parent validator being used.- # Same applies for the core schema that can be reused in schema generation.- delattr(cls, attr)+ cls.__pydantic_complete__ = False - if _types_namespace is not None:- rebuild_ns = _types_namespace- elif _parent_namespace_depth > 0:- rebuild_ns = _typing_extra.parent_frame_namespace(parent_depth=_parent_namespace_depth, force=True) or {}- else:- rebuild_ns = {}+ 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 _types_namespace is not None:+ rebuild_ns = _types_namespace+ elif _parent_namespace_depth > 0:+ rebuild_ns = (+ _typing_extra.parent_frame_namespace(parent_depth=_parent_namespace_depth, force=True) or {}+ )+ else:+ rebuild_ns = {} - parent_ns = _model_construction.unpack_lenient_weakvaluedict(cls.__pydantic_parent_namespace__) or {}+ parent_ns = _model_construction.unpack_lenient_weakvaluedict(cls.__pydantic_parent_namespace__) or {} - ns_resolver = _namespace_utils.NsResolver(- parent_namespace={**rebuild_ns, **parent_ns},- )+ ns_resolver = _namespace_utils.NsResolver(+ parent_namespace={**rebuild_ns, **parent_ns},+ ) - return _model_construction.complete_model_class(- cls,- _config.ConfigWrapper(cls.model_config, check=False),- ns_resolver,- raise_errors=raise_errors,- # If the model was already complete, we don't need to call the hook again.- call_on_complete_hook=not already_complete,- is_force_rebuild=force,- )+ return _model_construction.complete_model_class(+ cls,+ _config.ConfigWrapper(cls.model_config, check=False),+ ns_resolver,+ raise_errors=raise_errors,+ # If the model was already complete, we don't need to call the hook again.+ call_on_complete_hook=not already_complete,+ is_force_rebuild=force,+ ) @classmethod def model_validate(tests/test_main.pyindex c87dae793..f924cec99 100644@@ -2,6 +2,7 @@ import json import platform import re import sys+import threading import typing import warnings from collections import defaultdict@@ -2541,6 +2542,84 @@ def test_model_rebuild_localns(): C.model_rebuild(_types_namespace={'A': A}) +@pytest.mark.timeout(5)+def test_model_rebuild_nested_during_parametrization():+ T = TypeVar('T')++ class Model(BaseModel):+ b: Optional['Box[Leaf]'] = None++ class Box(BaseModel, Generic[T]):+ leaf: Optional['Leaf'] = None++ class Leaf(BaseModel):+ x: int = 0++ assert not Model.__pydantic_complete__+ assert not Box.__pydantic_complete__++ # Rebuilding `Model` evaluates `Box[Leaf]`, and `__class_getitem__` then calls+ # `Box.model_rebuild()` on the same thread. Any locking added to the rebuild logic+ # must support this reentrancy:+ m = Model(b={'leaf': {'x': 1}})+ assert m.b.leaf.x == 1+ assert Model.__pydantic_complete__+++@pytest.mark.skipif(sys.platform == 'emscripten', reason='no threading on emscripten')+def test_model_rebuild_already_rebuilt_by_other_thread():+ schema_gen_entered = threading.Event()+ resume_schema_gen = threading.Event()+ hook_calls: list[type] = []++ class Model(BaseModel):+ x: 'Gate'++ @classmethod+ def __pydantic_on_complete__(cls) -> None:+ hook_calls.append(cls)++ class Gate:+ @classmethod+ def __get_pydantic_core_schema__(cls, source_type, handler):+ schema_gen_entered.set()+ resume_schema_gen.wait(timeout=10)+ return core_schema.int_schema()++ assert not Model.__pydantic_complete__++ results: dict[str, bool | None] = {}+ t2_started = threading.Event()++ def rebuild(key: str) -> None:+ if key == 't2':+ t2_started.set()+ results[key] = Model.model_rebuild(_types_namespace={'Gate': Gate})++ # The first thread acquires the rebuild lock and waits in schema generation:+ t1 = threading.Thread(target=rebuild, args=('t1',), daemon=True)+ t1.start()+ assert schema_gen_entered.wait(timeout=10)++ # While the first thread is waiting on `resume_schema_gen`, `Model` can't become complete,+ # so the second thread is guaranteed to pass the unlocked completeness check and block on the lock:+ t2 = threading.Thread(target=rebuild, args=('t2',), daemon=True)+ t2.start()+ assert t2_started.wait(timeout=10)+ assert t2.is_alive()+ assert 't2' not in results++ resume_schema_gen.set()+ t1.join(timeout=10)+ t2.join(timeout=10)+ assert not t1.is_alive()+ assert not t2.is_alive()++ assert results == {'t1': True, 't2': None}+ assert hook_calls == [Model]+ assert Model(x=1).x == 1++ def test_model_rebuild_zero_depth(): class Model(BaseModel): x: 'X_Type'
What the agent reported
All stages complete. The reviewer's two robustness concerns were already addressed during development: the test-writer confirmed the test fails reliably on the unpatched tree (reproduces on round 1, ~5s) and passes post-fix, and the ~15s deadline is the deliberate, bounded cost of a timing-dependent race reproducer.
Summary
What was wrong
Concurrent lazy model_rebuild() of the same incomplete model raced against itself:
NsResolver.types_namespace(pydantic/_internal/_namespace_utils.py:276) stored the livevars(typ)mappingproxy inLazyLocalNamespace.LazyLocalNamespace.dataiterates it lazily vians.items(), while another thread'smodel_rebuild()mutated the same class__dict__(delattr/setattr of__pydantic_*__) →RuntimeError: dictionary changed size during iteration.- The report's secondary symptom:
model_rebuildatpydantic/main.py:696diddelattr(cls, attr)after anattr in cls.__dict__check; a concurrent rebuild removing the attribute in between raisedAttributeError: ... has no attribute '__pydantic_core_schema__'.
What I changed
pydantic/_internal/_namespace_utils.py: appendvars(typ).copy()instead of the live mappingproxy.mappingproxy.copy()delegates todict.copy— a single GIL-held C operation — so it yields an atomic, stable snapshot. Only pydantic-internal attributes are mutated during rebuild, none needed for annotation evaluation, so snapshotting is semantically safe.pydantic/main.py: wrapped the guardeddelattr(cls, attr)intry/except AttributeError: passto tolerate a concurrent rebuild having already removed the attribute. The pre-existingif attr in cls.__dict__guard means the only path to thatAttributeErroris the race, so no legitimate error is swallowed.tests/test_edge_cases.py: addedtest_concurrent_lazy_model_rebuild_no_dict_mutation_error, a threaded regression test modeled on the report's reproducer (fresh incomplete models exec'd per round, 24 threads on a barrier,setswitchinterval(1e-5)), asserting no "changed size during iteration" RuntimeError and no spurious__pydantic_core_schema__AttributeError.
Test evidence
- Pre-fix: test fails on round 1 (~5s) with the exact
RuntimeError: dictionary changed size during iterationat_namespace_utils.py:91. After fix #1 only, it then surfaced the secondaryAttributeError, motivating fix #2. - Post-both-fixes gate:
./bt-test tests/test_edge_cases.py::test_concurrent_lazy_model_rebuild_no_dict_mutation_error tests/test_forward_ref.py tests/test_edge_cases.py::test_validator_and_serializer_not_reused_during_rebuild→ 69 passed, 4 xfailed. Regression test now ~15s.
Requirements disposition
- Confirm using Pydantic V2 — checklist item, informational; no action needed.
- Fix
RuntimeError: dictionary changed size during iterationunder concurrentmodel_rebuild— implemented (_namespace_utils.py), with a failing-before/passing-after regression test. - Also-reported
AttributeError: ... '__pydantic_core_schema__'from the delattr block ("the same race") — implemented (main.py); the regression test asserts against it and passes. - Reproducer script scenario — exercised by the added regression test, which reproduces on the unpatched tree and passes after the fix.
Changes are left uncommitted in the working tree.