Merge branch 'main' into ref-gbops-ea

Author: jbrockmendel

asv_bench/benchmarks/indexing.py

@@ -290,12 +290,24 @@ def setup(self):
         self.dti = dti
         self.dti2 = dti2
 
+        index = np.random.choice(dti, 10000, replace=True)
+        df = DataFrame(index=index, data={"a": 1})
+        df_sort = df.sort_index()
+        self.df = df
+        self.df_sort = df_sort
+
     def time_get_indexer_mismatched_tz(self):
         # reached via e.g.
         #  ser = Series(range(len(dti)), index=dti)
         #  ser[dti2]
         self.dti.get_indexer(self.dti2)
 
+    def time_loc_unsorted(self):
+        self.df.loc["2016-6-11"]
+
+    def time_loc_sorted(self):
+        self.df_sort.loc["2016-6-11"]
+
 
 class CategoricalIndexIndexing:
 

pandas/_libs/window/indexers.pyi

@@ -8,6 +8,5 @@ def calculate_variable_window_bounds(
     min_periods,
     center: bool,
     closed: str | None,
-    step: int | None,
     index: np.ndarray,  # const int64_t[:]
 ) -> tuple[npt.NDArray[np.int64], npt.NDArray[np.int64]]: ...

pandas/_libs/window/indexers.pyx

