From 04e193c0152595552fad309b29b84d7fea9fb1f2 Mon Sep 17 00:00:00 2001 From: Victor Stinner Date: Wed, 18 Feb 2026 12:13:01 +0100 Subject: [PATCH 1/5] gh-141510: Fix frozendict.fromkeys() for subclasses Copy the frozendict. --- Lib/test/test_dict.py | 25 +++++++++++++++++++++++++ Objects/dictobject.c | 29 +++++++++++++++++++++++++++-- 2 files changed, 52 insertions(+), 2 deletions(-) diff --git a/Lib/test/test_dict.py b/Lib/test/test_dict.py index 21f8bb11071c90..87f5a1946e5e56 100644 --- a/Lib/test/test_dict.py +++ b/Lib/test/test_dict.py @@ -1787,6 +1787,31 @@ def test_hash(self): with self.assertRaisesRegex(TypeError, "unhashable type: 'list'"): hash(fd) + def test_fromkeys(self): + self.assertEqual(frozendict.fromkeys('abc'), + frozendict(a=None, b=None, c=None)) + + # Subclass which overrides the constructor + class FrozenDictSubclass(frozendict): + def __new__(self): + return frozendict(x=1) + + fd = FrozenDictSubclass.fromkeys("abc") + self.assertEqual(fd, frozendict(x=1, a=None, b=None, c=None)) + self.assertEqual(type(fd), FrozenDictSubclass) + + fd = FrozenDictSubclass.fromkeys(frozendict(y=2)) + self.assertEqual(fd, frozendict(x=1, y=None)) + self.assertEqual(type(fd), FrozenDictSubclass) + + # Subclass which doesn't override the constructor + class FrozenDictSubclass2(frozendict): + pass + + fd = FrozenDictSubclass2.fromkeys("abc") + self.assertEqual(fd, frozendict(a=None, b=None, c=None)) + self.assertEqual(type(fd), FrozenDictSubclass2) + if __name__ == "__main__": unittest.main() diff --git a/Objects/dictobject.c b/Objects/dictobject.c index 0959e2c78a3289..eb178776656413 100644 --- a/Objects/dictobject.c +++ b/Objects/dictobject.c @@ -138,6 +138,7 @@ As a consequence of this, split keys have a maximum size of 16. // Forward declarations static PyObject* frozendict_new(PyTypeObject *type, PyObject *args, PyObject *kwds); +static int dict_merge(PyObject *a, PyObject *b, int override); /*[clinic input] @@ -3286,9 +3287,31 @@ _PyDict_FromKeys(PyObject *cls, PyObject *iterable, PyObject *value) int status; d = _PyObject_CallNoArgs(cls); - if (d == NULL) + if (d == NULL) { return NULL; + } + // If cls is a frozendict subclass with overridden constructor, + // copy the frozendict. + PyTypeObject *cls_type = _PyType_CAST(cls); + if (PyFrozenDict_Check(d) + && PyObject_IsSubclass(cls, (PyObject*)&PyFrozenDict_Type) + && cls_type->tp_new != frozendict_new) + { + // Subclass-friendly copy + PyObject *copy = frozendict_new(cls_type, NULL, NULL); + if (copy == NULL) { + Py_DECREF(d); + return NULL; + } + if (dict_merge(copy, d, 1) < 0) { + Py_DECREF(d); + Py_DECREF(copy); + return NULL; + } + Py_SETREF(d, copy); + } + assert(!PyFrozenDict_Check(d) || Py_REFCNT(d) == 1); if (PyDict_CheckExact(d)) { if (PyDict_CheckExact(iterable)) { @@ -3359,7 +3382,7 @@ _PyDict_FromKeys(PyObject *cls, PyObject *iterable, PyObject *value) dict_iter_exit:; Py_END_CRITICAL_SECTION(); } - else if (PyFrozenDict_CheckExact(d)) { + else if (PyFrozenDict_Check(d)) { while ((key = PyIter_Next(it)) != NULL) { // anydict_setitem_take2 consumes a reference to key status = anydict_setitem_take2((PyDictObject *)d, @@ -7994,6 +8017,8 @@ frozendict_new(PyTypeObject *type, PyObject *args, PyObject *kwds) if (d == NULL) { return NULL; } + assert(Py_REFCNT(d) == 1); + PyFrozenDictObject *self = _PyFrozenDictObject_CAST(d); self->ma_hash = -1; From 3a852985ee21aa4de9141d7c55e9c3c2ecbcc7b0 Mon Sep 17 00:00:00 2001 From: Victor Stinner Date: Wed, 18 Feb 2026 15:07:20 +0100 Subject: [PATCH 2/5] Use PyUnstable_Object_IsUniquelyReferenced() --- Objects/dictobject.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Objects/dictobject.c b/Objects/dictobject.c index eb178776656413..dbe15441f105fe 100644 --- a/Objects/dictobject.c +++ b/Objects/dictobject.c @@ -3311,7 +3311,7 @@ _PyDict_FromKeys(PyObject *cls, PyObject *iterable, PyObject *value) } Py_SETREF(d, copy); } - assert(!PyFrozenDict_Check(d) || Py_REFCNT(d) == 1); + assert(!PyFrozenDict_Check(d) || PyUnstable_Object_IsUniquelyReferenced(d)); if (PyDict_CheckExact(d)) { if (PyDict_CheckExact(iterable)) { @@ -8017,7 +8017,7 @@ frozendict_new(PyTypeObject *type, PyObject *args, PyObject *kwds) if (d == NULL) { return NULL; } - assert(Py_REFCNT(d) == 1); + assert(PyUnstable_Object_IsUniquelyReferenced(d)); PyFrozenDictObject *self = _PyFrozenDictObject_CAST(d); self->ma_hash = -1; From b909e499f06369dc3ca790b0237af000d1801425 Mon Sep 17 00:00:00 2001 From: Victor Stinner Date: Wed, 18 Feb 2026 15:43:58 +0100 Subject: [PATCH 3/5] Test checks that created dict is not modified --- Lib/test/test_dict.py | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/Lib/test/test_dict.py b/Lib/test/test_dict.py index 87f5a1946e5e56..5335fc1e6fdb87 100644 --- a/Lib/test/test_dict.py +++ b/Lib/test/test_dict.py @@ -1792,17 +1792,23 @@ def test_fromkeys(self): frozendict(a=None, b=None, c=None)) # Subclass which overrides the constructor + created = None class FrozenDictSubclass(frozendict): def __new__(self): - return frozendict(x=1) + nonlocal created + created = frozendict(x=1) + return created fd = FrozenDictSubclass.fromkeys("abc") self.assertEqual(fd, frozendict(x=1, a=None, b=None, c=None)) self.assertEqual(type(fd), FrozenDictSubclass) + self.assertEqual(created, frozendict(x=1)) + created = None fd = FrozenDictSubclass.fromkeys(frozendict(y=2)) self.assertEqual(fd, frozendict(x=1, y=None)) self.assertEqual(type(fd), FrozenDictSubclass) + self.assertEqual(created, frozendict(x=1)) # Subclass which doesn't override the constructor class FrozenDictSubclass2(frozendict): From 6ecc62882e791b0b4d337542b49a0404a390fa0f Mon Sep 17 00:00:00 2001 From: Victor Stinner Date: Wed, 18 Feb 2026 15:51:05 +0100 Subject: [PATCH 4/5] Simplify the test --- Lib/test/test_dict.py | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/Lib/test/test_dict.py b/Lib/test/test_dict.py index 5335fc1e6fdb87..1a8ae1cd42356e 100644 --- a/Lib/test/test_dict.py +++ b/Lib/test/test_dict.py @@ -1792,11 +1792,9 @@ def test_fromkeys(self): frozendict(a=None, b=None, c=None)) # Subclass which overrides the constructor - created = None + created = frozendict(x=1) class FrozenDictSubclass(frozendict): def __new__(self): - nonlocal created - created = frozendict(x=1) return created fd = FrozenDictSubclass.fromkeys("abc") @@ -1804,7 +1802,6 @@ def __new__(self): self.assertEqual(type(fd), FrozenDictSubclass) self.assertEqual(created, frozendict(x=1)) - created = None fd = FrozenDictSubclass.fromkeys(frozendict(y=2)) self.assertEqual(fd, frozendict(x=1, y=None)) self.assertEqual(type(fd), FrozenDictSubclass) From ee9b18ab599bfaaa413d2b758137ecb81aba75da Mon Sep 17 00:00:00 2001 From: Victor Stinner Date: Wed, 18 Feb 2026 16:27:24 +0100 Subject: [PATCH 5/5] Reuse can_modify_dict() --- Objects/dictobject.c | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/Objects/dictobject.c b/Objects/dictobject.c index d6949090bc12b6..8d3c34f87e2afe 100644 --- a/Objects/dictobject.c +++ b/Objects/dictobject.c @@ -295,6 +295,8 @@ can_modify_dict(PyDictObject *mp) return PyUnstable_Object_IsUniquelyReferenced(_PyObject_CAST(mp)); } else { + // Locking is only required if the dictionary is not + // uniquely referenced. ASSERT_DICT_LOCKED(mp); return 1; } @@ -3239,6 +3241,8 @@ _PyDict_Pop(PyObject *dict, PyObject *key, PyObject *default_value) static PyDictObject * dict_dict_fromkeys(PyDictObject *mp, PyObject *iterable, PyObject *value) { + assert(can_modify_dict(mp)); + PyObject *oldvalue; Py_ssize_t pos = 0; PyObject *key; @@ -3264,6 +3268,8 @@ dict_dict_fromkeys(PyDictObject *mp, PyObject *iterable, PyObject *value) static PyDictObject * dict_set_fromkeys(PyDictObject *mp, PyObject *iterable, PyObject *value) { + assert(can_modify_dict(mp)); + Py_ssize_t pos = 0; PyObject *key; Py_hash_t hash; @@ -3319,7 +3325,7 @@ _PyDict_FromKeys(PyObject *cls, PyObject *iterable, PyObject *value) } Py_SETREF(d, copy); } - assert(!PyFrozenDict_Check(d) || PyUnstable_Object_IsUniquelyReferenced(d)); + assert(!PyFrozenDict_Check(d) || can_modify_dict((PyDictObject*)d)); if (PyDict_CheckExact(d)) { if (PyDict_CheckExact(iterable)) { @@ -8025,7 +8031,7 @@ frozendict_new(PyTypeObject *type, PyObject *args, PyObject *kwds) if (d == NULL) { return NULL; } - assert(PyUnstable_Object_IsUniquelyReferenced(d)); + assert(can_modify_dict(_PyAnyDict_CAST(d))); PyFrozenDictObject *self = _PyFrozenDictObject_CAST(d); self->ma_hash = -1;