Factor out common limits handling for x/y/z axes.

The change in set_top_view is necessary because super().set_xlim no
longer goes to 2D semantics (it's on the Axis.set_view_limits that one
would need to do a supercall), but in any case the old behavior was
actually more buggy because it would e.g. confuse data-limits sharex and
2D projection sharex; e.g.
`subplots(1, 2, sharex=True, subplot_kw={"projection": "3d"})`
was previously wrong.

As a side effect, also fixes `invert_yaxis`/`invert_zaxis` on 3d axises
(because they just go to the base `Axis.set_inverted`).

Author: anntzer

lib/matplotlib/axes/_base.py

@@ -3654,9 +3654,8 @@ def set_xlim(self, left=None, right=None, emit=True, auto=False,
             False turns off, None leaves unchanged.
 
         xmin, xmax : float, optional
-            They are equivalent to left and right respectively,
-            and it is an error to pass both *xmin* and *left* or
-            *xmax* and *right*.
+            They are equivalent to left and right respectively, and it is an
+            error to pass both *xmin* and *left* or *xmax* and *right*.
 
         Returns
         -------
@@ -3691,76 +3690,10 @@ def set_xlim(self, left=None, right=None, emit=True, auto=False,
         present is on the right.
 
         >>> set_xlim(5000, 0)
-
         """
-        if right is None and np.iterable(left):
-            left, right = left
-        if xmin is not None:
-            if left is not None:
-                raise TypeError('Cannot pass both `xmin` and `left`')
-            left = xmin
-        if xmax is not None:
-            if right is not None:
-                raise TypeError('Cannot pass both `xmax` and `right`')
-            right = xmax
-
-        self._process_unit_info([("x", (left, right))], convert=False)
-        left = self._validate_converted_limits(left, self.convert_xunits)
-        right = self._validate_converted_limits(right, self.convert_xunits)
-
-        if left is None or right is None:
-            # Axes init calls set_xlim(0, 1) before get_xlim() can be called,
-            # so only grab the limits if we really need them.
-            old_left, old_right = self.get_xlim()
-            if left is None:
-                left = old_left
-            if right is None:
-                right = old_right
-
-        if self.get_xscale() == 'log' and (left <= 0 or right <= 0):
-            # Axes init calls set_xlim(0, 1) before get_xlim() can be called,
-            # so only grab the limits if we really need them.
-            old_left, old_right = self.get_xlim()
-            if left <= 0:
-                _api.warn_external(
-                    'Attempted to set non-positive left xlim on a '
-                    'log-scaled axis.\n'
-                    'Invalid limit will be ignored.')
-                left = old_left
-            if right <= 0:
-                _api.warn_external(
-                    'Attempted to set non-positive right xlim on a '
-                    'log-scaled axis.\n'
-                    'Invalid limit will be ignored.')
-                right = old_right
-        if left == right:
-            _api.warn_external(
-                f"Attempting to set identical left == right == {left} results "
-                f"in singular transformations; automatically expanding.")
-        reverse = left > right
-        left, right = self.xaxis.get_major_locator().nonsingular(left, right)
-        left, right = self.xaxis.limit_range_for_scale(left, right)
-        # cast to bool to avoid bad interaction between python 3.8 and np.bool_
-        left, right = sorted([left, right], reverse=bool(reverse))
-
-        self._viewLim.intervalx = (left, right)
-        # Mark viewlims as no longer stale without triggering an autoscale.
-        for ax in self._shared_axes["x"].get_siblings(self):
-            ax._stale_viewlims["x"] = False
-        if auto is not None:
-            self._autoscaleXon = bool(auto)
-
-        if emit:
-            self.callbacks.process('xlim_changed', self)
-            # Call all of the other x-axes that are shared with this one
-            for other in self._shared_axes["x"].get_siblings(self):
-                if other is not self:
-                    other.set_xlim(self.viewLim.intervalx,
-                                   emit=False, auto=auto)
-                    if other.figure != self.figure:
-                        other.figure.canvas.draw_idle()
-        self.stale = True
-        return left, right
+        return self.xaxis._set_lim(
+            left, right, xmin, xmax, emit=emit, auto=auto,
+            names=("left", "right"))
 
     get_xscale = _axis_method_wrapper("xaxis", "get_scale")
 
@@ -3985,9 +3918,8 @@ def set_ylim(self, bottom=None, top=None, emit=True, auto=False,
             *False* turns off, *None* leaves unchanged.
 
         ymin, ymax : float, optional
-            They are equivalent to bottom and top respectively,
-            and it is an error to pass both *ymin* and *bottom* or
-            *ymax* and *top*.
+            They are equivalent to bottom and top respectively, and it is an
+            error to pass both *ymin* and *bottom* or *ymax* and *top*.
 
         Returns
         -------
@@ -4023,75 +3955,9 @@ def set_ylim(self, bottom=None, top=None, emit=True, auto=False,
 
         >>> set_ylim(5000, 0)
         """
-        if top is None and np.iterable(bottom):
-            bottom, top = bottom
-        if ymin is not None:
-            if bottom is not None:
-                raise TypeError('Cannot pass both `ymin` and `bottom`')
-            bottom = ymin
-        if ymax is not None:
-            if top is not None:
-                raise TypeError('Cannot pass both `ymax` and `top`')
-            top = ymax
-
-        self._process_unit_info([("y", (bottom, top))], convert=False)
-        bottom = self._validate_converted_limits(bottom, self.convert_yunits)
-        top = self._validate_converted_limits(top, self.convert_yunits)
-
-        if bottom is None or top is None:
-            # Axes init calls set_ylim(0, 1) before get_ylim() can be called,
-            # so only grab the limits if we really need them.
-            old_bottom, old_top = self.get_ylim()
-            if bottom is None:
-                bottom = old_bottom
-            if top is None:
-                top = old_top
-
-        if self.get_yscale() == 'log' and (bottom <= 0 or top <= 0):
-            # Axes init calls set_xlim(0, 1) before get_xlim() can be called,
-            # so only grab the limits if we really need them.
-            old_bottom, old_top = self.get_ylim()
-            if bottom <= 0:
-                _api.warn_external(
-                    'Attempted to set non-positive bottom ylim on a '
-                    'log-scaled axis.\n'
-                    'Invalid limit will be ignored.')
-                bottom = old_bottom
-            if top <= 0:
-                _api.warn_external(
-                    'Attempted to set non-positive top ylim on a '
-                    'log-scaled axis.\n'
-                    'Invalid limit will be ignored.')
-                top = old_top
-        if bottom == top:
-            _api.warn_external(
-                f"Attempting to set identical bottom == top == {bottom} "
-                f"results in singular transformations; automatically "
-                f"expanding.")
-        reverse = bottom > top
-        bottom, top = self.yaxis.get_major_locator().nonsingular(bottom, top)
-        bottom, top = self.yaxis.limit_range_for_scale(bottom, top)
-        # cast to bool to avoid bad interaction between python 3.8 and np.bool_
-        bottom, top = sorted([bottom, top], reverse=bool(reverse))
-
-        self._viewLim.intervaly = (bottom, top)
-        # Mark viewlims as no longer stale without triggering an autoscale.
-        for ax in self._shared_axes["y"].get_siblings(self):
-            ax._stale_viewlims["y"] = False
-        if auto is not None:
-            self._autoscaleYon = bool(auto)
-
-        if emit:
-            self.callbacks.process('ylim_changed', self)
-            # Call all of the other y-axes that are shared with this one
-            for other in self._shared_axes["y"].get_siblings(self):
-                if other is not self:
-                    other.set_ylim(self.viewLim.intervaly,
-                                   emit=False, auto=auto)
-                    if other.figure != self.figure:
-                        other.figure.canvas.draw_idle()
-        self.stale = True
-        return bottom, top
+        return self.yaxis._set_lim(
+            bottom, top, ymin, ymax, emit=emit, auto=auto,
+            names=("bottom", "top"))
 
     get_yscale = _axis_method_wrapper("yaxis", "get_scale")
 

lib/matplotlib/axis.py

@@ -1004,10 +1004,9 @@ def set_inverted(self, inverted):
         the top for the y-axis; the "inverse" direction is increasing to the
         left for the x-axis and to the bottom for the y-axis.
         """
-        # Currently, must be implemented in subclasses using set_xlim/set_ylim
-        # rather than generically using set_view_interval, so that shared
-        # axes get updated as well.
-        raise NotImplementedError('Derived must override')
+        a, b = self.get_view_interval()
+        # cast to bool to avoid bad interaction between python 3.8 and np.bool_
+        self._set_lim(*sorted((a, b), reverse=bool(inverted)), auto=None)
 
     def set_default_intervals(self):
         """
@@ -1023,6 +1022,97 @@ def set_default_intervals(self):
         # attribute, and the derived code below will check for that
         # and use it if it's available (else just use 0..1)
 
+    def _set_lim(self, v0, v1, alt0=None, alt1=None, *,
+                 emit=True, auto, names=("", "")):
+        """
+        Set view limits.
+
+        This method is a helper for the Axes ``set_xlim``, ``set_ylim``, and
+        ``set_zlim`` methods.  This docstring uses names corresponding to
+        ``set_xlim`` for simplicity.
+
+        *names* is the pair of the names of the first two parameters of the
+        Axes method (e.g., "left" and "right").  They are only used to generate
+        error messages; and can be empty if the limits are known to be valid.
+
+        Other parameters are directly forwarded from the Axes limits setter:
+        *v0*, *v1*, *alt0*, and *alt1* map to *left*, *right*, *xmin*, and
+        *xmax* respectively; *emit* and *auto* are used as is.
+        """
+        v0name, v1name = names  # The value names.
+        name, = [name for name, axis in self.axes._get_axis_map().items()
+                 if axis is self]  # The axis name.
+
+        if v1 is None and np.iterable(v0):
+            v0, v1 = v0
+        if alt0 is not None:
+            if v0 is not None:
+                raise TypeError(
+                    f"Cannot pass both {v0name!r} and '{name}lim'")
+            v0 = alt0
+        if alt1 is not None:
+            if v1 is not None:
+                raise TypeError(
+                    f"Cannot pass both {v1name!r} and '{name}lim'")
+            v1 = alt1
+
+        self.axes._process_unit_info([(name, (v0, v1))], convert=False)
+        v0 = self.axes._validate_converted_limits(v0, self.convert_units)
+        v1 = self.axes._validate_converted_limits(v1, self.convert_units)
+
+        if v0 is None or v1 is None:
+            # Axes init calls set_xlim(0, 1) before get_xlim() can be called,
+            # so only grab the limits if we really need them.
+            old0, old1 = self.get_view_interval()
+            if v0 is None:
+                v0 = old0
+            if v1 is None:
+                v1 = old1
+
+        if self.get_scale() == 'log' and (v0 <= 0 or v1 <= 0):
+            # Axes init calls set_xlim(0, 1) before get_xlim() can be called,
+            # so only grab the limits if we really need them.
+            old0, old1 = self.get_view_interval()
+            if v0 <= 0:
+                _api.warn_external(
+                    f"Attempt to set non-positive {v0name} {name}lim on a "
+                    f"log-scaled axis will be ignored.")
+                v0 = old0
+            if v1 <= 0:
+                _api.warn_external(
+                    f"Attempt to set non-positive {v1name} {name}lim on a "
+                    f"log-scaled axis will be ignored.")
+                v1 = old1
+        if v0 == v1:
+            _api.warn_external(
+                f"Attempting to set identical {v0name} == {v1name} == {v0} "
+                f"makes transformation singular; automatically expanding.")
+        reverse = v0 > v1
+        v0, v1 = self.get_major_locator().nonsingular(v0, v1)
+        v0, v1 = self.limit_range_for_scale(v0, v1)
+        # cast to bool to avoid bad interaction between python 3.8 and np.bool_
+        v0, v1 = sorted([v0, v1], reverse=bool(reverse))
+
+        self.set_view_interval(v0, v1, ignore=True)
+        # Mark viewlims as no longer stale without triggering an autoscale.
+        for ax in self.axes._shared_axes[name].get_siblings(self.axes):
+            ax._stale_viewlims[name] = False
+        if auto is not None:
+            setattr(self.axes, f"_autoscale{name.upper()}on", bool(auto))
+
+        if emit:
+            self.axes.callbacks.process(f"{name}lim_changed", self.axes)
+            # Call all of the other axes that are shared with this one
+            for other in self.axes._shared_axes[name].get_siblings(self.axes):
+                if other is not self.axes:
+                    other._get_axis_map()[name]._set_lim(
+                        v0, v1, emit=False, auto=auto, names=names)
+                    if other.figure != self.figure:
+                        other.figure.canvas.draw_idle()
+
+        self.stale = True
+        return v0, v1
+
     def _set_artist_props(self, a):
         if a is None:
             return
@@ -2242,12 +2332,6 @@ def get_ticks_position(self):
     def get_minpos(self):
         return self.axes.dataLim.minposx
 
-    def set_inverted(self, inverted):
-        # docstring inherited
-        a, b = self.get_view_interval()
-        # cast to bool to avoid bad interaction between python 3.8 and np.bool_
-        self.axes.set_xlim(sorted((a, b), reverse=bool(inverted)), auto=None)
-
     def set_default_intervals(self):
         # docstring inherited
         # only change view if dataLim has not changed and user has
@@ -2500,12 +2584,6 @@ def get_ticks_position(self):
     def get_minpos(self):
         return self.axes.dataLim.minposy
 
-    def set_inverted(self, inverted):
-        # docstring inherited
-        a, b = self.get_view_interval()
-        # cast to bool to avoid bad interaction between python 3.8 and np.bool_
-        self.axes.set_ylim(sorted((a, b), reverse=bool(inverted)), auto=None)
-
     def set_default_intervals(self):
         # docstring inherited
         # only change view if dataLim has not changed and user has

lib/matplotlib/projections/polar.py

@@ -1194,7 +1194,7 @@ def set_rlim(self, bottom=None, top=None, emit=True, auto=False, **kwargs):
     def set_ylim(self, bottom=None, top=None, emit=True, auto=False,
                  *, ymin=None, ymax=None):
         """
-        Set the data limits for the radial axis.
+        Set the view limits for the radial axis.
 
         Parameters
         ----------
@@ -1227,21 +1227,7 @@ def set_ylim(self, bottom=None, top=None, emit=True, auto=False,
         bottom, top : (float, float)
             The new y-axis limits in data coordinates.
         """
-        if ymin is not None:
-            if bottom is not None:
-                raise ValueError('Cannot supply both positional "bottom" '
-                                 'argument and kwarg "ymin"')
-            else:
-                bottom = ymin
-        if ymax is not None:
-            if top is not None:
-                raise ValueError('Cannot supply both positional "top" '
-                                 'argument and kwarg "ymax"')
-            else:
-                top = ymax
-        if top is None and np.iterable(bottom):
-            bottom, top = bottom[0], bottom[1]
-        return super().set_ylim(bottom=bottom, top=top, emit=emit, auto=auto)
+        return super().set_ylim(bottom, top, emit, auto, ymin=ymin, ymax=ymax)
 
     def get_rlabel_position(self):
         """

lib/matplotlib/tests/test_axes.py

@@ -2591,10 +2591,10 @@ def test_log_scales_no_data():
 def test_log_scales_invalid():
     fig, ax = plt.subplots()
     ax.set_xscale('log')
-    with pytest.warns(UserWarning, match='Attempted to set non-positive'):
+    with pytest.warns(UserWarning, match='Attempt to set non-positive'):
         ax.set_xlim(-1, 10)
     ax.set_yscale('log')
-    with pytest.warns(UserWarning, match='Attempted to set non-positive'):
+    with pytest.warns(UserWarning, match='Attempt to set non-positive'):
         ax.set_ylim(-1, 10)