Backtestspydanticrun-20261005-183002#13419

Issue #13419 Merged fix PR #13438 Run 5 Oct 2026 · run-20261005-183002 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. The race comes from several threads running `model_rebuild()` on the same class at once: one thread mutates the class `__dict__` (delattr/setattr of the schema, validator and serializer) while another iterates `vars(cls)` inside `LazyLocalNamespace.data` during annotation evaluation. A wraps the rebuild body in a global reentrant lock and re-checks `__pydantic_complete__` inside the lock. That serializes rebuilds and ensures only one thread completes the model, so the on-complete hook runs once. The lock is reentrant because a rebuild can trigger a nested rebuild through generic parametrization (`__class_getitem__` → origin `model_rebuild`). It is global rather than per-class, which avoids cross-class deadlocks, and the comments explain both choices. A also stops deleting `MockCoreSchema` instances, closing the window where concurrent readers fall back to the parent's attributes. That removes the sibling `AttributeError` race the issue mentions. Its two tests are well designed. One checks that reentrant nested rebuilds don't deadlock. The other uses events to force a second thread to block on the lock and then return `None` once the first thread completes the model, with the hook called exactly once. That is a deterministic test of the new concurrency contract, not a probabilistic stress test.

Patch B treats the symptoms. It snapshots the namespaces with C-level `dict.copy()` in `LazyLocalNamespace.data` and in `_decorator_infos_for_class`, and it swallows `AttributeError` around `delattr`. That suppresses the two reported exceptions, but concurrent rebuilds still run in parallel and mutate class state under each other. B's own test admits this: it says `model_rebuild()` 'isn't fully thread-safe' and that a validator can temporarily fall back to the `BaseModel` mock. The test then filters the collected errors down to only the two reported messages, so other failures from the same race are hidden. B also relies on `dict.copy()` being effectively atomic under the GIL, which is not guaranteed on free-threaded builds. Finally, it adds `try/except` blocks that hide real concurrent deletes instead of preventing them. B's stress tests are closer to the issue's reproducer, but they are probabilistic and narrowly filtered.

On correctness, which carries the most weight, A addresses the actual unsynchronized-rebuild bug, while B only masks the visible exceptions.

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

11m 23s

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

