diff --git a/pandas/tests/window/moments/test_moments_consistency_rolling.py b/pandas/tests/window/moments/test_moments_consistency_rolling.py
index ceabf71747cb8..802ece77fd36d 100644
--- a/pandas/tests/window/moments/test_moments_consistency_rolling.py
+++ b/pandas/tests/window/moments/test_moments_consistency_rolling.py
@@ -5,8 +5,7 @@
 
 import pandas.util._test_decorators as td
 
-import pandas as pd
-from pandas import DataFrame, DatetimeIndex, Index, Series
+from pandas import DataFrame, DatetimeIndex, Index, MultiIndex, Series
 import pandas._testing as tm
 from pandas.core.window.common import flex_binary_moment
 
@@ -240,7 +239,7 @@ def test_rolling_functions_window_non_shrinkage_binary(f):
     )
     df_expected = DataFrame(
         columns=Index(["A", "B"], name="foo"),
-        index=pd.MultiIndex.from_product([df.index, df.columns], names=["bar", "foo"]),
+        index=MultiIndex.from_product([df.index, df.columns], names=["bar", "foo"]),
         dtype="float64",
     )
     df_result = f(df)
@@ -482,12 +481,10 @@ def test_moment_functions_zero_length_pairwise(f):
     df2["a"] = df2["a"].astype("float64")
 
     df1_expected = DataFrame(
-        index=pd.MultiIndex.from_product([df1.index, df1.columns]), columns=Index([])
+        index=MultiIndex.from_product([df1.index, df1.columns]), columns=Index([])
     )
     df2_expected = DataFrame(
-        index=pd.MultiIndex.from_product(
-            [df2.index, df2.columns], names=["bar", "foo"]
-        ),
+        index=MultiIndex.from_product([df2.index, df2.columns], names=["bar", "foo"]),
         columns=Index(["a"], name="foo"),
         dtype="float64",
     )
diff --git a/pandas/tests/window/moments/test_moments_rolling.py b/pandas/tests/window/moments/test_moments_rolling.py
index 39b3a9a630760..ac6dd0bad619a 100644
--- a/pandas/tests/window/moments/test_moments_rolling.py
+++ b/pandas/tests/window/moments/test_moments_rolling.py
@@ -3,8 +3,7 @@
 
 import pandas.util._test_decorators as td
 
-import pandas as pd
-from pandas import DataFrame, Series
+from pandas import DataFrame, Series, date_range
 import pandas._testing as tm
 
 
@@ -546,7 +545,7 @@ def test_rolling_quantile_np_percentile():
     # is analogous to Numpy's percentile
     row = 10
     col = 5
-    idx = pd.date_range("20100101", periods=row, freq="B")
+    idx = date_range("20100101", periods=row, freq="B")
     df = DataFrame(np.random.rand(row * col).reshape((row, -1)), index=idx)
 
     df_quantile = df.quantile([0.25, 0.5, 0.75], axis=0)
diff --git a/pandas/tests/window/test_api.py b/pandas/tests/window/test_api.py
index 6ce425e2575db..52c629f96b713 100644
--- a/pandas/tests/window/test_api.py
+++ b/pandas/tests/window/test_api.py
@@ -1,8 +1,17 @@
 import numpy as np
 import pytest
 
-import pandas as pd
-from pandas import DataFrame, Index, Series, Timestamp, concat
+from pandas import (
+    DataFrame,
+    Index,
+    MultiIndex,
+    Period,
+    Series,
+    Timestamp,
+    concat,
+    date_range,
+    timedelta_range,
+)
 import pandas._testing as tm
 from pandas.core.base import SpecificationError
 
@@ -78,7 +87,7 @@ def test_agg():
 
     result = r.aggregate([np.mean, np.std])
     expected = concat([a_mean, a_std, b_mean, b_std], axis=1)
-    expected.columns = pd.MultiIndex.from_product([["A", "B"], ["mean", "std"]])
+    expected.columns = MultiIndex.from_product([["A", "B"], ["mean", "std"]])
     tm.assert_frame_equal(result, expected)
 
     result = r.aggregate({"A": np.mean, "B": np.std})
@@ -88,7 +97,7 @@ def test_agg():
 
     result = r.aggregate({"A": ["mean", "std"]})
     expected = concat([a_mean, a_std], axis=1)
-    expected.columns = pd.MultiIndex.from_tuples([("A", "mean"), ("A", "std")])
+    expected.columns = MultiIndex.from_tuples([("A", "mean"), ("A", "std")])
     tm.assert_frame_equal(result, expected)
 
     result = r["A"].aggregate(["mean", "sum"])
@@ -110,7 +119,7 @@ def test_agg():
     expected = concat([a_mean, a_std, b_mean, b_std], axis=1)
 
     exp_cols = [("A", "mean"), ("A", "std"), ("B", "mean"), ("B", "std")]
-    expected.columns = pd.MultiIndex.from_tuples(exp_cols)
+    expected.columns = MultiIndex.from_tuples(exp_cols)
     tm.assert_frame_equal(result, expected, check_like=True)
 
 
@@ -134,7 +143,7 @@ def test_agg_consistency():
     r = df.rolling(window=3)
 
     result = r.agg([np.sum, np.mean]).columns
-    expected = pd.MultiIndex.from_product([list("AB"), ["sum", "mean"]])
+    expected = MultiIndex.from_product([list("AB"), ["sum", "mean"]])
     tm.assert_index_equal(result, expected)
 
     result = r["A"].agg([np.sum, np.mean]).columns
