Simplify units.Registry.get_converter.

anntzer · anntzer · commit 73084867db3a · 2017-10-07T22:27:27.000-07:00
The caching of the converter was disabled 10 years ago (be73ef4) and is unlikely to ever work as the correct converter for ndarrays depends on the type of the contents, not on the container, so just drop the cache-related code. When a masked array is passed, it's OK to just get the first underlying data, even if it is masked (as it should have the same type as the unmasked entries), for the purpose of getting the converter.
diff --git a/lib/matplotlib/units.py b/lib/matplotlib/units.py
@@ -51,8 +51,8 @@ def default_units(x, axis):
 
 
 class AxisInfo(object):
-    """information to support default axis labeling and tick labeling, and
-       default limits"""
+    """Information to support default axis labeling, tick labeling, and limits.
+    """
     def __init__(self, majloc=None, minloc=None,
                  majfmt=None, minfmt=None, label=None,
                  default_limits=None):
@@ -78,20 +78,21 @@ class ConversionInterface(object):
     """
     @staticmethod
     def axisinfo(unit, axis):
-        'return an units.AxisInfo instance for axis with the specified units'
+        """Return an `AxisInfo` instance for *axis* with the specified *unit*.
+        """
         return None
 
     @staticmethod
     def default_units(x, axis):
-        'return the default unit for x or None for the given axis'
+        """Return the default unit for *x* or ``None`` for the given *axis*."""
         return None
 
     @staticmethod
     def convert(obj, unit, axis):
-        """
-        convert obj using unit for the specified axis.  If obj is a sequence,
-        return the converted sequence.  The output must be a sequence of
-        scalars that can be used by the numpy array layer
+        """Convert *obj* using *unit* for the specified *axis*.
+
+        If *obj* is a sequence, return the converted sequence.  The output must
+        be a sequence of scalars that can be used by the numpy array layer
         """
         return obj
 
@@ -102,7 +103,7 @@ def is_numlike(x):
         scalars which are the units converted to floats given the
         current unit.  The converter may be passed these floats, or
         arrays of them, even when units are set.  Derived conversion
-        interfaces may opt to pass plain-ol unitless numbers through
+        interfaces may opt to pass plain-old unitless numbers through
         the conversion interface and this is a helper function for
         them.
         """
@@ -114,61 +115,28 @@ def is_numlike(x):
 
 
 class Registry(dict):
-    """
-    register types with conversion interface
-    """
-    def __init__(self):
-        dict.__init__(self)
-        self._cached = {}
+    """Register types with conversion interface."""
 
     def get_converter(self, x):
-        'get the converter interface instance for x, or None'
-
-        if not len(self):
-            return None  # nothing registered
-        # DISABLED idx = id(x)
-        # DISABLED cached = self._cached.get(idx)
-        # DISABLED if cached is not None: return cached
-
-        converter = None
-        classx = getattr(x, '__class__', None)
-
-        if classx is not None:
-            converter = self.get(classx)
-
-        if isinstance(x, np.ndarray) and x.size:
-            xravel = x.ravel()
+        """Get the converter interface instance for *x*, or None."""
+        if isinstance(x, np.ndarray):
+            # In case x in a masked array, access the underlying data (only its
+            # type matters).  If x is a regular ndarray, getdata() just returns
+            # the array itself.
+            x = np.ma.getdata(x).ravel()
+        try:
+            return self[type(x)]
+        except KeyError:
             try:
-                # pass the first value of x that is not masked back to
-                # get_converter
-                if not np.all(xravel.mask):
-                    # some elements are not masked
-                    converter = self.get_converter(
-                        xravel[np.argmin(xravel.mask)])
-                    return converter
-            except AttributeError:
-                # not a masked_array
-                # Make sure we don't recurse forever -- it's possible for
-                # ndarray subclasses to continue to return subclasses and
-                # not ever return a non-subclass for a single element.
-                next_item = xravel[0]
-                if (not isinstance(next_item, np.ndarray) or
-                    next_item.shape != x.shape):
-                    converter = self.get_converter(next_item)
-                return converter
-
-        if converter is None:
-            try:
-                thisx = safe_first_element(x)
+                first = safe_first_element(x)
             except (TypeError, StopIteration):
                 pass
             else:
-                if classx and classx != getattr(thisx, '__class__', None):
-                    converter = self.get_converter(thisx)
-                    return converter
-
-        # DISABLED self._cached[idx] = converter
-        return converter
+                # Avoid infinite recursion for pathological iterables for which
+                # indexing returns instances of the same iterable class.
+                if type(first) is not type(x):
+                    return self.get_converter(first)
+        return None
 
 
 registry = Registry()
