MNT: make renderer always optional

Author: jklymak

doc/api/next_api_changes/behavior/22745-JMK.rst

@@ -0,0 +1,9 @@
+No need to specify renderer for get_tightbbox and get_window_extent
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The ``get_tightbbox`` and `~.Artist.get_window_extent` methods
+no longer require the *renderer* kwarg, saving users from having to
+querry it from ``fig.canvas.get_renderer``.  If the *renderer*
+kwarg is not supplied these methods first check if there is a cached renderer
+from a previous draw and use that.  If there is no cahched renderer, then
+the methods will use ``fig.canvas.get_renderer()`` as a fallback.

lib/matplotlib/_constrained_layout.py

@@ -52,7 +52,6 @@
 import numpy as np
 
 from matplotlib import _api, artist as martist
-from matplotlib._tight_layout import get_renderer
 import matplotlib.transforms as mtransforms
 import matplotlib._layoutgrid as mlayoutgrid
 
@@ -94,7 +93,7 @@ def do_constrained_layout(fig, h_pad, w_pad,
     layoutgrid : private debugging structure
     """
 
-    renderer = get_renderer(fig)
+    renderer = fig._get_renderer()
     # make layoutgrid tree...
     layoutgrids = make_layoutgrids(fig, None, rect=rect)
     if not layoutgrids['hasgrids']:

lib/matplotlib/_tight_layout.py

@@ -198,18 +198,6 @@ def auto_adjust_subplotpars(
         ax_bbox_list, pad, h_pad, w_pad, rect)
 
 
-def get_renderer(fig):
-    if fig._cachedRenderer:
-        return fig._cachedRenderer
-    else:
-        canvas = fig.canvas
-        if canvas and hasattr(canvas, "get_renderer"):
-            return canvas.get_renderer()
-        else:
-            from . import backend_bases
-            return backend_bases._get_renderer(fig)
-
-
 def get_subplotspec_list(axes_list, grid_spec=None):
     """
     Return a list of subplotspec from the given list of axes.

lib/matplotlib/artist.py

@@ -298,7 +298,7 @@ def stale(self, val):
         if val and self.stale_callback is not None:
             self.stale_callback(self, val)
 
-    def get_window_extent(self, renderer):
+    def get_window_extent(self, renderer=None):
         """
         Get the artist's bounding box in display space.
 
@@ -318,7 +318,7 @@ def get_window_extent(self, renderer):
         """
         return Bbox([[0, 0], [0, 0]])
 
-    def get_tightbbox(self, renderer):
+    def get_tightbbox(self, renderer=None):
         """
         Like `.Artist.get_window_extent`, but includes any clipping.
 

lib/matplotlib/axes/_base.py

@@ -4441,7 +4441,7 @@ def get_default_bbox_extra_artists(self):
         return [a for a in artists if a.get_visible() and a.get_in_layout()
                 and (isinstance(a, noclip) or not a._fully_clipped_to_axes())]
 
-    def get_tightbbox(self, renderer, call_axes_locator=True,
+    def get_tightbbox(self, renderer=None, call_axes_locator=True,
                       bbox_extra_artists=None, *, for_layout_only=False):
         """
         Return the tight bounding box of the Axes, including axis and their
@@ -4485,6 +4485,8 @@ def get_tightbbox(self, renderer, call_axes_locator=True,
         """
 
         bb = []
+        if renderer is None:
+            renderer = self.figure._get_renderer()
 
         if not self.get_visible():
             return None

lib/matplotlib/axis.py

@@ -1198,14 +1198,16 @@ def _update_ticks(self):
 
         return ticks_to_draw
 
-    def _get_ticklabel_bboxes(self, ticks, renderer):
+    def _get_ticklabel_bboxes(self, ticks, renderer=None):
         """Return lists of bboxes for ticks' label1's and label2's."""
+        if renderer is None:
+            renderer = self.figure._get_renderer()
         return ([tick.label1.get_window_extent(renderer)
                  for tick in ticks if tick.label1.get_visible()],
                 [tick.label2.get_window_extent(renderer)
                  for tick in ticks if tick.label2.get_visible()])
 
-    def get_tightbbox(self, renderer, *, for_layout_only=False):
+    def get_tightbbox(self, renderer=None, *, for_layout_only=False):
         """
         Return a bounding box that encloses the axis. It only accounts
         tick labels, axis label, and offsetText.
@@ -1217,7 +1219,8 @@ def get_tightbbox(self, renderer, *, for_layout_only=False):
         """
         if not self.get_visible():
             return
-
+        if renderer is None:
+            renderer = self.figure._get_renderer()
         ticks_to_draw = self._update_ticks()
 
         self._update_label_position(renderer)

lib/matplotlib/collections.py

@@ -303,7 +303,7 @@ def get_datalim(self, transData):
                 return bbox
         return transforms.Bbox.null()
 
-    def get_window_extent(self, renderer):
+    def get_window_extent(self, renderer=None):
         # TODO: check to ensure that this does not fail for
         # cases other than scatter plot legend
         return self.get_datalim(transforms.IdentityTransform())

lib/matplotlib/contour.py

@@ -251,23 +251,25 @@ def too_close(self, x, y, lw):
     def _get_nth_label_width(self, nth):
         """Return the width of the *nth* label, in pixels."""
         fig = self.axes.figure
+        renderer = fig._get_renderer()
         return (
             text.Text(0, 0,
                       self.get_text(self.labelLevelList[nth], self.labelFmt),
                       figure=fig,
                       size=self.labelFontSizeList[nth],
                       fontproperties=self.labelFontProps)
-            .get_window_extent(mpl._tight_layout.get_renderer(fig)).width)
+            .get_window_extent(renderer).width)
 
     @_api.deprecated("3.5")
     def get_label_width(self, lev, fmt, fsize):
         """Return the width of the label in points."""
         if not isinstance(lev, str):
             lev = self.get_text(lev, fmt)
         fig = self.axes.figure
+        renderer = fig._get_renderer()
         width = (text.Text(0, 0, lev, figure=fig,
                            size=fsize, fontproperties=self.labelFontProps)
-                 .get_window_extent(mpl._tight_layout.get_renderer(fig)).width)
+                 .get_window_extent(renderer).width)
         width *= 72 / fig.dpi
         return width
 

