SubplotParams.validate-associated fixes.

SubplotParams.validate was previously only used in SubplotTool so that
when resetting the SubplotParams, a temporarily invalid SubplotParams
would be ignored.  But the temporary `validate = False` was put at the
wrong place (it should wrap `_on_reset`'s implementation, not its
attachment to `buttonreset`).  Indeed, setting e.g. "left" to 0.0 and
"right" to 0.01 and then pressing reset (when using e.g. tk) would throw
an exception (because "left" would first be reset to 0.125 before
"right" gets reset to 0.9, and the intermediate state is invalid).
Instead, just use the already existing `Widgets.eventson` mechanism to
temporarily disable updates.

Also apply the corresponding change for Qt's own SubplotTool.

Deprecate the then unused (and undocumented) SubplotParams.validate; in
order to keep it writable during the deprecation period, slightly tweak
the implementation of _deprecate_privatize_attribute.

Author: anntzer

doc/api/next_api_changes/deprecations/20170-AL.rst

@@ -0,0 +1,4 @@
+``SubplotParams.validate``
+~~~~~~~~~~~~~~~~~~~~~~~~~~
+... is deprecated.  Use `.SubplotParams.update` to change `.SubplotParams`
+while always keeping it in a valid state.

lib/matplotlib/_api/deprecation.py

@@ -282,18 +282,20 @@ class Foo:
             attr = _deprecate_privatize_attribute(*args, **kwargs)
 
     where *all* parameters are forwarded to `deprecated`.  This form makes
-    ``attr`` a property which forwards access to ``self._attr`` (same name but
-    with a leading underscore), with a deprecation warning.  Note that the
-    attribute name is derived from *the name this helper is assigned to*.  This
-    helper also works for deprecating methods.
+    ``attr`` a property which forwards read and write access to ``self._attr``
+    (same name but with a leading underscore), with a deprecation warning.
+    Note that the attribute name is derived from *the name this helper is
+    assigned to*.  This helper also works for deprecating methods.
     """
 
     def __init__(self, *args, **kwargs):
         self.deprecator = deprecated(*args, **kwargs)
 
     def __set_name__(self, owner, name):
         setattr(owner, name, self.deprecator(
-            property(lambda self: getattr(self, f"_{name}")), name=name))
+            property(lambda self: getattr(self, f"_{name}"),
+                     lambda self, value: setattr(self, f"_{name}", value)),
+            name=name))
 
 
 def rename_parameter(since, old, new, func=None):

lib/matplotlib/backends/backend_qt5.py

@@ -777,12 +777,6 @@ def __init__(self, targetfig, parent):
 
         self._figure = targetfig
 
-        for lower, higher in [("bottom", "top"), ("left", "right")]:
-            self._widgets[lower].valueChanged.connect(
-                lambda val: self._widgets[higher].setMinimum(val + .001))
-            self._widgets[higher].valueChanged.connect(
-                lambda val: self._widgets[lower].setMaximum(val - .001))
-
         self._attrs = ["top", "bottom", "left", "right", "hspace", "wspace"]
         self._defaults = {attr: vars(self._figure.subplotpars)[attr]
                           for attr in self._attrs}
@@ -821,7 +815,12 @@ def _export_values(self):
         dialog.exec_()
 
     def _on_value_changed(self):
-        self._figure.subplots_adjust(**{attr: self._widgets[attr].value()
+        widgets = self._widgets
+        # Set all mins and maxes, so that this can also be used in _reset().
+        for lower, higher in [("bottom", "top"), ("left", "right")]:
+            widgets[higher].setMinimum(widgets[lower].value() + .001)
+            widgets[lower].setMaximum(widgets[higher].value() - .001)
+        self._figure.subplots_adjust(**{attr: widgets[attr].value()
                                         for attr in self._attrs})
         self._figure.canvas.draw_idle()
 
@@ -836,7 +835,12 @@ def _tight_layout(self):
 
     def _reset(self):
         for attr, value in self._defaults.items():
-            self._widgets[attr].setValue(value)
+            widget = self._widgets[attr]
+            widget.setRange(0, 1)
+            widget.blockSignals(True)
+            widget.setValue(value)
+            widget.blockSignals(False)
+        self._on_value_changed()
 
 
 class ToolbarQt(ToolContainerBase, QtWidgets.QToolBar):

lib/matplotlib/figure.py

@@ -120,6 +120,7 @@ class SubplotParams:
     """
     A class to hold the parameters for a subplot.
     """
+
     def __init__(self, left=None, bottom=None, right=None, top=None,
                  wspace=None, hspace=None):
         """
