Use super() instead of manually fetching supermethods for parasite axes.

anntzer · anntzer · commit cd500c79ac83 · 2018-07-17T12:00:29.000+02:00
(This manual fetching was previously done in _get_base_axes_attr.)
diff --git a/lib/mpl_toolkits/axes_grid1/parasite_axes.py b/lib/mpl_toolkits/axes_grid1/parasite_axes.py
@@ -10,7 +10,7 @@
 import numpy as np
 
 
-class ParasiteAxesBase(object):
+class ParasiteAxesBase:
 
     def get_images_artists(self):
         artists = {a for a in self.get_children() if a.get_visible()}
@@ -21,11 +21,10 @@ def get_images_artists(self):
     def __init__(self, parent_axes, **kwargs):
         self._parent_axes = parent_axes
         kwargs["frameon"] = False
-        self._get_base_axes_attr("__init__")(
-            self, parent_axes.figure, parent_axes._position, **kwargs)
+        super().__init__(parent_axes.figure, parent_axes._position, **kwargs)
 
     def cla(self):
-        self._get_base_axes_attr("cla")(self)
+        super().cla()
 
         martist.setp(self.get_children(), visible=False)
         self._get_lines = self._parent_axes._get_lines
@@ -45,18 +44,14 @@ def parasite_axes_class_factory(axes_class=None):
     if axes_class is None:
         axes_class = Axes
 
-    def _get_base_axes_attr(self, attrname):
-        return getattr(axes_class, attrname)
-
     return type("%sParasite" % axes_class.__name__,
-                (ParasiteAxesBase, axes_class),
-                {'_get_base_axes_attr': _get_base_axes_attr})
+                (ParasiteAxesBase, axes_class), {})
 
 
 ParasiteAxes = parasite_axes_class_factory()
 
 
-class ParasiteAxesAuxTransBase(object):
+class ParasiteAxesAuxTransBase:
     def __init__(self, parent_axes, aux_transform, viewlim_mode=None,
                  **kwargs):
 
@@ -87,7 +82,6 @@ def set_viewlim_mode(self, mode):
     def get_viewlim_mode(self):
         return self._viewlim_mode
 
-
     def update_viewlim(self):
         viewlim = self._parent_axes.viewLim.frozen()
         mode = self.get_viewlim_mode()
@@ -100,8 +94,7 @@ def update_viewlim(self):
         else:
             raise ValueError("Unknown mode : %s" % (self._viewlim_mode,))
 
-
-    def _pcolor(self, method_name, *XYC, **kwargs):
+    def _pcolor(self, super_pcolor, *XYC, **kwargs):
         if len(XYC) == 1:
             C = XYC[0]
             ny, nx = C.shape
@@ -113,29 +106,26 @@ def _pcolor(self, method_name, *XYC, **kwargs):
         else:
             X, Y, C = XYC
 
-        pcolor_routine = self._get_base_axes_attr(method_name)
-
         if "transform" in kwargs:
-            mesh = pcolor_routine(self, X, Y, C, **kwargs)
+            mesh = super_pcolor(self, X, Y, C, **kwargs)
         else:
             orig_shape = X.shape
             xy = np.vstack([X.flat, Y.flat])
             xyt=xy.transpose()
             wxy = self.transAux.transform(xyt)
             gx, gy = wxy[:,0].reshape(orig_shape), wxy[:,1].reshape(orig_shape)
-            mesh = pcolor_routine(self, gx, gy, C, **kwargs)
+            mesh = super_pcolor(self, gx, gy, C, **kwargs)
             mesh.set_transform(self._parent_axes.transData)
 
         return mesh
 
     def pcolormesh(self, *XYC, **kwargs):
-        return self._pcolor("pcolormesh", *XYC, **kwargs)
+        return self._pcolor(super().pcolormesh, *XYC, **kwargs)
 
     def pcolor(self, *XYC, **kwargs):
-        return self._pcolor("pcolor", *XYC, **kwargs)
-
+        return self._pcolor(super().pcolor, *XYC, **kwargs)
 
-    def _contour(self, method_name, *XYCL, **kwargs):
+    def _contour(self, super_contour, *XYCL, **kwargs):
 
         if len(XYCL) <= 2:
             C = XYCL[0]
@@ -150,32 +140,29 @@ def _contour(self, method_name, *XYCL, **kwargs):
             X, Y = XYCL[:2]
             CL = XYCL[2:]
 
