Remove deprecated 'smart bounds' functionality.

QuLogic · QuLogic · commit 01b3e5130103 · 2020-12-14T23:59:37.000-05:00
diff --git a/doc/api/axis_api.rst b/doc/api/axis_api.rst
@@ -226,8 +226,6 @@ Other
    Axis.limit_range_for_scale
    Axis.reset_ticks
    Axis.set_default_intervals
-   Axis.get_smart_bounds
-   Axis.set_smart_bounds
 
 Discouraged
 -----------
diff --git a/doc/api/next_api_changes/removals/18747-ES.rst b/doc/api/next_api_changes/removals/18747-ES.rst
@@ -16,3 +16,12 @@
 
 - ``quiver.QuiverKey.quiverkey_doc`` has been removed; use
   ``quiver.QuiverKey.__init__.__doc__`` instead.
+
+Smart bounds
+~~~~~~~~~~~~
+
+The "smart bounds" functionality on `~.axis.Axis` and `.Spine` has been
+deleted, and the following methods are removed:
+
+- ``Axis.set_smart_bounds`` and ``Axis.get_smart_bounds``
+- ``Spine.set_smart_bounds`` and ``Spine.get_smart_bounds``
diff --git a/lib/matplotlib/axis.py b/lib/matplotlib/axis.py
@@ -673,7 +673,6 @@ def __init__(self, axes, pickradius=15):
         self.callbacks = cbook.CallbackRegistry()
 
         self._autolabelpos = True