lib/matplotlib/figure.py

@@ -1618,7 +1618,7 @@ def get_default_bbox_extra_artists(self):
                 bbox_artists.extend(ax.get_default_bbox_extra_artists())
         return bbox_artists
 
-    def get_tightbbox(self, renderer, bbox_extra_artists=None):
+    def get_tightbbox(self, renderer=None, bbox_extra_artists=None):
         """
         Return a (tight) bounding box of the figure *in inches*.
 
@@ -1645,6 +1645,9 @@ def get_tightbbox(self, renderer, bbox_extra_artists=None):
             containing the bounding box (in figure inches).
         """
 
+        if renderer is None:
+            renderer = self.figure._get_renderer()
+
         bb = []
         if bbox_extra_artists is None:
             artists = self.get_default_bbox_extra_artists()
@@ -2060,13 +2063,8 @@ def dpi(self):
     def dpi(self, value):
         self._parent.dpi = value
 
-    @property
-    def _cachedRenderer(self):
-        return self._parent._cachedRenderer
-
-    @_cachedRenderer.setter
-    def _cachedRenderer(self, renderer):
-        self._parent._cachedRenderer = renderer
+    def _get_renderer(self):
+        return self._parent._get_renderer()
 
     def _redo_transform_rel_fig(self, bbox=None):
         """
@@ -2496,6 +2494,14 @@ def axes(self):
 
     get_axes = axes.fget
 
+    def _get_renderer(self):
+        if self._cachedRenderer is not None:
+            return self._cachedRenderer
+        elif hasattr(self.canvas, 'get_renderer'):
+            return self.canvas.get_renderer()
+        else:
+            return _get_renderer(self)
+
     def _get_dpi(self):
         return self._dpi
 
@@ -2644,7 +2650,7 @@ def get_constrained_layout_pads(self, relative=False):
         hspace = info['hspace']
 
         if relative and (w_pad is not None or h_pad is not None):
-            renderer = _get_renderer(self)
+            renderer = self._get_renderer()
             dpi = renderer.dpi
             w_pad = w_pad * dpi / renderer.width
             h_pad = h_pad * dpi / renderer.height

lib/matplotlib/gridspec.py

@@ -474,7 +474,7 @@ def tight_layout(self, figure, renderer=None,
                                "might be incorrect.")
 
         if renderer is None:
-            renderer = _tight_layout.get_renderer(figure)
+            renderer = figure._get_renderer()
 
         kwargs = _tight_layout.get_tight_layout_figure(
             figure, figure.axes, subplotspec_list, renderer,