Take review comments into account

oscargus · oscargus · commit c2b3f1fc6fcc · 2023-03-07T10:08:11.000+01:00
diff --git a/doc/api/next_api_changes/removals/24984-OG.rst b/doc/api/next_api_changes/removals/24984-OG.rst
@@ -41,7 +41,7 @@ parameter are removed. Instead, use ``set_params(base=..., subs=...)``.
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 The canvas now takes care of the renderer and whether to cache it or not,
-so the ````Axes.get_renderer_cache`` method is removed. The
+so the ``Axes.get_renderer_cache`` method is removed. The
 alternative is to call ``axes.figure.canvas.get_renderer()``.
 
 Unused methods in ``Axis``, ``Tick``, ``XAxis``, and ``YAxis``
diff --git a/lib/matplotlib/collections.py b/lib/matplotlib/collections.py
@@ -11,7 +11,7 @@
 
 import itertools
 import math
-from numbers import Number
+from numbers import Number, Real
 import warnings
 
 import numpy as np
@@ -439,9 +439,9 @@ def set_pickradius(self, pickradius):
         pickradius : float
             Pick radius, in points.
         """
-        if not isinstance(pickradius, Number):
+        if not isinstance(pickradius, Real):
             raise ValueError(
-                f"pickradius must be a number, not {pickradius!r}")
+                f"pickradius must be a real-valued number, not {pickradius!r}")
         self._pickradius = pickradius
 
     def get_pickradius(self):
diff --git a/lib/matplotlib/mlab.py b/lib/matplotlib/mlab.py
@@ -210,39 +210,6 @@ def detrend_linear(y):
     return y - (b*x + a)
 
 
-def _stride_windows(x, n, noverlap=0):
-    """
-    Get all windows of *x* with length *n* as a single array,
-    using strides to avoid data duplication.
-
-    .. warning::
-
-        It is not safe to write to the output array.  Multiple
-        elements may point to the same piece of memory,
-        so modifying one value may change others.
-
-    Parameters
-    ----------
-    x : 1D array or sequence
-        Array or sequence containing the data.
-    n : int
-        The number of data points in each window.
-    noverlap : int, default: 0 (no overlap)
-        The overlap between adjacent windows.
-
-    References
-    ----------
-    `stackoverflow: Rolling window for 1D arrays in Numpy?
-    <https://stackoverflow.com/a/6811241>`_
-    `stackoverflow: Using strides for an efficient moving average filter
-    <https://stackoverflow.com/a/4947453>`_
-    """
-    if noverlap >= n:
-        raise ValueError('noverlap must be less than n')
-    return np.lib.stride_tricks.sliding_window_view(
-        x, n, axis=0)[::n - noverlap].T
-
-
 def _spectral_helper(x, y=None, NFFT=None, Fs=None, detrend_func=None,
                      window=None, noverlap=None, pad_to=None,
                      sides=None, scale_by_freq=None, mode=None):
@@ -272,6 +239,9 @@ def _spectral_helper(x, y=None, NFFT=None, Fs=None, detrend_func=None,
     if NFFT is None:
         NFFT = 256
 
+    if noverlap >= NFFT:
+        raise ValueError('noverlap must be less than NFFT')
+
     if mode is None or mode == 'default':
         mode = 'psd'
     _api.check_in_list(
@@ -334,15 +304,17 @@ def _spectral_helper(x, y=None, NFFT=None, Fs=None, detrend_func=None,
         raise ValueError(
             "The window length must match the data's first dimension")
 
-    result = _stride_windows(x, NFFT, noverlap)
+    result = np.lib.stride_tricks.sliding_window_view(
+        x, NFFT, axis=0)[::NFFT - noverlap].T
     result = detrend(result, detrend_func, axis=0)
     result = result * window.reshape((-1, 1))
     result = np.fft.fft(result, n=pad_to, axis=0)[:numFreqs, :]
     freqs = np.fft.fftfreq(pad_to, 1/Fs)[:numFreqs]
 
     if not same_data:
         # if same_data is False, mode must be 'psd'
-        resultY = _stride_windows(y, NFFT, noverlap)
+        resultY = np.lib.stride_tricks.sliding_window_view(
+            y, NFFT, axis=0)[::NFFT - noverlap].T
         resultY = detrend(resultY, detrend_func, axis=0)
         resultY = resultY * window.reshape((-1, 1))
         resultY = np.fft.fft(resultY, n=pad_to, axis=0)[:numFreqs, :]
diff --git a/lib/matplotlib/offsetbox.py b/lib/matplotlib/offsetbox.py
@@ -1225,8 +1225,7 @@ def __str__(self):
         return f"AnnotationBbox({self.xy[0]:g},{self.xy[1]:g})"
 
     @_docstring.dedent_interpd
-    def __init__(self, offsetbox, xy, *,
-                 xybox=None,
+    def __init__(self, offsetbox, xy, xybox=None, *,
                  xycoords='data',
                  boxcoords=None,
                  frameon=True, pad=0.4,  # FancyBboxPatch boxstyle.
diff --git a/lib/matplotlib/tests/test_mlab.py b/lib/matplotlib/tests/test_mlab.py
@@ -6,68 +6,6 @@
 from matplotlib import mlab
 
 
-class TestStride:
-    def get_base(self, x):
-        y = x
-        while y.base is not None:
-            y = y.base
-        return y
-
-    def calc_window_target(self, x, NFFT, noverlap=0):
-        """
-        This is an adaptation of the original window extraction algorithm.
-        This is here to test to make sure the new implementation has the same
-        result.
-        """
-        step = NFFT - noverlap
-        ind = np.arange(0, len(x) - NFFT + 1, step)
-        n = len(ind)
-        result = np.zeros((NFFT, n))
-
-        # do the ffts of the slices
-        for i in range(n):
-            result[:, i] = x[ind[i]:ind[i]+NFFT]
-        return result
-
-    @pytest.mark.parametrize('n, noverlap',
-                             [(2, 2), (2, 3)],
-                             ids=['noverlap greater than n',
-                                  'noverlap equal to n'])
-    def test_stride_windows_invalid_params(self, n, noverlap):
-        x = np.arange(10)
-        with pytest.raises(ValueError):
-            mlab._stride_windows(x, n, noverlap)
-
-    @pytest.mark.parametrize('n, noverlap',
-                             [(1, 0), (5, 0), (15, 2), (13, -3)],
-                             ids=['n1-noverlap0', 'n5-noverlap0',
-                                  'n15-noverlap2', 'n13-noverlapn3'])
-    def test_stride_windows(self, n, noverlap):
-        x = np.arange(100)
-        y = mlab._stride_windows(x, n, noverlap=noverlap)
-
-        expected_shape = [0, 0]
-        expected_shape[0] = n
-        expected_shape[1] = 100 // (n - noverlap)
-        yt = self.calc_window_target(x, n, noverlap=noverlap)
-
-        assert yt.shape == y.shape
-        assert_array_equal(yt, y)
-        assert tuple(expected_shape) == y.shape
-        assert self.get_base(y) is x
-
-    def test_stride_windows_n32_noverlap0_unflatten(self):
-        n = 32
-        x = np.arange(n)[np.newaxis]
-        x1 = np.tile(x, (21, 1))
-        x2 = x1.flatten()
-        y = mlab._stride_windows(x2, n)
-
-        x1 = x1.T
-        assert y.shape == x1.shape
-        assert_array_equal(y, x1)
-
-
 def test_window():
     np.random.seed(0)
     n = 1000
diff --git a/lib/mpl_toolkits/mplot3d/axis3d.py b/lib/mpl_toolkits/mplot3d/axis3d.py
@@ -183,12 +183,6 @@ def get_minor_ticks(self, numticks=None):
                 obj.set_transform(self.axes.transData)
         return ticks
 
-    def _set_pane_pos(self, xys):
-        xys = np.asarray(xys)
-        xys = xys[:, :2]
-        self.pane.xy = xys
-        self.stale = True
-
     def set_pane_color(self, color, alpha=None):
         """
         Set pane color.
@@ -319,8 +313,9 @@ def draw_pane(self, renderer):
             plane = self._PLANES[2 * index]
         else:
             plane = self._PLANES[2 * index + 1]
-        xys = [tc[p] for p in plane]
-        self._set_pane_pos(xys)
+        xys = np.asarray([tc[p] for p in plane])
+        xys = xys[:, :2]
+        self.pane.xy = xys
         self.pane.draw(renderer)
 
         renderer.close_group('pane3d')
