Backtestspydanticrun-20260930-183947#13419

Issue #13419 Merged fix PR #13438 Run 30 Sep 2026 · run-20260930-183947 pydantic/pydantic

"dictionary changed size during iteration" during model_rebuild

Better

Our patch was judged better than the merged fix.

In this judgment, Patch A = our agent, Patch B = the merged fix.

Patch A fixes the reported failure at the point where it happens. `LazyLocalNamespace.data` now builds its merged dict from `.copy()` snapshots of the live `dict` or `mappingproxy` namespaces. The copy is a single C-level operation, so it cannot hit 'dictionary changed size during iteration'. The same snapshot is applied to `_decorator_infos_for_class`. A also fixes the sibling `AttributeError` race the issue mentions: the mock check now reads `cls.__dict__.get(attr)` instead of `getattr`, and `delattr` is wrapped in a try/except, in both `model_rebuild` and `rebuild_dataclass`. Its tests target the bug directly. One mutates a class dict from another thread while building `LazyLocalNamespace`, which would fail before the fix. Another is a scaled-down version of the issue's own concurrent deferred-rebuild reproducer. Two deterministic metaclass tests simulate the concurrent delattr. Patch B instead puts a global reentrant lock around `model_rebuild`, with a double-checked completeness test. This probably prevents the reported race, because the nested `Box.model_rebuild()` triggered by `__class_getitem__` re-enters on the same thread while other threads block. But it is a broader design change with more risk. It serializes every model rebuild process-wide. It can deadlock if user `__get_pydantic_core_schema__` code waits on another thread that rebuilds a model. It leaves `rebuild_dataclass` and other class-dict mutation paths unlocked. B's tests check reentrancy and the double-check behavior, but none reproduces the dictionary-iteration error or the delattr `AttributeError`. A is the more targeted, lower-risk fix with stronger regression tests.

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 15s

Wall-clock time in the container

Full test suite

No new failures

12,263 passed · 501 skipped · 12,764 total

Contamination audit

Clean

No sign the agent saw the real fix

Patch size

