Qt bugfixes, nbAgg improvements, related pre-processor improvements

Author: lukelbd

proplot/axes.py

@@ -1190,8 +1190,9 @@ def draw(self, renderer=None, *args, **kwargs):
     def get_size_inches(self):
         """Returns the width and the height of the axes in inches."""
         width, height = self.figure.get_size_inches()
-        width = width * abs(self.get_position().width)
-        height = height * abs(self.get_position().height)
+        bbox = self.get_position()
+        width = width * abs(bbox.width)
+        height = height * abs(bbox.height)
         return width, height
 
     def get_tightbbox(self, renderer, *args, **kwargs):

proplot/rctools.py

@@ -953,8 +953,14 @@ def ipython_matplotlib(backend=None, fmt=None):
     Parameters
     ----------
     backend : str, optional
-        The backend name. Use ``'auto'`` to apply ``%matplotlib inline`` for
-        notebooks and ``%matplotlib qt`` for all other sessions.
+        The backend name. The default is ``'auto'``, which applies
+        ``%matplotlib inline`` for notebooks and ``%matplotlib qt`` for
+        all other sessions.
+
+        Note that when using the qt backend on macOS, you may want to prevent
+        "tabbed" figure windows by navigating to Settings...Dock and changing
+        "Prefer tabs when opening documents" to "Manually" (see \
+`Issue #13164 <https://github.com/matplotlib/matplotlib/issues/13164>`__).
     fmt : str or list of str, optional
         The inline backend file format(s). Valid formats include ``'jpg'``,
         ``'png'``, ``'svg'``, ``'pdf'``, and ``'retina'``. This is ignored
@@ -996,8 +1002,9 @@ def ipython_matplotlib(backend=None, fmt=None):
     ipython.magic(f'config InlineBackend.figure_formats = {fmt!r}')
     ipython.magic('config InlineBackend.rc = {}')  # no notebook overrides
     ipython.magic('config InlineBackend.close_figures = True')  # memory issues
-    ipython.magic(  # use proplot tight layout
-        'config InlineBackend.print_figure_kwargs = {"bbox_inches":None}')
+    ipython.magic(  # use ProPlot tight layout instead
+        'config InlineBackend.print_figure_kwargs = {"bbox_inches":None}'
+    )
 
 
 def ipython_autoreload(autoreload=None):

proplot/subplots.py

@@ -456,8 +456,15 @@ def update(self, **kwargs):
         self.set_height_ratios(hratios)
 
         # Validate args
-        kwargs.pop('ncols', None)
-        kwargs.pop('nrows', None)
+        nrows = kwargs.pop('nrows', None)
+        ncols = kwargs.pop('ncols', None)
+        nrows_current, ncols_current = self.get_active_geometry()
+        if (nrows is not None and nrows != nrows_current) or (
+                ncols is not None and ncols != ncols_current):
+            raise ValueError(
+                f'Input geometry {(nrows, ncols)} does not match '
+                f'current geometry {(nrows_current, ncols_current)}.'
+            )
         self.left = kwargs.pop('left', None)
         self.right = kwargs.pop('right', None)
         self.bottom = kwargs.pop('bottom', None)
@@ -476,8 +483,8 @@ def update(self, **kwargs):
 
 def _canvas_preprocess(canvas, method):
     """Return a pre-processer that can be used to override instance-level
-    canvas draw() and print_figure() methods. This applies tight layout and
-    aspect ratio-conserving adjustments and aligns labels. Required so that
+    canvas draw_idle() and print_figure() methods. This applies tight layout
+    and aspect ratio-conserving adjustments and aligns labels. Required so that
     the canvas methods instantiate renderers with the correct dimensions.
     Note that MacOSX currently `cannot be resized \
 <https://github.com/matplotlib/matplotlib/issues/15131>`__."""
@@ -491,28 +498,30 @@ def _canvas_preprocess(canvas, method):
     # override bbox and bbox_inches as *properties*, but these are really
     # complicated, dangerous, and result in unnecessary extra draws.
     def _preprocess(self, *args, **kwargs):
-        if method == 'draw_idle' and self._is_idle_drawing:
-            return  # copied from source code
         fig = self.figure  # update even if not stale! needed after saves
-        if fig.stale and method == 'print_figure':
-            # Needed for displaying already-drawn inline figures, for
-            # some reason tight layout algorithm gets it wrong otherwise.
-            # Concerned that draw_idle() might wait until after
-            # print_figure() is done, so we use draw().
+        if method == 'print_figure':
+            # When re-generating inline figures, the tight layout algorithm
+            # can get figure size *or* spacing wrong unless we force additional
+            # draw! Seems to have no adverse effects when calling savefig.
             self.draw()
