Backtestspydanticrun-20260923-170312#13419

Issue #13419 Merged fix PR # Run 23 Sep 2026 · run-20260923-170312 pydantic/pydantic

"dictionary changed size during iteration" during model_rebuild

Worse

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

Initial 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: unknown

The two patches

Our patch+130 −2
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): 
Merged fix · PR #+138 −30
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:

  1. NsResolver.types_namespace (pydantic/_internal/_namespace_utils.py:276) stored the live vars(typ) mappingproxy in LazyLocalNamespace. LazyLocalNamespace.data iterates it lazily via ns.items(), while another thread's model_rebuild() mutated the same class __dict__ (delattr/setattr of __pydantic_*__) → RuntimeError: dictionary changed size during iteration.
  2. The report's secondary symptom: model_rebuild at pydantic/main.py:696 did delattr(cls, attr) after an attr in cls.__dict__ check; a concurrent rebuild removing the attribute in between raised AttributeError: ... has no attribute '__pydantic_core_schema__'.

What I changed

  • pydantic/_internal/_namespace_utils.py: append vars(typ).copy() instead of the live mappingproxy. mappingproxy.copy() delegates to dict.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 guarded delattr(cls, attr) in try/except AttributeError: pass to tolerate a concurrent rebuild having already removed the attribute. The pre-existing if attr in cls.__dict__ guard means the only path to that AttributeError is the race, so no legitimate error is swallowed.
  • tests/test_edge_cases.py: added test_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 iteration at _namespace_utils.py:91. After fix #1 only, it then surfaced the secondary AttributeError, 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 iteration under concurrent model_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.