150vs 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+144 −6
pydantic/_internal/_decorators.pyindex 3b8f847e..f954ec37 100644@@ -502,7 +502,8 @@ 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, as the class namespace can be mutated concurrently (e.g. by `model_rebuild()`):+    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 d308f7e4..46b34b10 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()}+        data: dict[str, Any] = {}+        for ns in self._namespaces:+            # The namespaces can be live mappings (e.g. `vars(cls)` of a class being rebuilt in another thread),+            # so we take an atomic snapshot using `copy()` instead of iterating over them directly:+            data.update(ns.copy() if isinstance(ns, (dict, MappingProxyType)) else ns)+        return data      def __len__(self) -> int:         return len(self.data)pydantic/dataclasses.pyindex 62d380f5..52fd3fd6 100644@@ -330,10 +330,14 @@ 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(cls.__dict__.get(attr), _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.-            delattr(cls, attr)+            try:+                delattr(cls, attr)+            except AttributeError:+                # The attribute was concurrently deleted by a `rebuild_dataclass()` call in another thread.+                pass      cls.__pydantic_complete__ = False pydantic/main.pyindex 758a839c..b27dfbb5 100644@@ -688,12 +688,16 @@ 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.MockValSer):+            if attr in cls.__dict__ and not isinstance(cls.__dict__.get(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)+                try:+                    delattr(cls, attr)+                except AttributeError:+                    # The attribute was concurrently deleted by a `model_rebuild()` call in another thread.+                    pass          if _types_namespace is not None:             rebuild_ns = _types_namespacetests/test_dataclasses.pyindex a32bc7ae..4e9e79ea 100644@@ -2618,6 +2618,23 @@ def test_rebuild_dataclass():     assert MyDataClass2.__pydantic_complete__  +def test_rebuild_dataclass_concurrent_attribute_deletion() -> None:+    """Simulate another thread deleting the core schema, validator and serializer during `rebuild_dataclass()`."""++    class RacingMeta(type):+        def __delattr__(cls, name: str) -> None:+            # Another thread deletes the attribute first:+            super().__delattr__(name)+            super().__delattr__(name)++    @pydantic.dataclasses.dataclass+    class MyDataClass(metaclass=RacingMeta):+        x: int++    assert rebuild_dataclass(MyDataClass, force=True) is True+    assert dataclasses.asdict(MyDataClass(x='1')) == {'x': 1}++ @pytest.mark.parametrize(     'dataclass_decorator',     [tests/test_forward_ref.pyindex 9b0325d2..32869ddf 100644@@ -2,6 +2,8 @@ import dataclasses import platform import re import sys+import threading+import time import typing from typing import Annotated, Any, Generic, Optional, TypeVar, Union @@ -1144,6 +1146,94 @@ def test_lazy_local_namespace_len() -> None:     assert len(namespace) == 2  +def test_lazy_local_namespace_concurrent_class_mutation() -> None:+    """The class namespace can be mutated by another thread (e.g. during `model_rebuild()`)+    while it is being merged in a `LazyLocalNamespace`."""++    cls = type('Cls', (), {f'attr_{i}': i for i in range(200)})+    stop = threading.Event()++    def mutate() -> None:+        # Continuously grow the class namespace:+        i = 0+        while not stop.is_set() and i < 100_000:+            setattr(cls, f'tmp_{i}', i)+            i += 1++    old_switch_interval = sys.getswitchinterval()+    sys.setswitchinterval(1e-6)+    thread = threading.Thread(target=mutate)+    thread.start()+    try:+        end = time.monotonic() + 0.5+        while time.monotonic() < end:+            namespace = LazyLocalNamespace({'a': int}, vars(cls))+            assert namespace['attr_0'] == 0+            assert namespace['a'] is int+    finally:+        stop.set()+        thread.join()+        sys.setswitchinterval(old_switch_interval)+++def test_concurrent_deferred_model_rebuild(create_module) -> None:+    """Instantiating models whose schema build was deferred from multiple threads at the same time+    triggers concurrent `model_rebuild()` calls, which should not fail."""++    source = '\n'.join(+        [+            'from __future__ import annotations',+            'from typing import Generic, TypeVar',+            'from pydantic import BaseModel',+            '',+            'class Model(BaseModel):',+            '    items: list[Box[Leaf0] | Box[Leaf1] | Leaf0] = []',+            *(f'    def method_{i}(self) -> None: ...' for i in range(60)),+            '',+            'T = TypeVar("T")',+            'class Box(BaseModel, Generic[T]):',+            '    value: T | None = None',+            '    ref: Leaf0 | None = None',+            *(f'    def method_{i}(self) -> None: ...' for i in range(60)),+            '',+            'class Leaf0(BaseModel):',+            '    x: int = 0',+            '',+            'class Leaf1(BaseModel):',+            '    y: int = 0',+        ]+    )++    old_switch_interval = sys.getswitchinterval()+    sys.setswitchinterval(1e-6)+    try:+        for _ in range(10):+            module = create_module(source)+            assert not module.Model.__pydantic_complete__++            errors: list[BaseException] = []+            barrier = threading.Barrier(8)++            def instantiate() -> None:+                barrier.wait()+                try:+                    for _ in range(20):+                        m = module.Model(items=[{'value': {'x': 1}}])+                        assert m.items[0].value.x == 1+                except BaseException as e:+                    errors.append(e)++            threads = [threading.Thread(target=instantiate) for _ in range(8)]+            for thread in threads:+                thread.start()+            for thread in threads:+                thread.join()++            assert errors == []+    finally:+        sys.setswitchinterval(old_switch_interval)++ @pytest.mark.xfail(     reason='While `get_cls_type_hints` uses the correct module ns for each base, `collect_model_fields` '     'will still use the `FieldInfo` instances from each base (see the `parent_fields_lookup` logic). 'tests/test_main.pyindex c87dae79..84390a64 100644@@ -2557,6 +2557,22 @@ def test_model_rebuild_zero_depth():     assert m.model_dump() == {'x': 42}  +def test_model_rebuild_concurrent_attribute_deletion() -> None:+    """Simulate another thread deleting the core schema, validator and serializer during `model_rebuild()`."""++    class RacingMeta(type(BaseModel)):+        def __delattr__(cls, name: str) -> None:+            # Another thread deletes the attribute first:+            super().__delattr__(name)+            super().__delattr__(name)++    class Model(BaseModel, metaclass=RacingMeta):+        x: int++    assert Model.model_rebuild(force=True) is True+    assert Model(x='1').model_dump() == {'x': 1}++ @pytest.fixture(scope='session', name='InnerEqualityModel') def inner_equality_fixture():     class InnerEqualityModel(BaseModel): 
Merged fix · PR #13438+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'