Minor cleanups.

Re: the rewriting of AsinhLocator formulas: The previous implementation
added 1e-6 to the logs in the case where xs=0 in order to avoid a
warning with log(0), but the result of the log was then zeroed out by
multiplication by xs anyways.  Instead, here we just rely on
`10**log(0) = 10**-inf = 0`.

Author: anntzer

lib/matplotlib/axis.py

@@ -208,7 +208,7 @@ def _apply_tickdir(self, tickdir):
         """Set tick direction.  Valid values are 'out', 'in', 'inout'."""
         # This method is responsible for updating `_pad`, and, in subclasses,
         # for setting the tick{1,2}line markers as well.  From the user
-        # perspective this should always be called though _apply_params, which
+        # perspective this should always be called through _apply_params, which
         # further updates ticklabel positions using the new pads.
         if tickdir is None:
             tickdir = mpl.rcParams[f'{self.__name__}.direction']

lib/matplotlib/backend_bases.py

@@ -2385,64 +2385,47 @@ def key_press_handler(event, canvas=None, toolbar=None):
         back-compatibility, but, if set, should always be equal to
         ``event.canvas.toolbar``.
     """
-    # these bindings happen whether you are over an Axes or not
-
     if event.key is None:
         return
     if canvas is None:
         canvas = event.canvas
     if toolbar is None:
         toolbar = canvas.toolbar
 
-    # Load key-mappings from rcParams.
-    fullscreen_keys = rcParams['keymap.fullscreen']
-    home_keys = rcParams['keymap.home']
-    back_keys = rcParams['keymap.back']
-    forward_keys = rcParams['keymap.forward']
-    pan_keys = rcParams['keymap.pan']
-    zoom_keys = rcParams['keymap.zoom']
-    save_keys = rcParams['keymap.save']
-    quit_keys = rcParams['keymap.quit']
-    quit_all_keys = rcParams['keymap.quit_all']
-    grid_keys = rcParams['keymap.grid']
-    grid_minor_keys = rcParams['keymap.grid_minor']
-    toggle_yscale_keys = rcParams['keymap.yscale']
-    toggle_xscale_keys = rcParams['keymap.xscale']
-
-    # toggle fullscreen mode ('f', 'ctrl + f')
-    if event.key in fullscreen_keys:
+    # toggle fullscreen mode (default key 'f', 'ctrl + f')
+    if event.key in rcParams['keymap.fullscreen']:
         try:
             canvas.manager.full_screen_toggle()
         except AttributeError:
             pass
 
     # quit the figure (default key 'ctrl+w')
-    if event.key in quit_keys:
+    if event.key in rcParams['keymap.quit']:
         Gcf.destroy_fig(canvas.figure)
-    if event.key in quit_all_keys:
+    if event.key in rcParams['keymap.quit_all']:
         Gcf.destroy_all()
 
     if toolbar is not None:
         # home or reset mnemonic  (default key 'h', 'home' and 'r')
-        if event.key in home_keys:
+        if event.key in rcParams['keymap.home']:
             toolbar.home()
         # forward / backward keys to enable left handed quick navigation
         # (default key for backward: 'left', 'backspace' and 'c')
-        elif event.key in back_keys:
+        elif event.key in rcParams['keymap.back']:
             toolbar.back()
         # (default key for forward: 'right' and 'v')
-        elif event.key in forward_keys:
+        elif event.key in rcParams['keymap.forward']:
             toolbar.forward()
         # pan mnemonic (default key 'p')
-        elif event.key in pan_keys:
+        elif event.key in rcParams['keymap.pan']:
             toolbar.pan()
             toolbar._update_cursor(event)
         # zoom mnemonic (default key 'o')
-        elif event.key in zoom_keys:
+        elif event.key in rcParams['keymap.zoom']:
             toolbar.zoom()
             toolbar._update_cursor(event)
         # saving current figure (default key 's')
-        elif event.key in save_keys:
+        elif event.key in rcParams['keymap.save']:
             toolbar.save_figure()
 
     if event.inaxes is None:
@@ -2452,19 +2435,16 @@ def key_press_handler(event, canvas=None, toolbar=None):
     def _get_uniform_gridstate(ticks):
         # Return True/False if all grid lines are on or off, None if they are
         # not all in the same state.
-        if all(tick.gridline.get_visible() for tick in ticks):
-            return True
-        elif not any(tick.gridline.get_visible() for tick in ticks):
-            return False
-        else:
-            return None
+        return (True if all(tick.gridline.get_visible() for tick in ticks) else
+                False if not any(tick.gridline.get_visible() for tick in ticks) else
+                None)
 
     ax = event.inaxes
     # toggle major grids in current Axes (default key 'g')
     # Both here and below (for 'G'), we do nothing if *any* grid (major or
     # minor, x or y) is not in a uniform state, to avoid messing up user
     # customization.
-    if (event.key in grid_keys
+    if (event.key in rcParams['keymap.grid']
             # Exclude minor grids not in a uniform state.
             and None not in [_get_uniform_gridstate(ax.xaxis.minorTicks),
                              _get_uniform_gridstate(ax.yaxis.minorTicks)]):
@@ -2483,7 +2463,7 @@ def _get_uniform_gridstate(ticks):
             ax.grid(y_state, which="major" if y_state else "both", axis="y")
             canvas.draw_idle()
     # toggle major and minor grids in current Axes (default key 'G')
-    if (event.key in grid_minor_keys
+    if (event.key in rcParams['keymap.grid_minor']
             # Exclude major grids not in a uniform state.
             and None not in [_get_uniform_gridstate(ax.xaxis.majorTicks),
                              _get_uniform_gridstate(ax.yaxis.majorTicks)]):
@@ -2501,7 +2481,7 @@ def _get_uniform_gridstate(ticks):
             ax.grid(y_state, which="both", axis="y")
             canvas.draw_idle()
     # toggle scaling of y-axes between 'log and 'linear' (default key 'l')
-    elif event.key in toggle_yscale_keys:
+    elif event.key in rcParams['keymap.yscale']:
         scale = ax.get_yscale()
         if scale == 'log':
             ax.set_yscale('linear')
@@ -2514,7 +2494,7 @@ def _get_uniform_gridstate(ticks):
                 ax.set_yscale('linear')
             ax.figure.canvas.draw_idle()
     # toggle scaling of x-axes between 'log and 'linear' (default key 'k')
-    elif event.key in toggle_xscale_keys:
+    elif event.key in rcParams['keymap.xscale']:
         scalex = ax.get_xscale()
         if scalex == 'log':
             ax.set_xscale('linear')

lib/matplotlib/font_manager.py

@@ -1448,7 +1448,8 @@ def _findfont_cached(self, prop, fontext, directory, fallback_to_default,
                 # actually raised.
                 return _ExceptionProxy(
                     ValueError,
-                    f"Failed to find font {prop}, and fallback to the default font was disabled"
+                    f"Failed to find font {prop}, and fallback to the default font was "
+                    f"disabled"
                 )
         else:
             _log.debug('findfont: Matching %s to %s (%r) with score of %f.',

lib/matplotlib/projections/polar.py

@@ -524,24 +524,16 @@ def get_matrix(self):
         if self._invalid:
             if self.mode == 'rlabel':
                 angle = (
-                    np.deg2rad(self.axes.get_rlabel_position()) *
-                    self.axes.get_theta_direction() +
-                    self.axes.get_theta_offset()
+                    np.deg2rad(self.axes.get_rlabel_position()
+                               * self.axes.get_theta_direction())
+                    + self.axes.get_theta_offset()
+                    - np.pi / 2
                 )
-            else:
-                if self.mode == 'min':
-                    angle = self.axes._realViewLim.xmin
-                elif self.mode == 'max':
-                    angle = self.axes._realViewLim.xmax
-
-            if self.mode in ('rlabel', 'min'):
-                padx = np.cos(angle - np.pi / 2)
-                pady = np.sin(angle - np.pi / 2)
-            else:
-                padx = np.cos(angle + np.pi / 2)
-                pady = np.sin(angle + np.pi / 2)
-
-            self._t = (self.pad * padx / 72, self.pad * pady / 72)
+            elif self.mode == 'min':
+                angle = self.axes._realViewLim.xmin - np.pi / 2
+            elif self.mode == 'max':
+                angle = self.axes._realViewLim.xmax + np.pi / 2
+            self._t = (self.pad * np.cos(angle) / 72, self.pad * np.sin(angle) / 72)
         return super().get_matrix()
 
 

lib/matplotlib/quiver.py

@@ -72,7 +72,7 @@
     of these components (in data or in screen space) depends on *angles*.
 
     *U* and *V* must have the same number of elements, matching the number of
-    arrow locations in  *X*, *Y*. *U* and *V* may be masked. Locations masked
+    arrow locations in *X*, *Y*. *U* and *V* may be masked. Locations masked
     in any of *U*, *V*, and *C* will not be drawn.
 
 C : 1D or 2D array-like, optional
@@ -90,7 +90,7 @@
       symbolize a quantity that is not based on *X*, *Y* data coordinates.
 
       If *U* == *V* the orientation of the arrow on the plot is 45 degrees
-      counter-clockwise from the  horizontal axis (positive to the right).
+      counter-clockwise from the horizontal axis (positive to the right).
 
     - 'xy': Arrow direction in data coordinates, i.e. the arrows point from
       (x, y) to (x+u, y+v). Use this e.g. for plotting a gradient field.

lib/matplotlib/ticker.py

@@ -2661,51 +2661,32 @@ def __call__(self):
             return self.tick_values(vmin, vmax)
 
     def tick_values(self, vmin, vmax):
-        # Construct a set of "on-screen" locations
-        # that are uniformly spaced:
+        # Construct a set of uniformly-spaced "on-screen" locations.
         ymin, ymax = self.linear_width * np.arcsinh(np.array([vmin, vmax])
-                                                        / self.linear_width)
+                                                    / self.linear_width)
         ys = np.linspace(ymin, ymax, self.numticks)
-        zero_dev = np.abs(ys / (ymax - ymin))
-        if (ymin * ymax) < 0:
-            # Ensure that the zero tick-mark is included,
-            # if the axis straddles zero
+        zero_dev = abs(ys / (ymax - ymin))
+        if ymin * ymax < 0:
+            # Ensure that the zero tick-mark is included, if the axis straddles zero.
             ys = np.hstack([ys[(zero_dev > 0.5 / self.numticks)], 0.0])
 
         # Transform the "on-screen" grid to the data space:
         xs = self.linear_width * np.sinh(ys / self.linear_width)
         zero_xs = (ys == 0)
 
-        # Round the data-space values to be intuitive base-n numbers,
-        # keeping track of positive and negative values separately,
-        # but giving careful treatment to the zero value:
-        if self.base > 1:
-            log_base = math.log(self.base)
-            powers = (
-                np.where(zero_xs, 0, np.sign(xs)) *
-                np.power(self.base,
-                         np.where(zero_xs, 0.0,
-                                  np.floor(np.log(np.abs(xs) + zero_xs*1e-6)
-                                                / log_base)))
-            )
-            if self.subs:
-                qs = np.outer(powers, self.subs).flatten()
-            else:
-                qs = powers
-        else:
-            powers = (
-                np.where(xs >= 0, 1, -1) *
-                np.power(10, np.where(zero_xs, 0.0,
-                                      np.floor(np.log10(np.abs(xs)
-                                                        + zero_xs*1e-6))))
-            )
-            qs = powers * np.round(xs / powers)
+        # Round the data-space values to be intuitive base-n numbers, keeping track of
+        # positive and negative values separately and carefully treating the zero value.
+        with np.errstate(divide="ignore"):  # base ** log(0) = base ** -inf = 0.
+            if self.base > 1:
+                pows = (np.sign(xs)
+                        * self.base ** np.floor(np.log(abs(xs)) / math.log(self.base)))
+                qs = np.outer(pows, self.subs).flatten() if self.subs else pows
+            else:  # No need to adjust sign(pows), as it cancels out when computing qs.
+                pows = np.where(zero_xs, 1, 10**np.floor(np.log10(abs(xs))))
+                qs = pows * np.round(xs / pows)
         ticks = np.array(sorted(set(qs)))
 
-        if len(ticks) >= 2:
-            return ticks
-        else:
-            return np.linspace(vmin, vmax, self.numticks)
+        return ticks if len(ticks) >= 2 else np.linspace(vmin, vmax, self.numticks)
 
 
 class LogitLocator(MaxNLocator):

lib/mpl_toolkits/axisartist/grid_finder.py

@@ -188,9 +188,7 @@ def get_grid_info(self, x1, y1, x2, y2):
                                                         lon_min, lon_max,
                                                         lat_min, lat_max)
 
-        ddx = (x2-x1)*1.e-10
-        ddy = (y2-y1)*1.e-10
-        bb = Bbox.from_extents(x1-ddx, y1-ddy, x2+ddx, y2+ddy)
+        bb = Bbox.from_extents(x1, y1, x2, y2).expanded(1 + 2e-10, 1 + 2e-10)
 
         grid_info = {
             "extremes": extremes,