@@ -146,17 +147,20 @@ def __init__(self, left=None, bottom=None, right=None, top=None,
             The height of the padding between subplots,
             as a fraction of the average Axes height.
         """
-        self.validate = True
+        self._validate = True
         for key in ["left", "bottom", "right", "top", "wspace", "hspace"]:
             setattr(self, key, mpl.rcParams[f"figure.subplot.{key}"])
         self.update(left, bottom, right, top, wspace, hspace)
 
+    # Also remove _validate after deprecation elapses.
+    validate = _api.deprecate_privatize_attribute("3.5")
+
     def update(self, left=None, bottom=None, right=None, top=None,
                wspace=None, hspace=None):
         """
         Update the dimensions of the passed parameters. *None* means unchanged.
         """
-        if self.validate:
+        if self._validate:
             if ((left if left is not None else self.left)
                     >= (right if right is not None else self.right)):
                 raise ValueError('left cannot be >= right')

lib/matplotlib/tests/test_api.py

@@ -37,14 +37,19 @@ def f(cls):
 def test_deprecate_privatize_attribute():
     class C:
         def __init__(self): self._attr = 1
-        def _meth(self, arg): pass
+        def _meth(self, arg): return arg
         attr = _api.deprecate_privatize_attribute("0.0")
         meth = _api.deprecate_privatize_attribute("0.0")
 
+    c = C()
     with pytest.warns(_api.MatplotlibDeprecationWarning):
-        C().attr
+        assert c.attr == 1
     with pytest.warns(_api.MatplotlibDeprecationWarning):
-        C().meth(42)
+        c.attr = 2
+    with pytest.warns(_api.MatplotlibDeprecationWarning):
+        assert c.attr == 2
+    with pytest.warns(_api.MatplotlibDeprecationWarning):
+        assert c.meth(42) == 42
 
 
 def test_delete_parameter():

lib/matplotlib/widgets.py

@@ -1402,11 +1402,7 @@ def __init__(self, targetfig, toolfig):
 
         bax = toolfig.add_axes([0.8, 0.05, 0.15, 0.075])
         self.buttonreset = Button(bax, 'Reset')
-
-        # During reset there can be a temporary invalid state depending on the
-        # order of the reset so we turn off validation for the resetting
-        with cbook._setattr_cm(toolfig.subplotpars, validate=False):
-            self.buttonreset.on_clicked(self._on_reset)
+        self.buttonreset.on_clicked(self._on_reset)
 
     def _on_slider_changed(self, _):
         self.targetfig.subplots_adjust(
@@ -1417,17 +1413,19 @@ def _on_slider_changed(self, _):
 
     def _on_reset(self, event):
         with ExitStack() as stack:
-            # Temporarily disable drawing on self and self's sliders.
+            # Temporarily disable drawing on self and self's sliders, and
+            # disconnect slider events (as the subplotparams can be temporarily
+            # invalid, depending on the order in which they are restored).
             stack.enter_context(cbook._setattr_cm(self, drawon=False))
             for slider in self._sliders:
-                stack.enter_context(cbook._setattr_cm(slider, drawon=False))
+                stack.enter_context(
+                    cbook._setattr_cm(slider, drawon=False, eventson=False))
             # Reset the slider to the initial position.
             for slider in self._sliders:
                 slider.reset()
-        # Draw the canvas.
         if self.drawon:
-            event.canvas.draw()
-            self.targetfig.canvas.draw()
+            event.canvas.draw()  # Redraw the subplottool canvas.
+        self._on_slider_changed(None)  # Apply changes to the target window.
 
     axleft = _api.deprecated("3.3")(
         property(lambda self: self.sliderleft.ax))