Code review updates

Author: scottshambaugh

lib/matplotlib/axes/_base.py

@@ -3027,46 +3027,42 @@ def autoscale_view(self, tight=None, scalex=True, scaley=True):
         if tight is not None:
             self._tight = bool(tight)
 
-        x_shared = self._shared_axes["x"].get_siblings(self)
-        y_shared = self._shared_axes["y"].get_siblings(self)
+        x_shared_axes = self._shared_axes["x"].get_siblings(self)
+        y_shared_axes = self._shared_axes["y"].get_siblings(self)
 
         x_stickies = y_stickies = np.array([])
         if self.use_sticky_edges:
-            # Use ._children and ._sticky_edges directly, because most extra
-            # artists in .get_children() (spines, titles, etc.) never have
-            # sticky edges. We also check axis objects since they can have
-            # sticky edges (e.g. polar RadialAxis).
             if self._xmargin and scalex and self.get_autoscalex_on():
-                x_sticky_lists = []
-                for ax in x_shared:
-                    for artist in (*ax._children, *ax._axis_map.values()):
+                x_sticky = []
+                for ax in x_shared_axes:
+                    for artist in ax._get_data_children():
                         sticky_edges = artist._sticky_edges
                         if sticky_edges is not None and sticky_edges.x:
-                            x_sticky_lists.append(sticky_edges.x)
-                if x_sticky_lists:
-                    x_stickies = np.sort(np.concatenate(x_sticky_lists))
+                            x_sticky.extend(sticky_edges.x)
+                if x_sticky:
+                    x_stickies = np.sort(x_sticky)
             if self._ymargin and scaley and self.get_autoscaley_on():
-                y_sticky_lists = []
-                for ax in y_shared:
-                    for artist in (*ax._children, *ax._axis_map.values()):
+                y_sticky = []
+                for ax in y_shared_axes:
+                    for artist in ax._get_data_children():
                         sticky_edges = artist._sticky_edges
                         if sticky_edges is not None and sticky_edges.y:
-                            y_sticky_lists.append(sticky_edges.y)
-                if y_sticky_lists:
-                    y_stickies = np.sort(np.concatenate(y_sticky_lists))
+                            y_sticky.extend(sticky_edges.y)
+                if y_sticky:
+                    y_stickies = np.sort(y_sticky)
         if self.get_xscale() == 'log':
             x_stickies = x_stickies[x_stickies > 0]
         if self.get_yscale() == 'log':
             y_stickies = y_stickies[y_stickies > 0]
 
         def handle_single_axis(
-                scale, shared, name, axis, margin, stickies, set_bound):
+                scale, shared_axes, name, axis, margin, stickies, set_bound):
 
             if not (scale and axis._get_autoscale_on()):
                 return  # nothing to do...
             # Base autoscaling on finite data limits when there is at least one
             # finite data limit among all the shared_axes and intervals.
-            values = [val for ax in shared
+            values = [val for ax in shared_axes
                       for val in getattr(ax.dataLim, f"interval{name}")
                       if np.isfinite(val)]
             if values:
@@ -3082,13 +3078,14 @@ def handle_single_axis(
             x0, x1 = locator.nonsingular(x0, x1)
             # Find the minimum minpos for use in the margin calculation.
             minimum_minpos = min(
-                getattr(ax.dataLim, f"minpos{name}") for ax in shared)
+                getattr(ax.dataLim, f"minpos{name}") for ax in shared_axes)
 
             # Prevent margin addition from crossing a sticky value.  A small
             # tolerance must be added due to floating point issues with
             # streamplot; it is defined relative to x1-x0 but has
             # no absolute term (e.g. "+1e-8") to avoid issues when working with
             # datasets where all values are tiny (less than 1e-8).
+            x0bound = x1bound = None
             if len(stickies):
                 tol = 1e-5 * abs(x1 - x0)
                 # Index of largest element < x0 + tol, if any.
@@ -3097,8 +3094,6 @@ def handle_single_axis(
                 # Index of smallest element > x1 - tol, if any.
                 i1 = stickies.searchsorted(x1 - tol)
                 x1bound = stickies[i1] if i1 != len(stickies) else None
-            else:
-                x0bound = x1bound = None
 
             # Add the margin in figure space and then transform back, to handle
             # non-linear scales.
@@ -3123,10 +3118,10 @@ def handle_single_axis(
             # End of definition of internal function 'handle_single_axis'.
 
         handle_single_axis(
-            scalex, x_shared, 'x', self.xaxis, self._xmargin,
+            scalex, x_shared_axes, 'x', self.xaxis, self._xmargin,
             x_stickies, self.set_xbound)
         handle_single_axis(
-            scaley, y_shared, 'y', self.yaxis, self._ymargin,
+            scaley, y_shared_axes, 'y', self.yaxis, self._ymargin,
             y_stickies, self.set_ybound)
 
     def _update_title_position(self, renderer):
@@ -4529,6 +4524,20 @@ def drag_pan(self, button, key, x, y):
             self.set_xlim(points[:, 0])
             self.set_ylim(points[:, 1])
 
+    def _get_data_children(self):
+        """
+        Return artists that represent data (plot lines, collections, images,
+        patches, etc.) as opposed to auxiliary artists needed to draw the
+        Axes itself (spines, titles, axis objects, etc.).
+
+        Data children are the artists that can contribute to autoscaling
+        and sticky edges.
+
+        Note: This is a preliminary definition and has not been thought
+        through completely. We may want to revise this later.
+        """
+        return [*self._children, *self._axis_map.values()]
+
     def get_children(self):
         # docstring inherited.
         return [