@@ -16,7 +16,6 @@ def calculate_variable_window_bounds(
     object min_periods,  # unused but here to match get_window_bounds signature
     bint center,
     str closed,
-    int64_t step,
     const int64_t[:] index
 ):
     """
@@ -39,9 +38,6 @@ def calculate_variable_window_bounds(
     closed : str
         string of side of the window that should be closed
 
-    step : int64
-        Spacing between windows
-
     index : ndarray[int64]
         time series index to roll over
 
@@ -150,4 +146,4 @@ def calculate_variable_window_bounds(
             # right endpoint is open
             if not right_closed and not center:
                 end[i] -= 1
-    return start[::step], end[::step]
+    return start, end

pandas/core/indexers/objects.py

@@ -115,9 +115,6 @@ def get_window_bounds(
         step: int | None = None,
     ) -> tuple[np.ndarray, np.ndarray]:
 
-        if step is not None:
-            raise NotImplementedError("step not implemented for variable window")
-
         # error: Argument 4 to "calculate_variable_window_bounds" has incompatible
         # type "Optional[bool]"; expected "bool"
         # error: Argument 6 to "calculate_variable_window_bounds" has incompatible
@@ -128,7 +125,6 @@ def get_window_bounds(
             min_periods,
             center,  # type: ignore[arg-type]
             closed,
-            1,
             self.index_array,  # type: ignore[arg-type]
         )
 
@@ -234,12 +230,10 @@ def get_window_bounds(
         step: int | None = None,
     ) -> tuple[np.ndarray, np.ndarray]:
 
-        if step is not None:
-            raise NotImplementedError("step not implemented for expanding window")
-
-        end = np.arange(1, num_values + 1, dtype=np.int64)
-        start = np.zeros(len(end), dtype=np.int64)
-        return start, end
+        return (
+            np.zeros(num_values, dtype=np.int64),
+            np.arange(1, num_values + 1, dtype=np.int64),
+        )
 
 
 class FixedForwardWindowIndexer(BaseIndexer):
@@ -343,8 +337,6 @@ def get_window_bounds(
         closed: str | None = None,
         step: int | None = None,
     ) -> tuple[np.ndarray, np.ndarray]:
-        if step is not None:
-            raise NotImplementedError("step not implemented for groupby window")
 
         # 1) For each group, get the indices that belong to the group
         # 2) Use the indices to calculate the start & end bounds of the window
@@ -404,11 +396,4 @@ def get_window_bounds(
         step: int | None = None,
     ) -> tuple[np.ndarray, np.ndarray]:
 
-        if step is not None:
-            raise NotImplementedError(
-                "step not implemented for exponentail moving window"
-            )
-        return (
-            np.array([0], dtype=np.int64),
-            np.array([num_values], dtype=np.int64),
-        )
+        return np.array([0], dtype=np.int64), np.array([num_values], dtype=np.int64)

pandas/core/window/rolling.py

@@ -229,6 +229,11 @@ def _validate(self) -> None:
                 )
         if self.method not in ["table", "single"]:
             raise ValueError("method must be 'table' or 'single")
+        if self.step is not None:
+            if not is_integer(self.step):
+                raise ValueError("step must be an integer")
+            elif self.step < 0:
+                raise ValueError("step must be >= 0")
 
     def _check_window_bounds(
         self, start: np.ndarray, end: np.ndarray, num_vals: int
@@ -238,16 +243,14 @@ def _check_window_bounds(
                 f"start ({len(start)}) and end ({len(end)}) bounds must be the "
                 f"same length"
             )
-        elif not isinstance(self._get_window_indexer(), GroupbyIndexer) and len(
-            start
-        ) != (num_vals + (self.step or 1) - 1) // (self.step or 1):
+        elif len(start) != (num_vals + (self.step or 1) - 1) // (self.step or 1):
             raise ValueError(
                 f"start and end bounds ({len(start)}) must be the same length "
                 f"as the object ({num_vals}) divided by the step ({self.step}) "
                 f"if given and rounded up"
             )
 
-    def _slice_index(self, index: Index, result: Sized | None = None) -> Index:
+    def _slice_axis_for_step(self, index: Index, result: Sized | None = None) -> Index:
         """
         Slices the index for a given result and the preset step.
         """
@@ -446,7 +449,7 @@ def _apply_series(
             raise DataError("No numeric types to aggregate") from err
 
         result = homogeneous_func(values)
-        index = self._slice_index(obj.index, result)
+        index = self._slice_axis_for_step(obj.index, result)
         return obj._constructor(result, index=index, name=obj.name)
 
     def _apply_blockwise(
@@ -484,7 +487,7 @@ def hfunc(values: ArrayLike) -> ArrayLike:
                 res_values.append(res)
                 taker.append(i)
 
-        index = self._slice_index(
+        index = self._slice_axis_for_step(
             obj.index, res_values[0] if len(res_values) > 0 else None
         )
         df = type(obj)._from_arrays(
@@ -524,7 +527,7 @@ def _apply_tablewise(
         values = values.T if self.axis == 1 else values
         result = homogeneous_func(values)
         result = result.T if self.axis == 1 else result
-        index = self._slice_index(obj.index, result)
+        index = self._slice_axis_for_step(obj.index, result)
         columns = (
             obj.columns
             if result.shape[1] == len(obj.columns)
@@ -644,13 +647,13 @@ def _numba_apply(
         )
         result = aggregator(values, start, end, min_periods, *func_args)
         result = result.T if self.axis == 1 else result
-        index = self._slice_index(obj.index, result)
+        index = self._slice_axis_for_step(obj.index, result)
         if obj.ndim == 1:
             result = result.squeeze()
             out = obj._constructor(result, index=index, name=obj.name)
             return out
         else:
-            columns = self._slice_index(obj.columns, result.T)
+            columns = self._slice_axis_for_step(obj.columns, result.T)
             out = obj._constructor(result, index=index, columns=columns)
             return self._resolve_output(out, obj)
 
@@ -692,7 +695,7 @@ def __init__(
         obj = obj.drop(columns=self._grouper.names, errors="ignore")
         # GH 15354
         if kwargs.get("step") is not None:
-            raise NotImplementedError("step not implemented for rolling groupby")
+            raise NotImplementedError("step not implemented for groupby")
         super().__init__(obj, *args, **kwargs)
 
     def _apply(
@@ -938,14 +941,12 @@ class Window(BaseWindow):
             The closed parameter with fixed windows is now supported.
 
     step : int, default None
-        When supported, applies ``[::step]`` to the resulting sequence of windows, in a
-        computationally efficient manner. Currently supported only with fixed-length
-        window indexers. Note that using a step argument other than None or 1 will
-        produce a result with a different shape than the input.
 
-        ..versionadded:: 1.5
+        ..versionadded:: 1.5.0
 
-            The step parameter is only supported with fixed windows.
+        Evaluate the window at every ``step`` result, equivalent to slicing as
+        ``[::step]``. ``window`` must be an integer. Using a step argument other
+        than None or 1 will produce a result with a different shape than the input.
 
     method : str {'single', 'table'}, default 'single'
 
@@ -1605,9 +1606,7 @@ def cov(
         **kwargs,
     ):
         if self.step is not None:
-            raise NotImplementedError(
-                "step not implemented for rolling and expanding cov"
-            )
+            raise NotImplementedError("step not implemented for cov")
 
         from pandas import Series
 
@@ -1650,11 +1649,8 @@ def corr(
         ddof: int = 1,
         **kwargs,
     ):
-
         if self.step is not None:
-            raise NotImplementedError(
-                "step not implemented for rolling and expanding corr"
-            )
+            raise NotImplementedError("step not implemented for corr")
 
         from pandas import Series
 
@@ -1749,24 +1745,16 @@ def _validate(self):
             if self.min_periods is None:
                 self.min_periods = 1
 
+            if self.step is not None:
+                raise NotImplementedError(
+                    "step is not supported with frequency windows"
+                )
+
         elif isinstance(self.window, BaseIndexer):
             # Passed BaseIndexer subclass should handle all other rolling kwargs
             pass
         elif not is_integer(self.window) or self.window < 0:
             raise ValueError("window must be an integer 0 or greater")
-        # GH 15354:
-        # validate window indexer parameters do not raise in get_window_bounds
-        # this cannot be done in BaseWindow._validate because there _get_window_indexer
-        # would erroneously create a fixed window given a window argument like "1s" due
-        # to _win_freq_i8 not being set
-        indexer = self._get_window_indexer()
-        indexer.get_window_bounds(
-            num_values=0,
-            min_periods=self.min_periods,
-            center=self.center,
-            closed=self.closed,
-            step=self.step,
-        )
 
     def _validate_datetimelike_monotonic(self):
         """

pandas/io/formats/style.py

@@ -2689,6 +2689,13 @@ def hide(
 
         Notes
         -----
+        .. warning::
+           This method only works with the output methods ``to_html``, ``to_string``
+           and ``to_latex``.
+
+           Other output methods, including ``to_excel``, ignore this hiding method
+           and will display all data.
+
         This method has multiple functionality depending upon the combination
         of the ``subset``, ``level`` and ``names`` arguments (see examples). The
         ``axis`` argument is used only to control whether the method is applied to row