-        renderer = fig._get_renderer()  # any renderer will do for now
-        for ax in fig._iter_axes():
-            ax._draw_auto_legends_colorbars()  # may insert panels
-        if rc['backend'] != 'nbAgg':
-            fig._adjust_aspect()  # resizes figure
-            if fig._auto_tight_layout:
-                fig._align_axislabels(False)  # get proper label offset only
-                fig._align_labels(renderer)   # position labels and suptitle
-                fig._adjust_tight_layout(renderer)
-        fig._align_axislabels(True)  # slide spanning labels across
-        fig._align_labels(renderer)  # update figure-relative coordinates!
-        res = getattr(type(self), method)(self, *args, **kwargs)
-        return res
+        if fig._is_preprocessing:
+            return
+        with fig._context_preprocessing():
+            renderer = fig._get_renderer()  # any renderer will do for now
+            for ax in fig._iter_axes():
+                ax._draw_auto_legends_colorbars()  # may insert panels
+            resize = rc['backend'] != 'nbAgg'
+            if resize:
+                fig._adjust_aspect()  # resizes figure
+            if fig._auto_tight:
+                fig._adjust_tight_layout(renderer, resize=resize)
+            fig._align_axislabels(True)
+            fig._align_labels(renderer)
+            fallback = _notNone(
+                fig._fallback_to_cm, rc['mathtext.fallback_to_cm']
+            )
+            with rc.context({'mathtext.fallback_to_cm': fallback}):
+                return getattr(type(self), method)(self, *args, **kwargs)
     return _preprocess.__get__(canvas)  # ...I don't get it either
 
 
@@ -714,6 +723,7 @@ def _subplots_geometry(**kwargs):
 class _hidelabels(object):
     """Hide objects temporarily so they are ignored by the tight bounding box
     algorithm."""
+    # NOTE: This will be removed when labels are implemented with AxesStack!
     def __init__(self, *args):
         self._labels = args
 