-        contour_routine = self._get_base_axes_attr(method_name)
-
         if "transform" in kwargs:
-            cont = contour_routine(self, X, Y, *CL, **kwargs)
+            cont = super_contour(self, X, Y, *CL, **kwargs)
         else:
             orig_shape = X.shape
             xy = np.vstack([X.flat, Y.flat])
             xyt=xy.transpose()
             wxy = self.transAux.transform(xyt)
             gx, gy = wxy[:,0].reshape(orig_shape), wxy[:,1].reshape(orig_shape)
-            cont = contour_routine(self, gx, gy, *CL, **kwargs)
+            cont = super_contour(self, gx, gy, *CL, **kwargs)
             for c in cont.collections:
                 c.set_transform(self._parent_axes.transData)
 
         return cont
 
     def contour(self, *XYCL, **kwargs):
-        return self._contour("contour", *XYCL, **kwargs)
+        return self._contour(super().contour, *XYCL, **kwargs)
 
     def contourf(self, *XYCL, **kwargs):
-        return self._contour("contourf", *XYCL, **kwargs)
+        return self._contour(super().contourf, *XYCL, **kwargs)
 
     def apply_aspect(self, position=None):
         self.update_viewlim()
-        self._get_base_axes_attr("apply_aspect")(self)
-        #ParasiteAxes.apply_aspect()
+        super().apply_aspect()
 
 
 @functools.lru_cache(None)
@@ -209,10 +196,10 @@ def _get_handles(ax):
     return handles
 
 
-class HostAxesBase(object):
+class HostAxesBase:
     def __init__(self, *args, **kwargs):
         self.parasites = []
-        self._get_base_axes_attr("__init__")(self, *args, **kwargs)
+        super().__init__(*args, **kwargs)
 
     def get_aux_axes(self, tr, viewlim_mode="equal", axes_class=None):
         parasite_axes_class = parasite_axes_auxtrans_class_factory(axes_class)
@@ -224,13 +211,9 @@ def get_aux_axes(self, tr, viewlim_mode="equal", axes_class=None):
         return ax2
 
     def _get_legend_handles(self, legend_handler_map=None):
-        # don't use this!
-        Axes_get_legend_handles = self._get_base_axes_attr("_get_legend_handles")
-        all_handles = list(Axes_get_legend_handles(self, legend_handler_map))
-
+        all_handles = super()._get_legend_handles()
         for ax in self.parasites:
             all_handles.extend(ax._get_legend_handles(legend_handler_map))
-
         return all_handles
 
     def draw(self, renderer):
@@ -257,14 +240,14 @@ def draw(self, renderer):
             self.images.extend(images)
             self.artists.extend(artists)
 
-        self._get_base_axes_attr("draw")(self, renderer)
+        super().draw(renderer)
         self.artists = orig_artists
         self.images = orig_images
 
     def cla(self):
         for ax in self.parasites:
             ax.cla()
-        self._get_base_axes_attr("cla")(self)
+        super().cla()
 
     def twinx(self, axes_class=None):
         """
@@ -361,15 +344,10 @@ def _remove_method(h):
         return ax2
 
     def get_tightbbox(self, renderer, call_axes_locator=True):
-
         bbs = [ax.get_tightbbox(renderer, call_axes_locator)
                for ax in self.parasites]
-        get_tightbbox = self._get_base_axes_attr("get_tightbbox")
-        bbs.append(get_tightbbox(self, renderer, call_axes_locator))
-
-        _bbox = Bbox.union([b for b in bbs if b.width!=0 or b.height!=0])
-
-        return _bbox
+        bbs.append(super().get_tightbbox(renderer, call_axes_locator))
+        return Bbox.union([b for b in bbs if b.width!=0 or b.height!=0])
 
 
 @functools.lru_cache(None)
@@ -380,13 +358,9 @@ def host_axes_class_factory(axes_class=None):
     def _get_base_axes(self):
         return axes_class
 
-    def _get_base_axes_attr(self, attrname):
-        return getattr(axes_class, attrname)
-
     return type("%sHostAxes" % axes_class.__name__,
                 (HostAxesBase, axes_class),
-                {'_get_base_axes_attr': _get_base_axes_attr,
-                 '_get_base_axes': _get_base_axes})
+                {'_get_base_axes': _get_base_axes})
 
 
 def host_subplot_class_factory(axes_class):
