Switch to a private, simpler AxesStack.

anntzer · anntzer · commit 114362143a4a · 2016-11-10T17:33:57.000-08:00
The current implementation of AxesStack subclasses cbook.Stack, which
requires hashable keys, which leads to additional complexity on the
caller's side (`_make_key`).

Instead, switch to using two lists (keys and axes) and relying on
`list.index`, which makes the implementation much simpler.

Also make the new class private and deprecate the previous one.
diff --git a/lib/matplotlib/figure.py b/lib/matplotlib/figure.py
@@ -16,8 +16,8 @@
 
 import six
 
-import warnings
 from operator import itemgetter
+import warnings
 
 import numpy as np
 
@@ -73,6 +73,7 @@ class AxesStack(Stack):
 
     """
     def __init__(self):
+        cbook.warn_deprecated("2.0")
         Stack.__init__(self)
         self._ind = 0
 
@@ -157,6 +158,62 @@ def __contains__(self, a):
         return a in self.as_list()
 
 
+class _AxesStack(object):
+    """Lightweight stack that tracks Axes in a Figure.
+    """
+
+    def __init__(self):
+        # We maintain a list of (creation_index, key, axes) tuples.
+        # We do not use an OrderedDict because 1. the keys may not be hashable
+        # and 2. we need to directly find a pair corresponding to an axes (i.e.
+        # we'd really need a two-way dict).
+        self._items = []
+        self._created = 0
+
+    def as_list(self):
+        """Copy of the list of axes, in the order of insertion.
+        """
+        return [ax for _, _, ax in sorted(self._items)]
+
+    def get(self, key):
+        """Find the axes corresponding to a key; defaults to `None`.
+        """
+        return next((ax for _, k, ax in self._items if k == key), None)
+
+    def current_key_axes(self):
+        """Return the topmost `(key, axes)` pair, or `(None, None)` if empty.
+        """
+        _, key, ax = (self._items or [(None, None, None)])[-1]
+        return key, ax
+
+    def add(self, key, ax):
+        """Append a `(key, axes)` pair, unless the axes are already present.
+        """
+        # Skipping existing Axes is needed to support calling `add_axes` with
+        # an already existing Axes.
+        if not any(a == ax for _, _, a in self._items):
+            self._items.append((self._created, key, ax))
+            self._created += 1
+
+    def bubble(self, ax):
+        """Move an axes and its corresponding key to the top.
+        """
+        idx, = (idx for idx, (_, _, a) in enumerate(self._items) if a == ax)
+        self._items.append(self._items[idx])
+        del self._items[idx]
+
+    def remove(self, ax):
+        """Remove an axes and its corresponding key.
+        """
+        idx, = (idx for idx, (_, _, a) in enumerate(self._items) if a == ax)
+        del self._items[idx]
+
+    def clear(self):
+        """Clear the stack.
+        """
+        del self._items[:]
+
+
 class SubplotParams(object):
     """
     A class to hold the parameters for a subplot
@@ -350,7 +407,7 @@ def __init__(self,
         self.subplotpars = subplotpars
         self.set_tight_layout(tight_layout)
 
-        self._axstack = AxesStack()  # track all figure axes and current axes
+        self._axstack = _AxesStack()  # track all figure axes and current axes
         self.clf()
         self._cachedRenderer = None
 
@@ -398,10 +455,8 @@ def show(self, warn=True):
                 "matplotlib is currently using a non-GUI backend, "
                 "so cannot show the figure")
 
-    def _get_axes(self):
-        return self._axstack.as_list()
-
-    axes = property(fget=_get_axes, doc="Read-only: list of axes in Figure")
+    axes = property(lambda self: self._axstack.as_list(),
+                    doc="Read-only: list of axes in Figure")
 
     def _get_dpi(self):
         return self._dpi
@@ -812,36 +867,6 @@ def delaxes(self, a):
             func(self)
         self.stale = True
 
-    def _make_key(self, *args, **kwargs):
-        'make a hashable key out of args and kwargs'
-
-        def fixitems(items):
-            #items may have arrays and lists in them, so convert them
-            # to tuples for the key
-            ret = []
-            for k, v in items:
-                # some objects can define __getitem__ without being
-                # iterable and in those cases the conversion to tuples
-                # will fail. So instead of using the iterable(v) function
-                # we simply try and convert to a tuple, and proceed if not.
-                try:
-                    v = tuple(v)
-                except Exception:
-                    pass
-                ret.append((k, v))
-            return tuple(ret)
-
-        def fixlist(args):
-            ret = []
-            for a in args:
-                if iterable(a):
-                    a = tuple(a)
-                ret.append(a)
-            return tuple(ret)
-
-        key = fixlist(args), fixitems(six.iteritems(kwargs))
-        return key
-
     @docstring.dedent_interpd
     def add_axes(self, *args, **kwargs):
         """
@@ -895,9 +920,9 @@ def add_axes(self, *args, **kwargs):
 
         # shortcut the projection "key" modifications later on, if an axes
         # with the exact args/kwargs exists, return it immediately.
-        key = self._make_key(*args, **kwargs)
+        key = (args, kwargs)
         ax = self._axstack.get(key)
-        if ax is not None:
+        if ax:
             self.sca(ax)
             return ax
 
@@ -914,7 +939,7 @@ def add_axes(self, *args, **kwargs):
             # check that an axes of this type doesn't already exist, if it
             # does, set it as active and return it
             ax = self._axstack.get(key)
-            if ax is not None and isinstance(ax, projection_class):
+            if isinstance(ax, projection_class):
                 self.sca(ax)
                 return ax
 
@@ -988,15 +1013,14 @@ def add_subplot(self, *args, **kwargs):
                 raise ValueError(msg)
             # make a key for the subplot (which includes the axes object id
             # in the hash)
-            key = self._make_key(*args, **kwargs)
+            key = (args, kwargs)
         else:
             projection_class, kwargs, key = process_projection_requirements(
                 self, *args, **kwargs)
 
             # try to find the axes with this key in the stack
             ax = self._axstack.get(key)
-
-            if ax is not None:
+            if ax:
                 if isinstance(ax, projection_class):
                     # the axes already existed, so set it as active & return
                     self.sca(ax)
@@ -1496,7 +1520,7 @@ def _gci(self):
         do not use elsewhere.
         """
         # Look first for an image in the current Axes:
-        cax = self._axstack.current_key_axes()[1]
+        ckey, cax = self._axstack.current_key_axes()
         if cax is None:
             return None
         im = cax._gci()
diff --git a/lib/matplotlib/projections/__init__.py b/lib/matplotlib/projections/__init__.py
@@ -103,11 +103,7 @@ def process_projection_requirements(figure, *args, **kwargs):
         raise TypeError('projection must be a string, None or implement a '
                             '_as_mpl_axes method. Got %r' % projection)
 
-    # Make the key without projection kwargs, this is used as a unique
-    # lookup for axes instances
-    key = figure._make_key(*args, **kwargs)
-
-    return projection_class, kwargs, key
+    return projection_class, kwargs, (args, kwargs)
 
 
 def get_projection_names():
