gh-141510: Implement copy and deepcopy for frozendict

Lib/copy.py

@@ -101,7 +101,7 @@ def copy(x):
 
 
 _copy_atomic_types = frozenset({types.NoneType, int, float, bool, complex, str, tuple,
-          bytes, frozenset, type, range, slice, property,
+          bytes, frozendict, frozenset, type, range, slice, property,
           types.BuiltinFunctionType, types.EllipsisType,
           types.NotImplementedType, types.FunctionType, types.CodeType,
           weakref.ref, super})
@@ -166,7 +166,7 @@ def deepcopy(x, memo=None):
           int, float, bool, complex, bytes, str, types.CodeType, type, range,
           types.BuiltinFunctionType, types.FunctionType, weakref.ref, property})
 
-_deepcopy_dispatch = d = {}
+d = {}
 
 
 def _deepcopy_list(x, memo, deepcopy=deepcopy):
@@ -203,10 +203,16 @@ def _deepcopy_dict(x, memo, deepcopy=deepcopy):
     return y
 d[dict] = _deepcopy_dict
 
+def _deepcopy_frozendict(x, memo, deepcopy=deepcopy):
+    y = _deepcopy_dict(x, memo, deepcopy)
+    return frozendict(y)
+d[frozendict] = _deepcopy_frozendict
+
 def _deepcopy_method(x, memo): # Copy instance methods
     return type(x)(x.__func__, deepcopy(x.__self__, memo))
 d[types.MethodType] = _deepcopy_method
 
+_deepcopy_dispatch = frozendict(d)
 del d
 
 def _keep_alive(x, memo):

Lib/test/test_copy.py

@@ -133,6 +133,12 @@ def test_copy_dict(self):
         self.assertEqual(y, x)
         self.assertIsNot(y, x)
 
+    def test_copy_frozendict(self):
+        x = frozendict(x=1, y=2)
+        self.assertIs(copy.copy(x), x)
+        x = frozendict()
+        self.assertIs(copy.copy(x), x)
+
     def test_copy_set(self):
         x = {1, 2, 3}
         y = copy.copy(x)
@@ -419,6 +425,13 @@ def test_deepcopy_dict(self):
         self.assertIsNot(x, y)
         self.assertIsNot(x["foo"], y["foo"])
 
+    def test_deepcopy_frozendict(self):
+        x = frozendict({"foo": [1, 2], "bar": 3})
+        y = copy.deepcopy(x)
+        self.assertEqual(y, x)
+        self.assertIsNot(x, y)
+        self.assertIsNot(x["foo"], y["foo"])
+
     @support.skip_emscripten_stack_overflow()
     @support.skip_wasi_stack_overflow()
     def test_deepcopy_reflexive_dict(self):

Lib/test/test_descr.py

@@ -311,12 +311,7 @@ def test_spam_lists(self):
         # Testing spamlist operations...
         import copy, xxsubtype as spam
 
-        def spamlist(l, memo=None):
-            import xxsubtype as spam
-            return spam.spamlist(l)
-
-        # This is an ugly hack:
-        copy._deepcopy_dispatch[spam.spamlist] = spamlist
+        spamlist = spam.spamlist
 
         self.binop_test(spamlist([1]), spamlist([2]), spamlist([1,2]), "a+b",
                        "__add__")
@@ -350,19 +345,22 @@ def foo(self): return 1
         a.setstate(42)
         self.assertEqual(a.getstate(), 42)
 
+        # test deepcopy makes a deep copy of the elements of a spamlist
+        a.append([])
+        a_copy = copy.deepcopy(a)
+        assert a_copy is not a
+        assert a_copy[-1] is not a[-1]
+        assert a_copy == a
+        # the spamlist does not explictly implement deepcopy, the state is not copied
+        assert a_copy.getstate() != a.getstate()
+
     @support.impl_detail("the module 'xxsubtype' is internal")
     @unittest.skipIf(xxsubtype is None, "requires xxsubtype module")
     def test_spam_dicts(self):
         # Testing spamdict operations...
         import copy, xxsubtype as spam
-        def spamdict(d, memo=None):
-            import xxsubtype as spam
-            sd = spam.spamdict()
-            for k, v in list(d.items()):
-                sd[k] = v
-            return sd
-        # This is an ugly hack:
-        copy._deepcopy_dispatch[spam.spamdict] = spamdict
+
+        spamdict = spam.spamdict
 
         self.binop_test(spamdict({1:2,3:4}), 1, 1, "b in a", "__contains__")
         self.binop_test(spamdict({1:2,3:4}), 2, 0, "b in a", "__contains__")
@@ -401,6 +399,15 @@ def foo(self): return 1
         a.setstate(100)
         self.assertEqual(a.getstate(), 100)
 
+        # test deepcopy makes a deep copy of the elements of a spamdict
+        a[-1] = []
+        a_copy = copy.deepcopy(a)
+        assert a_copy is not a
+        assert a_copy[-1] is not a[-1]
+        assert a_copy == a
+        # the spamdict does not explictly implement deepcopy, the state is not copied
+        assert a_copy.getstate() != a.getstate()
+
     def test_wrap_lenfunc_bad_cast(self):
         self.assertEqual(range(sys.maxsize).__len__(), sys.maxsize)
 

Misc/NEWS.d/next/Library/2026-02-17-11-28-37.gh-issue-141510.OpAz0M.rst

@@ -0,0 +1,2 @@
+The :mod:`copy` module now supports the :class:`frozendict` type. Patch by
+Pieter Eendebak based on work by Victor Stinner.