Merge pull request matplotlib#11195 from anntzer/cleanups

Some unrelated cleanups.

Author: timhoffm

lib/matplotlib/axes/_subplots.py

@@ -1,3 +1,4 @@
+import functools
 import warnings
 
 from matplotlib import docstring
@@ -87,18 +88,13 @@ def __init__(self, fig, *args, **kwargs):
                     pos=True, subplot=True, artist=self)
 
     def __reduce__(self):
-        # get the first axes class which does not
-        # inherit from a subplotbase
-
-        def not_subplotbase(c):
-            return issubclass(c, Axes) and not issubclass(c, SubplotBase)
-
-        axes_class = [c for c in self.__class__.mro()
-                      if not_subplotbase(c)][0]
-        r = [_PicklableSubplotClassConstructor(),
-             (axes_class,),
-             self.__getstate__()]
-        return tuple(r)
+        # get the first axes class which does not inherit from a subplotbase
+        axes_class = next(
+            c for c in type(self).__mro__
+            if issubclass(c, Axes) and not issubclass(c, SubplotBase))
+        return (_picklable_subplot_class_constructor,
+                (axes_class,),
+                self.__getstate__())
 
     def get_geometry(self):
         """get the subplot geometry, e.g., 2,2,3"""
@@ -188,9 +184,8 @@ def _make_twin_axes(self, *kl, **kwargs):
         self._twinned_axes.join(self, ax2)
         return ax2
 
-_subplot_classes = {}
-
 
+@functools.lru_cache(None)
 def subplot_class_factory(axes_class=None):
     # This makes a new class that inherits from SubplotBase and the
     # given axes_class (which is assumed to be a subclass of Axes).
@@ -199,62 +194,23 @@ def subplot_class_factory(axes_class=None):
     # not have to be created for every type of Axes.
     if axes_class is None:
         axes_class = Axes
+    return type("%sSubplot" % axes_class.__name__,
+                (SubplotBase, axes_class),
+                {'_axes_class': axes_class})
 
-    new_class = _subplot_classes.get(axes_class)
-    if new_class is None:
-        new_class = type(str("%sSubplot") % (axes_class.__name__),
-                         (SubplotBase, axes_class),
-                         {'_axes_class': axes_class})
-        _subplot_classes[axes_class] = new_class
-
-    return new_class
 
 # This is provided for backward compatibility
 Subplot = subplot_class_factory()
 
 
-class _PicklableSubplotClassConstructor(object):
+def _picklable_subplot_class_constructor(axes_class):
     """
-    This stub class exists to return the appropriate subplot
-    class when __call__-ed with an axes class. This is purely to
-    allow Pickling of Axes and Subplots.
+    This stub class exists to return the appropriate subplot class when called
+    with an axes class. This is purely to allow pickling of Axes and Subplots.
     """
-    def __call__(self, axes_class):
-        # create a dummy object instance
-        subplot_instance = _PicklableSubplotClassConstructor()
-        subplot_class = subplot_class_factory(axes_class)
-        # update the class to the desired subplot class
-        subplot_instance.__class__ = subplot_class
-        return subplot_instance
+    subplot_class = subplot_class_factory(axes_class)
+    return subplot_class.__new__(subplot_class)
 
 
 docstring.interpd.update(Axes=martist.kwdoc(Axes))
 docstring.interpd.update(Subplot=martist.kwdoc(Axes))
-
-"""
-# this is some discarded code I was using to find the minimum positive
-# data point for some log scaling fixes.  I realized there was a
-# cleaner way to do it, but am keeping this around as an example for
-# how to get the data out of the axes.  Might want to make something
-# like this a method one day, or better yet make get_verts an Artist
-# method
-
-            minx, maxx = self.get_xlim()
-            if minx<=0 or maxx<=0:
-                # find the min pos value in the data
-                xs = []
-                for line in self.lines:
-                    xs.extend(line.get_xdata(orig=False))
-                for patch in self.patches:
-                    xs.extend([x for x,y in patch.get_verts()])
-                for collection in self.collections:
-                    xs.extend([x for x,y in collection.get_verts()])
-                posx = [x for x in xs if x>0]
-                if len(posx):
-
-                    minx = min(posx)
-                    maxx = max(posx)
-                    # warning, probably breaks inverted axis
-                    self.set_xlim((0.1*minx, maxx))
-
-"""

