Nested classes and instancemethods are directly picklable on Py3.5+.

anntzer · anntzer · commit 08387d8e167c · 2018-02-21T22:54:50.000-08:00
https://docs.python.org/3/whatsnew/3.5.html#pickle The previous workarounds were private and can be directly removed.
diff --git a/lib/matplotlib/axes/_base.py b/lib/matplotlib/axes/_base.py
@@ -158,7 +158,7 @@ def __init__(self, axes, command='plot'):
         self.set_prop_cycle()
 
     def __getstate__(self):
-        # note: it is not possible to pickle a itertools.cycle instance
+        # note: it is not possible to pickle a generator (and thus a cycler).
         return {'axes': self.axes, 'command': self.command}
 
     def __setstate__(self, state):
diff --git a/lib/matplotlib/cbook/__init__.py b/lib/matplotlib/cbook/__init__.py
@@ -2160,44 +2160,6 @@ def violin_stats(X, method, points=100):
     return vpstats
 
 
-class _NestedClassGetter(object):
-    # recipe from http://stackoverflow.com/a/11493777/741316
-    """
-    When called with the containing class as the first argument,
-    and the name of the nested class as the second argument,
-    returns an instance of the nested class.
-    """
-    def __call__(self, containing_class, class_name):
-        nested_class = getattr(containing_class, class_name)
-
-        # make an instance of a simple object (this one will do), for which we
-        # can change the __class__ later on.
-        nested_instance = _NestedClassGetter()
-
-        # set the class of the instance, the __init__ will never be called on
-        # the class but the original state will be set later on by pickle.
-        nested_instance.__class__ = nested_class
-        return nested_instance
-
-
-class _InstanceMethodPickler(object):
-    """
-    Pickle cannot handle instancemethod saving. _InstanceMethodPickler
-    provides a solution to this.
-    """
-    def __init__(self, instancemethod):
-        """Takes an instancemethod as its only argument."""
-        if six.PY3:
-            self.parent_obj = instancemethod.__self__
-            self.instancemethod_name = instancemethod.__func__.__name__
-        else:
-            self.parent_obj = instancemethod.im_self
-            self.instancemethod_name = instancemethod.im_func.__name__
-
-    def get_instancemethod(self):
-        return getattr(self.parent_obj, self.instancemethod_name)
-
-
 def pts_to_prestep(x, *args):
     """
     Convert continuous line to pre-steps.
diff --git a/lib/matplotlib/markers.py b/lib/matplotlib/markers.py
@@ -187,15 +187,6 @@ def __init__(self, marker=None, fillstyle=None):
         self.set_fillstyle(fillstyle)
         self.set_marker(marker)
 
-    def __getstate__(self):
-        d = self.__dict__.copy()
-        d.pop('_marker_function')
-        return d
-
-    def __setstate__(self, statedict):
-        self.__dict__ = statedict
-        self.set_marker(self._marker)
-
     def _recache(self):
         if self._marker_function is None:
             return
diff --git a/lib/matplotlib/offsetbox.py b/lib/matplotlib/offsetbox.py
@@ -156,25 +156,6 @@ def __init__(self, *args, **kwargs):
         self._children = []
         self._offset = (0, 0)
 
-    def __getstate__(self):
-        state = martist.Artist.__getstate__(self)
-
-        # pickle cannot save instancemethods, so handle them here
-        from .cbook import _InstanceMethodPickler
-        import inspect
-
-        offset = state['_offset']
-        if inspect.ismethod(offset):
-            state['_offset'] = _InstanceMethodPickler(offset)
-        return state
-
-    def __setstate__(self, state):
-        self.__dict__ = state
-        from .cbook import _InstanceMethodPickler
-        if isinstance(self._offset, _InstanceMethodPickler):
-            self._offset = self._offset.get_instancemethod()
-        self.stale = True
-
     def set_figure(self, fig):
         """
         Set the figure
diff --git a/lib/matplotlib/patches.py b/lib/matplotlib/patches.py
@@ -2033,14 +2033,6 @@ def __call__(self, x0, y0, width, height, mutation_size,
             else:
                 return self.transmute(x0, y0, width, height, mutation_size)
 
-        def __reduce__(self):
-            # because we have decided to nest these classes, we need to
-            # add some more information to allow instance pickling.
-            return (cbook._NestedClassGetter(),
-                    (BoxStyle, self.__class__.__name__),
-                    self.__dict__
-                    )
-
     class Square(_Base):
         """
         A simple square box.
@@ -2819,14 +2811,6 @@ def __call__(self, posA, posB,
 
             return shrunk_path
 
-        def __reduce__(self):
-            # because we have decided to nest these classes, we need to
-            # add some more information to allow instance pickling.
-            return (cbook._NestedClassGetter(),
-                    (ConnectionStyle, self.__class__.__name__),
-                    self.__dict__
-                    )
-
     class Arc3(_Base):
         """
         Creates a simple quadratic bezier curve between two
@@ -3276,14 +3260,6 @@ def __call__(self, path, mutation_size, linewidth,
             else:
                 return self.transmute(path, mutation_size, linewidth)
 
-        def __reduce__(self):
-            # because we have decided to nest these classes, we need to
-            # add some more information to allow instance pickling.
-            return (cbook._NestedClassGetter(),
-                    (ArrowStyle, self.__class__.__name__),
-                    self.__dict__
-                    )
-
     class _Curve(_Base):
         """
         A simple arrow which will work with any path instance. The
diff --git a/lib/matplotlib/transforms.py b/lib/matplotlib/transforms.py
@@ -1680,30 +1680,6 @@ def _init(self, child):
     def __eq__(self, other):
         return self._child.__eq__(other)
 
-    # NOTE: Transform.__[gs]etstate__ should be sufficient when using only
-    # Python 3.4+.
-    def __getstate__(self):
-        # only store the child information and parents
-        return {
-            'child': self._child,
-            'input_dims': self.input_dims,
-            'output_dims': self.output_dims,
-            # turn the weak-values dictionary into a normal dictionary
-            'parents': dict((k, v()) for (k, v) in
-                            six.iteritems(self._parents))
-        }
-
-    def __setstate__(self, state):
-        # re-initialise the TransformWrapper with the state's child
-        self._init(state['child'])
-        # The child may not be unpickled yet, so restore its information.
-        self.input_dims = state['input_dims']
-        self.output_dims = state['output_dims']
-        # turn the normal dictionary back into a dictionary with weak
-        # values
-        self._parents = dict((k, weakref.ref(v)) for (k, v) in
-                             six.iteritems(state['parents']) if v is not None)
-
     def __str__(self):
         return ("{}(\n"
                     "{})"
