python · sobolevn · Oct 22, 2021 · Oct 22, 2021
@@ -977,6 +977,10 @@ def _process_class(cls, init, repr, eq, order, unsafe_hash, frozen):
                 raise TypeError(f'Cannot overwrite attribute {fn.__name__} '
                                 f'in class {cls.__name__}')
 
+        # Need this for pickling frozen classes.
+        cls.__getstate__ = _dataclass_getstate
+        cls.__setstate__ = _dataclass_setstate
+
     # Decide if/how we're going to create a hash function.
     hash_action = _hash_action[bool(unsafe_hash),
                                bool(eq),
@@ -995,6 +999,21 @@ def _process_class(cls, init, repr, eq, order, unsafe_hash, frozen):
     return cls
 
 
+# _dataclass_getstate and _dataclass_setstate are needed for pickling frozen
+# classes (maybe even with slots).
+# These could be slightly more performant if we generated
+# the code instead of iterating over fields.  But that can be a project for
+# another day, if performance becomes an issue.
+def _dataclass_getstate(self):
+    return [getattr(self, f.name) for f in fields(self)]
+
+
+def _dataclass_setstate(self, state):
+    for field, value in zip(fields(self), state):
+        # use setattr because dataclass may be frozen
+        object.__setattr__(self, field.name, value)
+
+
 def dataclass(cls=None, /, *, init=True, repr=True, eq=True, order=False,
               unsafe_hash=False, frozen=False):
     """Returns the same class as was passed in, with dunder methods

@@ -2775,6 +2775,35 @@ class Derived(Base):
         # We can add a new field to the derived instance.
         d.z = 10
 
+    # Can't be local to test_frozen_pickle.
+    @dataclass(frozen=True)
+    class FrozenSlotsClass:
+        __slots__ = ('foo', 'bar')
+        foo: str
+        bar: int
+
+    @dataclass(frozen=True)
+    class FrozenWithoutSlotsClass:
+        foo: str
+        bar: int
+
+    def test_frozen_pickle(self):
+        # bpo-43999
+        # bpo-45520
+
+        self.assertEqual(self.FrozenSlotsClass.__slots__, ("foo", "bar"))
+        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+            with self.subTest(proto=proto):
+                obj = self.FrozenSlotsClass("a", 1)
+                p = pickle.loads(pickle.dumps(obj, protocol=proto))
+                self.assertIsNot(obj, p)
+                self.assertEqual(obj, p)
+
+                obj = self.FrozenWithoutSlotsClass("a", 1)
+                p = pickle.loads(pickle.dumps(obj, protocol=proto))
+                self.assertIsNot(obj, p)
+                self.assertEqual(obj, p)
+
 class TestDescriptors(unittest.TestCase):
     def test_set_name(self):
         # See bpo-33141.

diff --git a/Misc/NEWS.d/next/Library/2021-10-22-11-02-26.bpo-45520._KpfOB.rst b/Misc/NEWS.d/next/Library/2021-10-22-11-02-26.bpo-45520._KpfOB.rst
@@ -0,0 +1,3 @@
+Fix ``__getstate__`` and ``__setstate__`` methods for frozen
+``dataclasses``. It basically backports a part of 3.10's code to support
+``pickle`` and ``deepcopy``.