-        self._smart_bounds = False  # Deprecated in 3.2
 
         self.label = mtext.Text(
             np.nan, np.nan,
@@ -1010,17 +1009,6 @@ def get_ticklabel_extents(self, renderer):
             bbox2 = mtransforms.Bbox.from_extents(0, 0, 0, 0)
         return bbox, bbox2
 
-    @_api.deprecated("3.2")
-    def set_smart_bounds(self, value):
-        """Set the axis to have smart bounds."""
-        self._smart_bounds = value
-        self.stale = True
-
-    @_api.deprecated("3.2")
-    def get_smart_bounds(self):
-        """Return whether the axis has smart bounds."""
-        return self._smart_bounds
-
     def _update_ticks(self):
         """
         Update ticks (position and labels) using the current data interval of
@@ -1048,36 +1036,6 @@ def _update_ticks(self):
         if view_low > view_high:
             view_low, view_high = view_high, view_low
 
-        if self._smart_bounds and ticks:  # _smart_bounds is deprecated in 3.2
-            # handle inverted limits
-            data_low, data_high = sorted(self.get_data_interval())
-            locs = np.sort([tick.get_loc() for tick in ticks])
-            if data_low <= view_low:
-                # data extends beyond view, take view as limit
-                ilow = view_low
-            else:
-                # data stops within view, take best tick
-                good_locs = locs[locs <= data_low]
-                if len(good_locs):
-                    # last tick prior or equal to first data point
-                    ilow = good_locs[-1]
-                else:
-                    # No ticks (why not?), take first tick
-                    ilow = locs[0]
-            if data_high >= view_high:
-                # data extends beyond view, take view as limit
-                ihigh = view_high
-            else:
-                # data stops within view, take best tick
-                good_locs = locs[locs >= data_high]
-                if len(good_locs):
-                    # first tick after or equal to last data point
-                    ihigh = good_locs[0]
-                else:
-                    # No ticks (why not?), take last tick
-                    ihigh = locs[-1]
-            ticks = [tick for tick in ticks if ilow <= tick.get_loc() <= ihigh]
-
         interval_t = self.get_transform().transform([view_low, view_high])
 
         ticks_to_draw = []
diff --git a/lib/matplotlib/spines.py b/lib/matplotlib/spines.py
@@ -61,7 +61,6 @@ def __init__(self, axes, spine_type, path, **kwargs):
         self.set_transform(self.axes.transData)  # default transform
 
         self._bounds = None  # default bounds
-        self._smart_bounds = False  # deprecated in 3.2
 
         # Defer initial position determination. (Not much support for
         # non-rectangular axes is currently implemented, and this lets
@@ -82,23 +81,6 @@ def __init__(self, axes, spine_type, path, **kwargs):
         # Note: This cannot be calculated until this is added to an Axes
         self._patch_transform = mtransforms.IdentityTransform()
 
-    @_api.deprecated("3.2")
-    def set_smart_bounds(self, value):
-        """Set the spine and associated axis to have smart bounds."""
-        self._smart_bounds = value
-
-        # also set the axis if possible
-        if self.spine_type in ('left', 'right'):
-            self.axes.yaxis.set_smart_bounds(value)
-        elif self.spine_type in ('top', 'bottom'):
-            self.axes.xaxis.set_smart_bounds(value)
-        self.stale = True
-
-    @_api.deprecated("3.2")
-    def get_smart_bounds(self):
-        """Return whether the spine has smart bounds."""
-        return self._smart_bounds
-
     def set_patch_arc(self, center, radius, theta1, theta2):
         """Set the spine to be arc-like."""
         self._patch_type = 'arc'
@@ -247,64 +229,14 @@ def _adjust_location(self):
         if self.spine_type == 'circle':
             return
 
-        if self._bounds is None:
-            if self.spine_type in ('left', 'right'):
-                low, high = self.axes.viewLim.intervaly
-            elif self.spine_type in ('top', 'bottom'):
-                low, high = self.axes.viewLim.intervalx
-            else:
-                raise ValueError('unknown spine spine_type: %s' %
-                                 self.spine_type)
-
-            if self._smart_bounds:  # deprecated in 3.2
-                # attempt to set bounds in sophisticated way
-
-                # handle inverted limits
-                viewlim_low, viewlim_high = sorted([low, high])
-
-                if self.spine_type in ('left', 'right'):
-                    datalim_low, datalim_high = self.axes.dataLim.intervaly
-                    ticks = self.axes.get_yticks()
-                elif self.spine_type in ('top', 'bottom'):
-                    datalim_low, datalim_high = self.axes.dataLim.intervalx
-                    ticks = self.axes.get_xticks()
-                # handle inverted limits
-                ticks = np.sort(ticks)
-                datalim_low, datalim_high = sorted([datalim_low, datalim_high])
-
-                if datalim_low < viewlim_low:
-                    # Data extends past view. Clip line to view.
-                    low = viewlim_low
-                else:
-                    # Data ends before view ends.
-                    cond = (ticks <= datalim_low) & (ticks >= viewlim_low)
-                    tickvals = ticks[cond]
-                    if len(tickvals):
-                        # A tick is less than or equal to lowest data point.
-                        low = tickvals[-1]
-                    else:
-                        # No tick is available
-                        low = datalim_low
-                    low = max(low, viewlim_low)
-
-                if datalim_high > viewlim_high:
-                    # Data extends past view. Clip line to view.
-                    high = viewlim_high
-                else:
-                    # Data ends before view ends.
-                    cond = (ticks >= datalim_high) & (ticks <= viewlim_high)
-                    tickvals = ticks[cond]
-                    if len(tickvals):
-                        # A tick is greater than or equal to highest data
-                        # point.
-                        high = tickvals[0]
-                    else:
-                        # No tick is available
-                        high = datalim_high
-                    high = min(high, viewlim_high)
-
-        else:
+        if self._bounds is not None:
             low, high = self._bounds
+        elif self.spine_type in ('left', 'right'):
+            low, high = self.axes.viewLim.intervaly
+        elif self.spine_type in ('top', 'bottom'):
+            low, high = self.axes.viewLim.intervalx
+        else:
+            raise ValueError(f'unknown spine spine_type: {self.spine_type}')
 
         if self._patch_type == 'arc':
             if self.spine_type in ('bottom', 'top'):