234vs 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+228 −6
pydantic/_internal/_decorators.pyindex 3b8f847e..34b8dadf 100644@@ -502,7 +502,9 @@ 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 copy, as the class namespace can be mutated concurrently+    # (e.g. by a `model_rebuild()` call from another thread):+    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..e3e1b4e9 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,14 @@ 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, shared mappings (e.g. the `vars()` of a class, which+            # can be mutated concurrently by a `model_rebuild()` call from another thread).+            # Iterating over them in Python code could then raise a `RuntimeError` (dictionary+            # changed size during iteration), so we take a snapshot using the C-level `copy()`.+            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..94b45be0 100644@@ -330,10 +330,15 @@ 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, None), _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 already removed by a concurrent `rebuild_dataclass()` call+                # from another thread, which is the state we want here.+                pass      cls.__pydantic_complete__ = False pydantic/main.pyindex 758a839c..cc0f567f 100644@@ -688,12 +688,17 @@ 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(getattr(cls, attr, None), _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 already removed by a concurrent `model_rebuild()` call+                    # from another thread, which is the state we want here.+                    pass          if _types_namespace is not None:             rebuild_ns = _types_namespacetests/test_concurrent_rebuild.pynew file mode 100644index 00000000..ebfeb365@@ -0,0 +1,202 @@+"""Tests for concurrent (multi-threaded) schema rebuilds.++See https://github.com/pydantic/pydantic/issues/13419: when incomplete models are first+instantiated concurrently, multiple threads call `model_rebuild()` for the same class.+"""++import sys+import threading+import time+import traceback+import types+from collections.abc import Callable, Iterator+from contextlib import contextmanager+from typing import Any++import pytest++from pydantic import BaseModel+from pydantic._internal._namespace_utils import LazyLocalNamespace+from pydantic.dataclasses import dataclass, rebuild_dataclass++# These tests spawn their own threads and alter the (global) thread switch interval:+pytestmark = pytest.mark.thread_unsafe(reason='Tests spawn threads and mutate the thread switch interval')++N_THREADS = 16+RACE_WINDOW_S = 0.3+++@contextmanager+def _frequent_thread_switches() -> Iterator[None]:+    # More frequent thread preemption, to widen the race windows:+    old_interval = sys.getswitchinterval()+    sys.setswitchinterval(1e-6)+    try:+        yield+    finally:+        sys.setswitchinterval(old_interval)+++def _race(targets: list[Callable[[], Any]], *, rounds: int = 1) -> list[str]:+    """Run each target repeatedly in its own thread for `RACE_WINDOW_S`, and return the collected tracebacks."""+    errors: list[str] = []+    errors_lock = threading.Lock()++    def worker(barrier: threading.Barrier, target: Callable[[], Any]) -> None:+        barrier.wait()+        end = time.monotonic() + RACE_WINDOW_S+        while time.monotonic() < end:+            try:+                target()+            except Exception:+                with errors_lock:+                    errors.append(traceback.format_exc())++    with _frequent_thread_switches():+        for _ in range(rounds):+            barrier = threading.Barrier(len(targets))+            threads = [threading.Thread(target=worker, args=(barrier, target)) for target in targets]+            for t in threads:+                t.start()+            for t in threads:+                t.join()+            if errors:+                break+    return errors+++def test_lazy_local_namespace_with_concurrently_mutated_class_namespace() -> None:+    class Cls:+        pass++    for i in range(100):+        setattr(Cls, f'attr{i}', i)++    stop = threading.Event()++    def mutate() -> None:+        while not stop.is_set():+            Cls.dynamic = 1+            del Cls.dynamic++    def lookup() -> None:+        # A fresh namespace each time, so that the class namespace gets snapshotted again:+        assert LazyLocalNamespace({'a': 1}, vars(Cls))['attr50'] == 50++    mutator = threading.Thread(target=mutate)+    mutator.start()+    try:+        errors = _race([lookup] * (N_THREADS - 1))+    finally:+        stop.set()+        mutator.join()++    assert errors == []+++MODULE_SOURCE = """+from __future__ import annotations++from typing import Generic, TypeVar++from pydantic import BaseModel, field_validator++T = TypeVar('T')+++class Model0(BaseModel):+    items: list[Box0[Leaf0] | Box1[Leaf1] | Leaf2] = []++{methods}+++class Model1(BaseModel):+    items: list[Box1[Leaf2] | Box0[Leaf1] | Leaf0] = []++    @field_validator('items')+    @classmethod+    def validate_items(cls, v):+        return v++{methods}+++class Box0(BaseModel, Generic[T]):+    value: T | None = None+    ref: Leaf0 | None = None++{methods}+++class Box1(BaseModel, Generic[T]):+    value: T | None = None+    ref: Leaf1 | None = None++{methods}+++class Leaf0(BaseModel):+    x: int = 0+++class Leaf1(BaseModel):+    x: int = 0+++class Leaf2(BaseModel):+    x: int = 0+""".format(methods='\n'.join(f'    def method{m}(self) -> None: ...' for m in range(60)))+++def test_concurrent_lazy_model_rebuild() -> None:+    """Instantiating incomplete models concurrently (triggering concurrent `model_rebuild()` calls) should not fail."""++    errors: list[str] = []+    for rnd in range(10):+        # Fresh module => fresh incomplete classes:+        module = types.ModuleType(f'_test_concurrent_lazy_model_rebuild_{rnd}')+        sys.modules[module.__name__] = module+        try:+            exec(compile(MODULE_SOURCE, module.__name__, 'exec'), module.__dict__)+            models = [module.Model0, module.Model1]+            assert not any(model.__pydantic_complete__ for model in models)++            # Note: `model_rebuild()` isn't fully thread-safe, and a concurrent rebuild can temporarily+            # remove the validator of the class (falling back to the `BaseModel` mock one). We only assert+            # that the namespace/attribute access races reported in the issue don't happen anymore:+            errors = [+                tb+                for tb in _race([models[i % len(models)] for i in range(N_THREADS)])+                if 'dictionary changed size during iteration' in tb or 'AttributeError' in tb+            ]++            for model in models:+                assert model.__pydantic_complete__+                assert model(items=[{'x': 1}]).items+        finally:+            del sys.modules[module.__name__]++        assert errors == [], errors[0]+++def test_concurrent_forced_model_rebuild() -> None:+    class Model(BaseModel):+        a: int++    errors = _race([lambda: Model.model_rebuild(force=True)] * N_THREADS, rounds=5)+    assert errors == []++    assert Model.__pydantic_complete__+    assert Model(a=1).a == 1+++def test_concurrent_forced_dataclass_rebuild() -> None:+    @dataclass+    class DC:+        a: int++    errors = _race([lambda: rebuild_dataclass(DC, force=True)] * N_THREADS, rounds=5)+    assert errors == []++    assert DC.__pydantic_complete__+    assert DC(a=1).a == 1 
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'