@@ -142,7 +151,7 @@ def test_agg_consistency():
     tm.assert_index_equal(result, expected)
 
     result = r.agg({"A": [np.sum, np.mean]}).columns
-    expected = pd.MultiIndex.from_tuples([("A", "sum"), ("A", "mean")])
+    expected = MultiIndex.from_tuples([("A", "sum"), ("A", "mean")])
     tm.assert_index_equal(result, expected)
 
 
@@ -159,7 +168,7 @@ def test_agg_nested_dicts():
     expected = concat(
         [r["A"].mean(), r["A"].std(), r["B"].mean(), r["B"].std()], axis=1
     )
-    expected.columns = pd.MultiIndex.from_tuples(
+    expected.columns = MultiIndex.from_tuples(
         [("ra", "mean"), ("ra", "std"), ("rb", "mean"), ("rb", "std")]
     )
     with pytest.raises(SpecificationError, match=msg):
@@ -191,21 +200,21 @@ def test_count_nonnumeric_types():
             "int": [1, 2, 3],
             "float": [4.0, 5.0, 6.0],
             "string": list("abc"),
-            "datetime": pd.date_range("20170101", periods=3),
-            "timedelta": pd.timedelta_range("1 s", periods=3, freq="s"),
+            "datetime": date_range("20170101", periods=3),
+            "timedelta": timedelta_range("1 s", periods=3, freq="s"),
             "periods": [
-                pd.Period("2012-01"),
-                pd.Period("2012-02"),
-                pd.Period("2012-03"),
+                Period("2012-01"),
+                Period("2012-02"),
+                Period("2012-03"),
             ],
             "fl_inf": [1.0, 2.0, np.Inf],
             "fl_nan": [1.0, 2.0, np.NaN],
             "str_nan": ["aa", "bb", np.NaN],
             "dt_nat": dt_nat_col,
             "periods_nat": [
-                pd.Period("2012-01"),
-                pd.Period("2012-02"),
-                pd.Period(None),
+                Period("2012-01"),
+                Period("2012-02"),
+                Period(None),
             ],
         },
         columns=cols,
@@ -298,11 +307,11 @@ def test_multiple_agg_funcs(func, window_size, expected_vals):
     else:
         window = f()
 
