FIX: account for changes to cpython with copy/deepcopy to super()

tacaswell · tacaswell · commit 60903f0b0cf6 · 2024-12-31T16:10:38.000-05:00
See python/cpython#126817 for upstream discussion. This works around the change by using (private) methods from the copy module to re-implement the path though copy/deepcopy that we would like to use but avoid the special-casing for `super()` objects that is breaking us. We could vendor the current versions of `_keep_alive` (weakref work to manage lifecycles) and `_reconstruct` (where the recursion happens) to superficially avoid using private functions from CPython. However, if these functions do change significantly I worry that our copies would not inter-operate anyway. Closes #29157
diff --git a/lib/matplotlib/path.py b/lib/matplotlib/path.py
@@ -11,6 +11,7 @@
 
 import copy
 from functools import lru_cache
+import sys
 from weakref import WeakValueDictionary
 
 import numpy as np
@@ -282,7 +283,17 @@ def __deepcopy__(self, memo=None):
         readonly, even if the source `Path` is.
         """
         # Deepcopying arrays (vertices, codes) strips the writeable=False flag.
-        p = copy.deepcopy(super(), memo)
+        if sys.version_info >= (3, 14):
+            from copy import _reconstruct, _keep_alive
+            rv = super().__reduce_ex__(4)
+            assert memo is not None
+            p = _reconstruct(self, memo, *rv)
+            if memo is not None:
+                memo[id(self)] = p
+                _keep_alive(self, memo)
+
+        else:
+            p = copy.deepcopy(super(), memo)
         p._readonly = False
         return p
 
diff --git a/lib/matplotlib/transforms.py b/lib/matplotlib/transforms.py
@@ -38,6 +38,7 @@
 import copy
 import functools
 import itertools
+import sys
 import textwrap
 import weakref
 import math
@@ -141,7 +142,12 @@ def __setstate__(self, data_dict):
             for k, v in self._parents.items() if v is not None}
 
     def __copy__(self):
-        other = copy.copy(super())
+        if sys.version_info >= (3, 14):
+            from copy import _reconstruct
+            rv = super().__reduce_ex__(4)
+            other = _reconstruct(self, None, *rv)
+        else:
+            other = copy.copy(super())
         # If `c = a + b; a1 = copy(a)`, then modifications to `a1` do not
         # propagate back to `c`, i.e. we need to clear the parents of `a1`.
         other._parents = {}