lib/matplotlib/mathtext.py

@@ -1360,9 +1360,6 @@ def __init__(self):
         self.size = 0
 
     def __repr__(self):
-        return self.__internal_repr__()
-
-    def __internal_repr__(self):
         return self.__class__.__name__
 
     def get_kerning(self, next):
@@ -1449,7 +1446,7 @@ def __init__(self, c, state, math=True):
         # pack phase, after we know the real fontsize
         self._update_metrics()
 
-    def __internal_repr__(self):
+    def __repr__(self):
         return '`%s`' % self.c
 
     def _update_metrics(self):
@@ -1547,7 +1544,7 @@ def __init__(self, elements):
 
     def __repr__(self):
         return '[%s <%.02f %.02f %.02f %.02f> %s]' % (
-            self.__internal_repr__(),
+            super().__repr__(),
             self.width, self.height,
             self.depth, self.shift_amount,
             ' '.join([repr(x) for x in self.children]))

lib/matplotlib/patches.py

@@ -38,9 +38,6 @@ class Patch(artist.Artist):
     # subclass-by-subclass basis.
     _edge_default = False
 
-    def __str__(self):
-        return str(self.__class__).split('.')[-1]
-
     def __init__(self,
                  edgecolor=None,
                  facecolor=None,

lib/matplotlib/tests/test_axes.py

@@ -1779,6 +1779,7 @@ def __init__(self):
         def _as_mpl_axes(self):
             # implement the matplotlib axes interface
             return PolarAxes, {'theta_offset': self.theta_offset}
+
     prj = Polar()
     prj2 = Polar()
     prj2.theta_offset = np.pi
@@ -1793,7 +1794,7 @@ def _as_mpl_axes(self):
 
     # testing axes creation with gca
     ax = plt.gca(projection=prj)
-    assert type(ax) == maxes._subplots._subplot_classes[PolarAxes]
+    assert type(ax) == maxes._subplots.subplot_class_factory(PolarAxes)
     ax_via_gca = plt.gca(projection=prj)
     assert ax_via_gca is ax
     # try getting the axes given a different polar projection
@@ -1814,7 +1815,7 @@ def _as_mpl_axes(self):
 
     # testing axes creation with subplot
     ax = plt.subplot(121, projection=prj)
-    assert type(ax) == maxes._subplots._subplot_classes[PolarAxes]
+    assert type(ax) == maxes._subplots.subplot_class_factory(PolarAxes)
     plt.close()
 
 

lib/mpl_toolkits/axes_grid1/parasite_axes.py

@@ -1,4 +1,4 @@
-import six
+import functools
 
 from matplotlib import (
     artist as martist, collections as mcoll, transforms as mtransforms,
@@ -40,32 +40,21 @@ def cla(self):
             self.yaxis.set_zorder(2.5)
 
 
-_parasite_axes_classes = {}
+@functools.lru_cache(None)
 def parasite_axes_class_factory(axes_class=None):
     if axes_class is None:
         axes_class = Axes
 
-    new_class = _parasite_axes_classes.get(axes_class)
-    if new_class is None:
-        def _get_base_axes_attr(self, attrname):
-            return getattr(axes_class, attrname)
+    def _get_base_axes_attr(self, attrname):
+        return getattr(axes_class, attrname)
 
-        new_class = type(str("%sParasite" % (axes_class.__name__)),
-                         (ParasiteAxesBase, axes_class),
-                         {'_get_base_axes_attr': _get_base_axes_attr})
-        _parasite_axes_classes[axes_class] = new_class
+    return type("%sParasite" % axes_class.__name__,
+                (ParasiteAxesBase, axes_class),
+                {'_get_base_axes_attr': _get_base_axes_attr})
 
-    return new_class
 
 ParasiteAxes = parasite_axes_class_factory()
 
-# #class ParasiteAxes(ParasiteAxesBase, Axes):
-
-#     @classmethod
-#     def _get_base_axes_attr(cls, attrname):
-#         return getattr(Axes, attrname)
-
-
 
 class ParasiteAxesAuxTransBase(object):
     def __init__(self, parent_axes, aux_transform, viewlim_mode=None,
@@ -189,30 +178,22 @@ def apply_aspect(self, position=None):
         #ParasiteAxes.apply_aspect()
 
 
-
-_parasite_axes_auxtrans_classes = {}
+@functools.lru_cache(None)
 def parasite_axes_auxtrans_class_factory(axes_class=None):
     if axes_class is None:
         parasite_axes_class = ParasiteAxes
     elif not issubclass(axes_class, ParasiteAxesBase):
         parasite_axes_class = parasite_axes_class_factory(axes_class)
     else:
         parasite_axes_class = axes_class
-
-    new_class = _parasite_axes_auxtrans_classes.get(parasite_axes_class)
-    if new_class is None:
-        new_class = type(str("%sParasiteAuxTrans" % (parasite_axes_class.__name__)),
-                         (ParasiteAxesAuxTransBase, parasite_axes_class),
-                         {'_parasite_axes_class': parasite_axes_class,
-                         'name': 'parasite_axes'})
-        _parasite_axes_auxtrans_classes[parasite_axes_class] = new_class
-
-    return new_class
-
-
-ParasiteAxesAuxTrans = parasite_axes_auxtrans_class_factory(axes_class=ParasiteAxes)
+    return type("%sParasiteAuxTrans" % parasite_axes_class.__name__,
+                (ParasiteAxesAuxTransBase, parasite_axes_class),
+                {'_parasite_axes_class': parasite_axes_class,
+                 'name': 'parasite_axes'})
 
 
+ParasiteAxesAuxTrans = parasite_axes_auxtrans_class_factory(
+    axes_class=ParasiteAxes)
 
 
 def _get_handles(ax):
@@ -391,33 +372,29 @@ def get_tightbbox(self, renderer, call_axes_locator=True):
         return _bbox
 
 
-_host_axes_classes = {}
+@functools.lru_cache(None)
 def host_axes_class_factory(axes_class=None):
     if axes_class is None:
         axes_class = Axes
 
-    new_class = _host_axes_classes.get(axes_class)
-    if new_class is None:
-        def _get_base_axes(self):
-            return axes_class
+    def _get_base_axes(self):
+        return axes_class
 
-        def _get_base_axes_attr(self, attrname):
-            return getattr(axes_class, attrname)
+    def _get_base_axes_attr(self, attrname):
+        return getattr(axes_class, attrname)
 
-        new_class = type(str("%sHostAxes" % (axes_class.__name__)),
-                         (HostAxesBase, axes_class),
-                         {'_get_base_axes_attr': _get_base_axes_attr,
-                          '_get_base_axes': _get_base_axes})
+    return type("%sHostAxes" % axes_class.__name__,
+                (HostAxesBase, axes_class),
+                {'_get_base_axes_attr': _get_base_axes_attr,
+                 '_get_base_axes': _get_base_axes})
 
-        _host_axes_classes[axes_class] = new_class
-
-    return new_class
 
 def host_subplot_class_factory(axes_class):
     host_axes_class = host_axes_class_factory(axes_class=axes_class)
     subplot_host_class = subplot_class_factory(host_axes_class)
     return subplot_host_class
 
+
 HostAxes = host_axes_class_factory(axes_class=Axes)
 SubplotHost = subplot_class_factory(HostAxes)
 

lib/mpl_toolkits/axisartist/floating_axes.py

@@ -1,8 +1,8 @@
 """
 An experimental support for curvilinear grid.
 """
-import six
-from six.moves import zip
+
+import functools
 
 # TODO :
 # see if tick_iterator method can be simplified by reusing the parent method.
@@ -506,19 +506,12 @@ def adjust_axes_lim(self):
         self.set_ylim(ymin-dy, ymax+dy)
 
 
-
-_floatingaxes_classes = {}
-
+@functools.lru_cache(None)
 def floatingaxes_class_factory(axes_class):
+    return type("Floating %s" % axes_class.__name__,
+                (FloatingAxesBase, axes_class),
+                {'_axes_class_floating': axes_class})
 
-    new_class = _floatingaxes_classes.get(axes_class)
-    if new_class is None:
-        new_class = type(str("Floating %s" % (axes_class.__name__)),
-                         (FloatingAxesBase, axes_class),
-                         {'_axes_class_floating': axes_class})
-        _floatingaxes_classes[axes_class] = new_class
-
-    return new_class
 
 from .axislines import Axes
 from mpl_toolkits.axes_grid1.parasite_axes import host_axes_class_factory