-    index = pd.MultiIndex.from_tuples(
+    index = MultiIndex.from_tuples(
         [("A", 0), ("A", 1), ("A", 2), ("B", 3), ("B", 4), ("B", 5), ("B", 6)],
         names=["stock", None],
     )
-    columns = pd.MultiIndex.from_tuples(
+    columns = MultiIndex.from_tuples(
         [("low", "mean"), ("low", "max"), ("high", "mean"), ("high", "min")]
     )
     expected = DataFrame(expected_vals, index=index, columns=columns)
diff --git a/pandas/tests/window/test_expanding.py b/pandas/tests/window/test_expanding.py
index 3405502e54e70..01804faad5a5e 100644
--- a/pandas/tests/window/test_expanding.py
+++ b/pandas/tests/window/test_expanding.py
@@ -3,8 +3,7 @@
 
 from pandas.errors import UnsupportedFunctionCall
 
-import pandas as pd
-from pandas import DataFrame, Series
+from pandas import DataFrame, DatetimeIndex, Series
 import pandas._testing as tm
 from pandas.core.window import Expanding
 
@@ -82,8 +81,8 @@ def test_empty_df_expanding(expander):
 
     # Verifies that datetime and integer expanding windows can be applied
     # to empty DataFrames with datetime index
-    expected = DataFrame(index=pd.DatetimeIndex([]))
-    result = DataFrame(index=pd.DatetimeIndex([])).expanding(expander).sum()
+    expected = DataFrame(index=DatetimeIndex([]))
+    result = DataFrame(index=DatetimeIndex([])).expanding(expander).sum()
     tm.assert_frame_equal(result, expected)
 
 
diff --git a/pandas/tests/window/test_groupby.py b/pandas/tests/window/test_groupby.py
index 7a75ff1cff5bc..f9b5a5fe9a3c1 100644
--- a/pandas/tests/window/test_groupby.py
+++ b/pandas/tests/window/test_groupby.py
@@ -1,9 +1,9 @@
 import numpy as np
 import pytest
 
-import pandas as pd
-from pandas import DataFrame, MultiIndex, Series
+from pandas import DataFrame, MultiIndex, Series, Timestamp, date_range, to_datetime
 import pandas._testing as tm
+from pandas.api.indexers import BaseIndexer
 from pandas.core.groupby.groupby import get_groupby
 
 
@@ -133,7 +133,7 @@ def test_rolling_apply_mutability(self):
         df = DataFrame({"A": ["foo"] * 3 + ["bar"] * 3, "B": [1] * 6})
         g = df.groupby("A")
 
-        mi = pd.MultiIndex.from_tuples(
+        mi = MultiIndex.from_tuples(
             [("bar", 3), ("bar", 4), ("bar", 5), ("foo", 0), ("foo", 1), ("foo", 2)]
         )
 
@@ -162,9 +162,7 @@ def foo(x):
         result = df.groupby("id").value.rolling(1).apply(foo, raw=raw_value)
         expected = Series(
             [expected_value] * 3,
-            index=pd.MultiIndex.from_tuples(
-                ((1, 0), (1, 1), (1, 2)), names=["id", None]
-            ),
+            index=MultiIndex.from_tuples(((1, 0), (1, 1), (1, 2)), names=["id", None]),
             name="value",
         )
         tm.assert_series_equal(result, expected)
@@ -175,7 +173,7 @@ def test_groupby_rolling_center_center(self):
         result = series.groupby(series).rolling(center=True, window=3).mean()
         expected = Series(
             [np.nan] * 5,
-            index=pd.MultiIndex.from_tuples(((1, 0), (2, 1), (3, 2), (4, 3), (5, 4))),
+            index=MultiIndex.from_tuples(((1, 0), (2, 1), (3, 2), (4, 3), (5, 4))),
         )
         tm.assert_series_equal(result, expected)
 
@@ -183,7 +181,7 @@ def test_groupby_rolling_center_center(self):
         result = series.groupby(series).rolling(center=True, window=3).mean()
         expected = Series(
             [np.nan] * 4,
-            index=pd.MultiIndex.from_tuples(((1, 0), (2, 1), (3, 2), (4, 3))),
+            index=MultiIndex.from_tuples(((1, 0), (2, 1), (3, 2), (4, 3))),
         )
         tm.assert_series_equal(result, expected)
 
@@ -191,7 +189,7 @@ def test_groupby_rolling_center_center(self):
         result = df.groupby("a").rolling(center=True, window=3).mean()
         expected = DataFrame(
             [np.nan, 1, 2, 3, np.nan, np.nan, 6, 7, 8, 9, np.nan],
-            index=pd.MultiIndex.from_tuples(
+            index=MultiIndex.from_tuples(
                 (
                     ("a", 0),
                     ("a", 1),
@@ -215,7 +213,7 @@ def test_groupby_rolling_center_center(self):
         result = df.groupby("a").rolling(center=True, window=3).mean()
         expected = DataFrame(
             [np.nan, 1, 2, 3, np.nan, np.nan, 6, 7, 8, np.nan],
-            index=pd.MultiIndex.from_tuples(
+            index=MultiIndex.from_tuples(
                 (
                     ("a", 0),
                     ("a", 1),
@@ -238,7 +236,7 @@ def test_groupby_rolling_center_on(self):
         # GH 37141
         df = DataFrame(
             data={
-                "Date": pd.date_range("2020-01-01", "2020-01-10"),
+                "Date": date_range("2020-01-01", "2020-01-10"),
                 "gb": ["group_1"] * 6 + ["group_2"] * 4,
                 "value": range(10),
             }
@@ -251,18 +249,18 @@ def test_groupby_rolling_center_on(self):
         expected = Series(
             [1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 7.0, 7.5, 7.5, 7.5],
             name="value",
-            index=pd.MultiIndex.from_tuples(
+            index=MultiIndex.from_tuples(
                 (
-                    ("group_1", pd.Timestamp("2020-01-01")),
-                    ("group_1", pd.Timestamp("2020-01-02")),
-                    ("group_1", pd.Timestamp("2020-01-03")),
-                    ("group_1", pd.Timestamp("2020-01-04")),
-                    ("group_1", pd.Timestamp("2020-01-05")),
-                    ("group_1", pd.Timestamp("2020-01-06")),
-                    ("group_2", pd.Timestamp("2020-01-07")),
-                    ("group_2", pd.Timestamp("2020-01-08")),
-                    ("group_2", pd.Timestamp("2020-01-09")),
-                    ("group_2", pd.Timestamp("2020-01-10")),
+                    ("group_1", Timestamp("2020-01-01")),
+                    ("group_1", Timestamp("2020-01-02")),
+                    ("group_1", Timestamp("2020-01-03")),
+                    ("group_1", Timestamp("2020-01-04")),
+                    ("group_1", Timestamp("2020-01-05")),
+                    ("group_1", Timestamp("2020-01-06")),
+                    ("group_2", Timestamp("2020-01-07")),
+                    ("group_2", Timestamp("2020-01-08")),
+                    ("group_2", Timestamp("2020-01-09")),
+                    ("group_2", Timestamp("2020-01-10")),
                 ),
                 names=["gb", "Date"],
             ),
@@ -305,7 +303,7 @@ def test_groupby_subselect_rolling(self):
         expected = DataFrame(
             [np.nan, np.nan, 2.0, np.nan],
             columns=["b"],
-            index=pd.MultiIndex.from_tuples(
+            index=MultiIndex.from_tuples(
                 ((1, 0), (2, 1), (2, 3), (3, 2)), names=["a", None]
             ),
         )
@@ -314,7 +312,7 @@ def test_groupby_subselect_rolling(self):
         result = df.groupby("a")["b"].rolling(2).max()
         expected = Series(
             [np.nan, np.nan, 2.0, np.nan],
-            index=pd.MultiIndex.from_tuples(
+            index=MultiIndex.from_tuples(
                 ((1, 0), (2, 1), (2, 3), (3, 2)), names=["a", None]
             ),
             name="b",
@@ -323,7 +321,7 @@ def test_groupby_subselect_rolling(self):
 
     def test_groupby_rolling_custom_indexer(self):
         # GH 35557
-        class SimpleIndexer(pd.api.indexers.BaseIndexer):
+        class SimpleIndexer(BaseIndexer):
             def get_window_bounds(
                 self, num_values=0, min_periods=None, center=None, closed=None
             ):
@@ -351,7 +349,7 @@ def test_groupby_rolling_subset_with_closed(self):
                 "column1": range(6),
                 "column2": range(6),
                 "group": 3 * ["A", "B"],
-                "date": [pd.Timestamp("2019-01-01")] * 6,
+                "date": [Timestamp("2019-01-01")] * 6,
             }
         )
         result = (
@@ -359,9 +357,9 @@ def test_groupby_rolling_subset_with_closed(self):
         )
         expected = Series(
             [np.nan, 0.0, 2.0, np.nan, 1.0, 4.0],
-            index=pd.MultiIndex.from_tuples(
-                [("A", pd.Timestamp("2019-01-01"))] * 3
-                + [("B", pd.Timestamp("2019-01-01"))] * 3,
+            index=MultiIndex.from_tuples(
+                [("A", Timestamp("2019-01-01"))] * 3
+                + [("B", Timestamp("2019-01-01"))] * 3,
                 names=["group", "date"],
             ),
             name="column1",
@@ -375,7 +373,7 @@ def test_groupby_subset_rolling_subset_with_closed(self):
                 "column1": range(6),
                 "column2": range(6),
                 "group": 3 * ["A", "B"],
-                "date": [pd.Timestamp("2019-01-01")] * 6,
+                "date": [Timestamp("2019-01-01")] * 6,
             }
         )
 
@@ -386,9 +384,9 @@ def test_groupby_subset_rolling_subset_with_closed(self):
         )
         expected = Series(
             [np.nan, 0.0, 2.0, np.nan, 1.0, 4.0],
-            index=pd.MultiIndex.from_tuples(
-                [("A", pd.Timestamp("2019-01-01"))] * 3
-                + [("B", pd.Timestamp("2019-01-01"))] * 3,
+            index=MultiIndex.from_tuples(
+                [("A", Timestamp("2019-01-01"))] * 3
+                + [("B", Timestamp("2019-01-01"))] * 3,
                 names=["group", "date"],
             ),
             name="column1",
@@ -400,7 +398,7 @@ def test_groupby_rolling_index_changed(self, func):
         # GH: #36018 nlevels of MultiIndex changed
         ds = Series(
             [1, 2, 2],
-            index=pd.MultiIndex.from_tuples(
+            index=MultiIndex.from_tuples(
                 [("a", "x"), ("a", "y"), ("c", "z")], names=["1", "2"]
             ),
             name="a",
@@ -409,7 +407,7 @@ def test_groupby_rolling_index_changed(self, func):
         result = getattr(ds.groupby(ds).rolling(2), func)()
         expected = Series(
             [np.nan, np.nan, 2.0],
-            index=pd.MultiIndex.from_tuples(
+            index=MultiIndex.from_tuples(
                 [(1, "a", "x"), (2, "a", "y"), (2, "c", "z")], names=["a", "1", "2"]
             ),
             name="a",
@@ -420,23 +418,23 @@ def test_groupby_rolling_empty_frame(self):
         # GH 36197
         expected = DataFrame({"s1": []})
         result = expected.groupby("s1").rolling(window=1).sum()
-        expected.index = pd.MultiIndex.from_tuples([], names=["s1", None])
+        expected.index = MultiIndex.from_tuples([], names=["s1", None])
         tm.assert_frame_equal(result, expected)
 
         expected = DataFrame({"s1": [], "s2": []})
         result = expected.groupby(["s1", "s2"]).rolling(window=1).sum()
-        expected.index = pd.MultiIndex.from_tuples([], names=["s1", "s2", None])
+        expected.index = MultiIndex.from_tuples([], names=["s1", "s2", None])
         tm.assert_frame_equal(result, expected)
 
     def test_groupby_rolling_string_index(self):
         # GH: 36727
         df = DataFrame(
             [
-                ["A", "group_1", pd.Timestamp(2019, 1, 1, 9)],
-                ["B", "group_1", pd.Timestamp(2019, 1, 2, 9)],
-                ["Z", "group_2", pd.Timestamp(2019, 1, 3, 9)],
-                ["H", "group_1", pd.Timestamp(2019, 1, 6, 9)],
-                ["E", "group_2", pd.Timestamp(2019, 1, 20, 9)],
+                ["A", "group_1", Timestamp(2019, 1, 1, 9)],
+                ["B", "group_1", Timestamp(2019, 1, 2, 9)],
+                ["Z", "group_2", Timestamp(2019, 1, 3, 9)],
+                ["H", "group_1", Timestamp(2019, 1, 6, 9)],
+                ["E", "group_2", Timestamp(2019, 1, 20, 9)],
             ],
             columns=["index", "group", "eventTime"],
         ).set_index("index")
@@ -447,11 +445,11 @@ def test_groupby_rolling_string_index(self):
         result = rolling_groups.apply(lambda df: df.shape[0])
         expected = DataFrame(
             [
-                ["A", "group_1", pd.Timestamp(2019, 1, 1, 9), 1.0],
-                ["B", "group_1", pd.Timestamp(2019, 1, 2, 9), 2.0],
-                ["H", "group_1", pd.Timestamp(2019, 1, 6, 9), 3.0],
-                ["Z", "group_2", pd.Timestamp(2019, 1, 3, 9), 1.0],
-                ["E", "group_2", pd.Timestamp(2019, 1, 20, 9), 1.0],
+                ["A", "group_1", Timestamp(2019, 1, 1, 9), 1.0],
+                ["B", "group_1", Timestamp(2019, 1, 2, 9), 2.0],
+                ["H", "group_1", Timestamp(2019, 1, 6, 9), 3.0],
+                ["Z", "group_2", Timestamp(2019, 1, 3, 9), 1.0],
+                ["E", "group_2", Timestamp(2019, 1, 20, 9), 1.0],
             ],
             columns=["index", "group", "eventTime", "count_to_date"],
         ).set_index(["group", "index"])
@@ -468,7 +466,7 @@ def test_groupby_rolling_no_sort(self):
         expected = DataFrame(
             np.array([[2.0, 2.0], [1.0, 1.0]]),
             columns=["foo", "bar"],
-            index=pd.MultiIndex.from_tuples([(2, 0), (1, 1)], names=["foo", None]),
+            index=MultiIndex.from_tuples([(2, 0), (1, 1)], names=["foo", None]),
         )
         tm.assert_frame_equal(result, expected)
 
@@ -479,7 +477,7 @@ def test_groupby_rolling_count_closed_on(self):
                 "column1": range(6),
                 "column2": range(6),
                 "group": 3 * ["A", "B"],
-                "date": pd.date_range(end="20190101", periods=6),
+                "date": date_range(end="20190101", periods=6),
             }
         )
         result = (
@@ -490,14 +488,14 @@ def test_groupby_rolling_count_closed_on(self):
         expected = Series(
             [np.nan, 1.0, 1.0, np.nan, 1.0, 1.0],
             name="column1",
-            index=pd.MultiIndex.from_tuples(
+            index=MultiIndex.from_tuples(
                 [
-                    ("A", pd.Timestamp("2018-12-27")),
-                    ("A", pd.Timestamp("2018-12-29")),
-                    ("A", pd.Timestamp("2018-12-31")),
-                    ("B", pd.Timestamp("2018-12-28")),
-                    ("B", pd.Timestamp("2018-12-30")),
-                    ("B", pd.Timestamp("2019-01-01")),
+                    ("A", Timestamp("2018-12-27")),
+                    ("A", Timestamp("2018-12-29")),
+                    ("A", Timestamp("2018-12-31")),
+                    ("B", Timestamp("2018-12-28")),
+                    ("B", Timestamp("2018-12-30")),
+                    ("B", Timestamp("2019-01-01")),
                 ],
                 names=["group", "date"],
             ),
@@ -516,7 +514,7 @@ def test_groupby_rolling_sem(self, func, kwargs):
         result = getattr(df.groupby("a"), func)(**kwargs).sem()
         expected = DataFrame(
             {"a": [np.nan] * 5, "b": [np.nan, 0.70711, np.nan, 0.70711, 0.70711]},
-            index=pd.MultiIndex.from_tuples(
+            index=MultiIndex.from_tuples(
                 [("a", 0), ("a", 1), ("b", 2), ("b", 3), ("b", 4)], names=["a", None]
             ),
         )
@@ -529,7 +527,7 @@ def test_groupby_rolling_nans_in_index(self, rollings, key):
         # GH: 34617
         df = DataFrame(
             {
-                "a": pd.to_datetime(["2020-06-01 12:00", "2020-06-01 14:00", np.nan]),
+                "a": to_datetime(["2020-06-01 12:00", "2020-06-01 14:00", np.nan]),
                 "b": [1, 2, 3],
                 "c": [1, 1, 1],
             }
diff --git a/pandas/tests/window/test_rolling.py b/pandas/tests/window/test_rolling.py
index 1cfbb57d582a3..1658cca347786 100644
--- a/pandas/tests/window/test_rolling.py
+++ b/pandas/tests/window/test_rolling.py
@@ -5,9 +5,20 @@
 
 from pandas.errors import UnsupportedFunctionCall
 
-import pandas as pd
-from pandas import DataFrame, Series, date_range
+from pandas import (
+    DataFrame,
+    DatetimeIndex,
+    MultiIndex,
+    Series,
+    Timedelta,
+    Timestamp,
+    date_range,
+    period_range,
+    to_datetime,
+    to_timedelta,
+)
 import pandas._testing as tm
+from pandas.api.indexers import BaseIndexer
 from pandas.core.window import Rolling
 
 
@@ -61,35 +72,35 @@ def test_invalid_constructor(frame_or_series, w):
         c(window=2, min_periods=1, center=w)
 
 
-@pytest.mark.parametrize("window", [timedelta(days=3), pd.Timedelta(days=3)])
+@pytest.mark.parametrize("window", [timedelta(days=3), Timedelta(days=3)])
 def test_constructor_with_timedelta_window(window):
     # GH 15440
     n = 10
     df = DataFrame(
-        {"value": np.arange(n)}, index=pd.date_range("2015-12-24", periods=n, freq="D")
+        {"value": np.arange(n)}, index=date_range("2015-12-24", periods=n, freq="D")
     )
     expected_data = np.append([0.0, 1.0], np.arange(3.0, 27.0, 3))
 
     result = df.rolling(window=window).sum()
     expected = DataFrame(
         {"value": expected_data},
-        index=pd.date_range("2015-12-24", periods=n, freq="D"),
+        index=date_range("2015-12-24", periods=n, freq="D"),
     )
     tm.assert_frame_equal(result, expected)
     expected = df.rolling("3D").sum()
     tm.assert_frame_equal(result, expected)
 
 
-@pytest.mark.parametrize("window", [timedelta(days=3), pd.Timedelta(days=3), "3D"])
+@pytest.mark.parametrize("window", [timedelta(days=3), Timedelta(days=3), "3D"])
 def test_constructor_timedelta_window_and_minperiods(window, raw):
     # GH 15305
     n = 10
     df = DataFrame(
-        {"value": np.arange(n)}, index=pd.date_range("2017-08-08", periods=n, freq="D")
+        {"value": np.arange(n)}, index=date_range("2017-08-08", periods=n, freq="D")
     )
     expected = DataFrame(
         {"value": np.append([np.NaN, 1.0], np.arange(3.0, 27.0, 3))},
-        index=pd.date_range("2017-08-08", periods=n, freq="D"),
+        index=date_range("2017-08-08", periods=n, freq="D"),
     )
     result_roll_sum = df.rolling(window=window, min_periods=2).sum()
     result_roll_generic = df.rolling(window=window, min_periods=2).apply(sum, raw=raw)
@@ -129,7 +140,7 @@ def test_closed_fixed_binary_col():
     data = [0, 1, 1, 0, 0, 1, 0, 1]
     df = DataFrame(
         {"binary_col": data},
-        index=pd.date_range(start="2020-01-01", freq="min", periods=len(data)),
+        index=date_range(start="2020-01-01", freq="min", periods=len(data)),
     )
 
     rolling = df.rolling(window=len(df), closed="left", min_periods=1)
@@ -137,7 +148,7 @@ def test_closed_fixed_binary_col():
     expected = DataFrame(
         [np.nan, 0, 0.5, 2 / 3, 0.5, 0.4, 0.5, 0.428571],
         columns=["binary_col"],
-        index=pd.date_range(start="2020-01-01", freq="min", periods=len(data)),
+        index=date_range(start="2020-01-01", freq="min", periods=len(data)),
     )
     tm.assert_frame_equal(result, expected)
 
@@ -146,7 +157,7 @@ def test_closed_fixed_binary_col():
 def test_closed_empty(closed, arithmetic_win_operators):
     # GH 26005
     func_name = arithmetic_win_operators
-    ser = Series(data=np.arange(5), index=pd.date_range("2000", periods=5, freq="2D"))
+    ser = Series(data=np.arange(5), index=date_range("2000", periods=5, freq="2D"))
     roll = ser.rolling("1D", closed=closed)
 
     result = getattr(roll, func_name)()
@@ -157,7 +168,7 @@ def test_closed_empty(closed, arithmetic_win_operators):
 @pytest.mark.parametrize("func", ["min", "max"])
 def test_closed_one_entry(func):
     # GH24718
-    ser = Series(data=[2], index=pd.date_range("2000", periods=1))
+    ser = Series(data=[2], index=date_range("2000", periods=1))
     result = getattr(ser.rolling("10D", closed="left"), func)()
     tm.assert_series_equal(result, Series([np.nan], index=ser.index))
 
@@ -166,14 +177,12 @@ def test_closed_one_entry(func):
 def test_closed_one_entry_groupby(func):
     # GH24718
     ser = DataFrame(
-        data={"A": [1, 1, 2], "B": [3, 2, 1]}, index=pd.date_range("2000", periods=3)
+        data={"A": [1, 1, 2], "B": [3, 2, 1]}, index=date_range("2000", periods=3)
     )
     result = getattr(
         ser.groupby("A", sort=False)["B"].rolling("10D", closed="left"), func
     )()
-    exp_idx = pd.MultiIndex.from_arrays(
-        arrays=[[1, 1, 2], ser.index], names=("A", None)
-    )
+    exp_idx = MultiIndex.from_arrays(arrays=[[1, 1, 2], ser.index], names=("A", None))
     expected = Series(data=[np.nan, 3, np.nan], index=exp_idx, name="B")
     tm.assert_series_equal(result, expected)
 
@@ -195,7 +204,7 @@ def test_closed_one_entry_groupby(func):
 def test_closed_min_max_datetime(input_dtype, func, closed, expected):
     # see gh-21704
     ser = Series(
-        data=np.arange(10).astype(input_dtype), index=pd.date_range("2000", periods=10)
+        data=np.arange(10).astype(input_dtype), index=date_range("2000", periods=10)
     )
 
     result = getattr(ser.rolling("3D", closed=closed), func)()
@@ -205,7 +214,7 @@ def test_closed_min_max_datetime(input_dtype, func, closed, expected):
 
 def test_closed_uneven():
     # see gh-21704
-    ser = Series(data=np.arange(10), index=pd.date_range("2000", periods=10))
+    ser = Series(data=np.arange(10), index=date_range("2000", periods=10))
 
     # uneven
     ser = ser.drop(index=ser.index[[1, 5]])
@@ -229,7 +238,7 @@ def test_closed_uneven():
 )
 def test_closed_min_max_minp(func, closed, expected):
     # see gh-21704
-    ser = Series(data=np.arange(10), index=pd.date_range("2000", periods=10))
+    ser = Series(data=np.arange(10), index=date_range("2000", periods=10))
     ser[ser.index[-3:]] = np.nan
     result = getattr(ser.rolling("3D", min_periods=2, closed=closed), func)()
     expected = Series(expected, index=ser.index)
@@ -247,7 +256,7 @@ def test_closed_min_max_minp(func, closed, expected):
 )
 def test_closed_median_quantile(closed, expected):
     # GH 26005
-    ser = Series(data=np.arange(10), index=pd.date_range("2000", periods=10))
+    ser = Series(data=np.arange(10), index=date_range("2000", periods=10))
     roll = ser.rolling("3D", closed=closed)
     expected = Series(expected, index=ser.index)
 
@@ -268,8 +277,8 @@ def tests_empty_df_rolling(roller):
 
     # Verifies that datetime and integer rolling windows can be applied to
     # empty DataFrames with datetime index
-    expected = DataFrame(index=pd.DatetimeIndex([]))
-    result = DataFrame(index=pd.DatetimeIndex([])).rolling(roller).sum()
+    expected = DataFrame(index=DatetimeIndex([]))
+    result = DataFrame(index=DatetimeIndex([])).rolling(roller).sum()
     tm.assert_frame_equal(result, expected)
 
 
@@ -303,11 +312,9 @@ def test_missing_minp_zero_variable():
     # https://github.com/pandas-dev/pandas/pull/18921
     x = Series(
         [np.nan] * 4,
-        index=pd.DatetimeIndex(
-            ["2017-01-01", "2017-01-04", "2017-01-06", "2017-01-07"]
-        ),
+        index=DatetimeIndex(["2017-01-01", "2017-01-04", "2017-01-06", "2017-01-07"]),
     )
-    result = x.rolling(pd.Timedelta("2d"), min_periods=0).sum()
+    result = x.rolling(Timedelta("2d"), min_periods=0).sum()
     expected = Series(0.0, index=x.index)
     tm.assert_series_equal(result, expected)
 
@@ -315,7 +322,7 @@ def test_missing_minp_zero_variable():
 def test_multi_index_names():
 
     # GH 16789, 16825
-    cols = pd.MultiIndex.from_product([["A", "B"], ["C", "D", "E"]], names=["1", "2"])
+    cols = MultiIndex.from_product([["A", "B"], ["C", "D", "E"]], names=["1", "2"])
     df = DataFrame(np.ones((10, 6)), columns=cols)
     result = df.rolling(3).cov()
 
@@ -366,7 +373,7 @@ def test_rolling_datetime(axis_frame, tz_naive_fixture):
     # GH-28192
     tz = tz_naive_fixture
     df = DataFrame(
-        {i: [1] * 2 for i in pd.date_range("2019-8-01", "2019-08-03", freq="D", tz=tz)}
+        {i: [1] * 2 for i in date_range("2019-8-01", "2019-08-03", freq="D", tz=tz)}
     )
     if axis_frame in [0, "index"]:
         result = df.T.rolling("2D", axis=axis_frame).sum().T
@@ -376,11 +383,11 @@ def test_rolling_datetime(axis_frame, tz_naive_fixture):
         {
             **{
                 i: [1.0] * 2
-                for i in pd.date_range("2019-8-01", periods=1, freq="D", tz=tz)
+                for i in date_range("2019-8-01", periods=1, freq="D", tz=tz)
             },
             **{
                 i: [2.0] * 2
-                for i in pd.date_range("2019-8-02", "2019-8-03", freq="D", tz=tz)
+                for i in date_range("2019-8-02", "2019-8-03", freq="D", tz=tz)
             },
         }
     )
@@ -390,7 +397,7 @@ def test_rolling_datetime(axis_frame, tz_naive_fixture):
 def test_rolling_window_as_string():
     # see gh-22590
     date_today = datetime.now()
-    days = pd.date_range(date_today, date_today + timedelta(365), freq="D")
+    days = date_range(date_today, date_today + timedelta(365), freq="D")
 
     npr = np.random.RandomState(seed=421)
 
@@ -683,13 +690,13 @@ def test_iter_rolling_datetime(expected, expected_index, window):
     [
         (
             {"level": 0},
-            pd.MultiIndex.from_tuples(
+            MultiIndex.from_tuples(
                 [(0, 0), (0, 0), (1, 1), (1, 1), (1, 1)], names=[None, None]
             ),
         ),
         (
             {"by": "X"},
-            pd.MultiIndex.from_tuples(
+            MultiIndex.from_tuples(
                 [(0, 0), (1, 0), (2, 1), (3, 1), (4, 1)], names=["X", None]
             ),
         ),
@@ -717,15 +724,15 @@ def test_rolling_numerical_accuracy_kahan_mean(add):
     df = DataFrame(
         {"A": [3002399751580331.0 + add, -0.0, -0.0]},
         index=[
-            pd.Timestamp("19700101 09:00:00"),
-            pd.Timestamp("19700101 09:00:03"),
-            pd.Timestamp("19700101 09:00:06"),
+            Timestamp("19700101 09:00:00"),
+            Timestamp("19700101 09:00:03"),
+            Timestamp("19700101 09:00:06"),
         ],
     )
     result = (
         df.resample("1s").ffill().rolling("3s", closed="left", min_periods=3).mean()
     )
-    dates = pd.date_range("19700101 09:00:00", periods=7, freq="S")
+    dates = date_range("19700101 09:00:00", periods=7, freq="S")
     expected = DataFrame(
         {
             "A": [
@@ -753,8 +760,8 @@ def test_rolling_numerical_accuracy_kahan_sum():
 
 def test_rolling_numerical_accuracy_jump():
     # GH: 32761
-    index = pd.date_range(start="2020-01-01", end="2020-01-02", freq="60s").append(
-        pd.DatetimeIndex(["2020-01-03"])
+    index = date_range(start="2020-01-01", end="2020-01-02", freq="60s").append(
+        DatetimeIndex(["2020-01-03"])
     )
     data = np.random.rand(len(index))
 
@@ -775,7 +782,7 @@ def test_rolling_numerical_accuracy_small_values():
 
 def test_rolling_numerical_too_large_numbers():
     # GH: 11645
-    dates = pd.date_range("2015-01-01", periods=10, freq="D")
+    dates = date_range("2015-01-01", periods=10, freq="D")
     ds = Series(data=range(10), index=dates, dtype=np.float64)
     ds[2] = -9e33
     result = ds.rolling(5).mean()
@@ -823,7 +830,7 @@ def test_rolling_axis_one_with_nan():
 
 @pytest.mark.parametrize(
     "value",
-    ["test", pd.to_datetime("2019-12-31"), pd.to_timedelta("1 days 06:05:01.00003")],
+    ["test", to_datetime("2019-12-31"), to_timedelta("1 days 06:05:01.00003")],
 )
 def test_rolling_axis_1_non_numeric_dtypes(value):
     # GH: 20649
@@ -849,13 +856,11 @@ def test_rolling_on_df_transposed():
     ("index", "window"),
     [
         (
-            pd.period_range(start="2020-01-01 08:00", end="2020-01-01 08:08", freq="T"),
+            period_range(start="2020-01-01 08:00", end="2020-01-01 08:08", freq="T"),
             "2T",
         ),
         (
-            pd.period_range(
-                start="2020-01-01 08:00", end="2020-01-01 12:00", freq="30T"
-            ),
+            period_range(start="2020-01-01 08:00", end="2020-01-01 12:00", freq="30T"),
             "1h",
         ),
     ],
@@ -932,18 +937,18 @@ def test_timeoffset_as_window_parameter_for_corr():
                 1.0000000000000002,
             ],
         },
-        index=pd.MultiIndex.from_tuples(
+        index=MultiIndex.from_tuples(
             [
-                (pd.Timestamp("20130101 09:00:00"), "B"),
-                (pd.Timestamp("20130101 09:00:00"), "A"),
-                (pd.Timestamp("20130102 09:00:02"), "B"),
-                (pd.Timestamp("20130102 09:00:02"), "A"),
-                (pd.Timestamp("20130103 09:00:03"), "B"),
-                (pd.Timestamp("20130103 09:00:03"), "A"),
-                (pd.Timestamp("20130105 09:00:05"), "B"),
-                (pd.Timestamp("20130105 09:00:05"), "A"),
-                (pd.Timestamp("20130106 09:00:06"), "B"),
-                (pd.Timestamp("20130106 09:00:06"), "A"),
+                (Timestamp("20130101 09:00:00"), "B"),
+                (Timestamp("20130101 09:00:00"), "A"),
+                (Timestamp("20130102 09:00:02"), "B"),
+                (Timestamp("20130102 09:00:02"), "A"),
+                (Timestamp("20130103 09:00:03"), "B"),
+                (Timestamp("20130103 09:00:03"), "A"),
+                (Timestamp("20130105 09:00:05"), "B"),
+                (Timestamp("20130105 09:00:05"), "A"),
+                (Timestamp("20130106 09:00:06"), "B"),
+                (Timestamp("20130106 09:00:06"), "A"),
             ]
         ),
     )
@@ -951,11 +956,11 @@ def test_timeoffset_as_window_parameter_for_corr():
     df = DataFrame(
         {"B": [0, 1, 2, 4, 3], "A": [7, 4, 6, 9, 3]},
         index=[
-            pd.Timestamp("20130101 09:00:00"),
-            pd.Timestamp("20130102 09:00:02"),
-            pd.Timestamp("20130103 09:00:03"),
-            pd.Timestamp("20130105 09:00:05"),
-            pd.Timestamp("20130106 09:00:06"),
+            Timestamp("20130101 09:00:00"),
+            Timestamp("20130102 09:00:02"),
+            Timestamp("20130103 09:00:03"),
+            Timestamp("20130105 09:00:05"),
+            Timestamp("20130106 09:00:06"),
         ],
     )
 
@@ -1039,7 +1044,7 @@ def test_rolling_non_monotonic(method, expected):
     use_expanding = [True, False, True, False, True, True, True, True]
     df = DataFrame({"values": np.arange(len(use_expanding)) ** 2})
 
-    class CustomIndexer(pd.api.indexers.BaseIndexer):
+    class CustomIndexer(BaseIndexer):
         def get_window_bounds(self, num_values, min_periods, center, closed):
             start = np.empty(num_values, dtype=np.int64)
             end = np.empty(num_values, dtype=np.int64)
@@ -1061,7 +1066,7 @@ def get_window_bounds(self, num_values, min_periods, center, closed):
 
 @pytest.mark.parametrize(
     ("index", "window"),
-    [([0, 1, 2, 3, 4], 2), (pd.date_range("2001-01-01", freq="D", periods=5), "2D")],
+    [([0, 1, 2, 3, 4], 2), (date_range("2001-01-01", freq="D", periods=5), "2D")],
 )
 def test_rolling_corr_timedelta_index(index, window):
     # GH: 31286
@@ -1080,7 +1085,7 @@ def test_groupby_rolling_nan_included():
     result = df.groupby("group", dropna=False).rolling(1, min_periods=1).mean()
     expected = DataFrame(
         {"B": [0.0, 2.0, 3.0, 1.0, 4.0]},
-        index=pd.MultiIndex.from_tuples(
+        index=MultiIndex.from_tuples(
             [("g1", 0), ("g1", 2), ("g2", 3), (np.nan, 1), (np.nan, 4)],
             names=["group", None],
         ),