@@ -811,7 +821,7 @@ def __init__(self,
         self._axpad = units(_notNone(axpad, rc['subplots.axpad']))
         self._panelpad = units(_notNone(panelpad, rc['subplots.panelpad']))
         self._auto_format = autoformat
-        self._auto_tight_layout = _notNone(tight, rc['tight'])
+        self._auto_tight = _notNone(tight, rc['tight'])
         self._include_panels = includepanels
         self._fallback_to_cm = fallback_to_cm
         self._ref_num = ref
@@ -996,44 +1006,51 @@ def _adjust_aspect(self):
             return
         ax = self._axes_main[self._ref_num - 1]
         mode = ax.get_aspect()
-        aspect = None
-        if mode == 'equal':
-            xscale, yscale = ax.get_xscale(), ax.get_yscale()
-            if xscale == 'linear' and yscale == 'linear':
-                aspect = 1.0 / ax.get_data_ratio()
-            elif xscale == 'log' and yscale == 'log':
-                aspect = 1.0 / ax.get_data_ratio_log()
-            else:
-                pass  # matplotlib issues warning, forces aspect == 'auto'
-        # Apply aspect
-        if aspect is not None:
-            aspect = round(aspect * 1e10) * 1e-10
-            subplots_kw = self._subplots_kw
-            aspect_prev = round(subplots_kw['aspect'] * 1e10) * 1e-10
-            if aspect != aspect_prev:
-                subplots_kw['aspect'] = aspect
-                figsize, gridspec_kw, _ = _subplots_geometry(**subplots_kw)
-                self.set_size_inches(figsize, manual=False)
-                self._gridspec_main.update(**gridspec_kw)
-
-    def _adjust_tight_layout(self, renderer):
+        if mode != 'equal':
+            return
+
+        # Compare to current aspect
+        subplots_kw = self._subplots_kw
+        xscale, yscale = ax.get_xscale(), ax.get_yscale()
+        if xscale == 'linear' and yscale == 'linear':
+            aspect = 1.0 / ax.get_data_ratio()
+        elif xscale == 'log' and yscale == 'log':
+            aspect = 1.0 / ax.get_data_ratio_log()
+        else:
+            pass  # matplotlib issues warning, forces aspect == 'auto'
+        aspect = round(aspect * 1e10) * 1e-10
+        aspect_prev = round(subplots_kw['aspect'] * 1e10) * 1e-10
+        if aspect == aspect_prev:
+            return
+
+        # Apply new aspect
+        subplots_kw['aspect'] = aspect
+        figsize, gridspec_kw, _ = _subplots_geometry(**subplots_kw)
+        self.set_size_inches(figsize, auto=True)
+        self._gridspec_main.update(**gridspec_kw)
+
+    def _adjust_tight_layout(self, renderer, resize=True):
         """Applies tight layout scaling that permits flexible figure
         dimensions and preserves panel widths and subplot aspect ratios.
         The `renderer` should be a `~matplotlib.backend_bases.RendererBase`
         instance."""
         # Initial stuff
         axs = self._iter_axes()
-        obox = self.bbox_inches  # original bbox
-        bbox = self.get_tightbbox(renderer)
-        gridspec = self._gridspec_main
         subplots_kw = self._subplots_kw
         subplots_orig_kw = self._subplots_orig_kw  # tight layout overrides
         if not axs or not subplots_kw or not subplots_orig_kw:
             return
 
+        # Temporarily disable spanning labels and get correct
+        # positions for labels and suptitle
+        self._align_axislabels(False)
+        self._align_labels(renderer)
+
         # Tight box *around* figure
         # Get bounds from old bounding box
         pad = self._pad
+        obox = self.bbox_inches  # original bbox
+        bbox = self.get_tightbbox(renderer)
         left = bbox.xmin
         bottom = bbox.ymin
         right = obox.xmax - bbox.xmax
@@ -1051,6 +1068,7 @@ def _adjust_tight_layout(self, renderer):
         # Get arrays storing gridspec spacing args
         axpad = self._axpad
         panelpad = self._panelpad
+        gridspec = self._gridspec_main
         nrows, ncols = gridspec.get_active_geometry()
         wspace, hspace = subplots_kw['wspace'], subplots_kw['hspace']
         wspace_orig = subplots_orig_kw['wspace']
@@ -1125,13 +1143,20 @@ def _adjust_tight_layout(self, renderer):
                 jspace[i] = space
             spaces.append(jspace)
 
-        # Apply new spaces
+        # Update geometry solver kwargs
         subplots_kw.update({
             'wspace': spaces[0], 'hspace': spaces[1],
         })
+        if not resize:
+            width, height = self.get_size_inches()
+            subplots_kw = subplots_kw.copy()
+            subplots_kw.update(width=width, height=height)
+
+        # Apply new spacing
         figsize, gridspec_kw, _ = _subplots_geometry(**subplots_kw)
+        if resize:
+            self.set_size_inches(figsize, auto=True)
         self._gridspec_main.update(**gridspec_kw)
-        self.set_size_inches(figsize, manual=False)
 
     def _align_axislabels(self, b=True):
         """Align spanning *x* and *y* axis labels in the perpendicular
@@ -1411,7 +1436,7 @@ def _insert_row_column(
 
         # Update figure
         figsize, gridspec_kw, _ = _subplots_geometry(**subplots_kw)
-        self.set_size_inches(figsize, manual=False)
+        self.set_size_inches(figsize, auto=True)
         if exists:
             gridspec = self._gridspec_main
             gridspec.update(**gridspec_kw)
@@ -1626,16 +1651,17 @@ def set_canvas(self, canvas):
         # `~matplotlib.backend_bases.FigureCanvasBase.print_figure`
         # methods. The latter is called by save() and by the inline backend.
         # See `_canvas_preprocess` for details."""
-        # NOTE: Use draw_idle() rather than draw() becuase latter is not
-        # always called! For example, MacOSX uses _draw() and nbAgg does
-        # not call draw() *or* _draw()! Not sure how it works actually.
-        # Should be same because we piggyback draw() which *itself* defers
-        # the event. Just make sure to check _is_idle_drawing!
-        canvas.draw_idle = _canvas_preprocess(canvas, 'draw_idle')
+        # NOTE: Cannot use draw_idle() because it causes *major* complications
+        # for qt5 backend. Even though usage is less consistent we *must*
+        # use draw() and _draw().
+        if hasattr(canvas, '_draw'):
+            canvas._draw = _canvas_preprocess(canvas, '_draw')
+        else:
+            canvas.draw = _canvas_preprocess(canvas, 'draw')
         canvas.print_figure = _canvas_preprocess(canvas, 'print_figure')
         super().set_canvas(canvas)
 
-    def set_size_inches(self, w, h=None, forward=True, manual=True):
+    def set_size_inches(self, w, h=None, forward=True, auto=False):
         # Set the figure size and, if this is being called manually or from
         # an interactive backend, override the geometry tracker so users can
         # use interactive backends. See #76. Undocumented because this is
@@ -1656,11 +1682,19 @@ def set_size_inches(self, w, h=None, forward=True, manual=True):
         width_true, height_true = self.get_size_inches()
         width_trunc = int(self.bbox.width) / self.dpi
         height_trunc = int(self.bbox.height) / self.dpi
-        if (manual  # have actually seen (width_true, heigh_trunc)!
-                and width not in (width_true, width_trunc)
-                and height not in (height_true, height_trunc)):
-            self._subplots_kw.update(width=width, height=height)
-        super().set_size_inches(width, height, forward=forward)
+        if auto:
+            with self._context_resizing():
+                super().set_size_inches(width, height, forward=forward)
+        else:
+            if (  # can have internal resizing not associated with any draws
+                (width not in (width_true, width_trunc)
+                 or height not in (height_true, height_trunc))
+                and not self._is_resizing
+                and not self.canvas._is_idle_drawing  # standard
+                and not getattr(self.canvas, '_draw_pending', None)  # pyqt5
+            ):
+                self._subplots_kw.update(width=width, height=height)
+            super().set_size_inches(width, height, forward=forward)
 
     def _iter_axes(self):
         """Iterates over all axes and panels in the figure belonging to the