Backtestspydanticrun-20260930-183947#13419
"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
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
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'