making namespace usage more consistent (#37852)

* making namespace usage more consistent

* Adding more index classes to test_numeric

Author: christopherhadley

pandas/tests/arithmetic/test_numeric.py

@@ -11,7 +11,17 @@
 import pytest
 
 import pandas as pd
-from pandas import Index, Int64Index, Series, Timedelta, TimedeltaIndex, array
+from pandas import (
+    Float64Index,
+    Index,
+    Int64Index,
+    RangeIndex,
+    Series,
+    Timedelta,
+    TimedeltaIndex,
+    UInt64Index,
+    array,
+)
 import pandas._testing as tm
 from pandas.core import ops
 
@@ -43,7 +53,7 @@ def adjust_negative_zero(zero, expected):
 # List comprehension has incompatible type List[PandasObject]; expected List[RangeIndex]
 #  See GH#29725
 ser_or_index: List[Any] = [Series, Index]
-lefts: List[Any] = [pd.RangeIndex(10, 40, 10)]
+lefts: List[Any] = [RangeIndex(10, 40, 10)]
 lefts.extend(
     [
         cls([10, 20, 30], dtype=dtype)
@@ -364,7 +374,7 @@ def test_divmod_zero(self, zero, numeric_idx):
     @pytest.mark.parametrize("op", [operator.truediv, operator.floordiv])
     def test_div_negative_zero(self, zero, numeric_idx, op):
         # Check that -1 / -0.0 returns np.inf, not -np.inf
-        if isinstance(numeric_idx, pd.UInt64Index):
+        if isinstance(numeric_idx, UInt64Index):
             return
         idx = numeric_idx - 3
 
@@ -634,15 +644,15 @@ def test_mul_int_array(self, numeric_idx):
         result = idx * np.array(5, dtype="int64")
         tm.assert_index_equal(result, idx * 5)
 
-        arr_dtype = "uint64" if isinstance(idx, pd.UInt64Index) else "int64"
+        arr_dtype = "uint64" if isinstance(idx, UInt64Index) else "int64"
         result = idx * np.arange(5, dtype=arr_dtype)
         tm.assert_index_equal(result, didx)
 
     def test_mul_int_series(self, numeric_idx):
         idx = numeric_idx
         didx = idx * idx
 
-        arr_dtype = "uint64" if isinstance(idx, pd.UInt64Index) else "int64"
+        arr_dtype = "uint64" if isinstance(idx, UInt64Index) else "int64"
         result = idx * Series(np.arange(5, dtype=arr_dtype))
         tm.assert_series_equal(result, Series(didx))
 
@@ -657,7 +667,7 @@ def test_mul_float_series(self, numeric_idx):
     def test_mul_index(self, numeric_idx):
         # in general not true for RangeIndex
         idx = numeric_idx
-        if not isinstance(idx, pd.RangeIndex):
+        if not isinstance(idx, RangeIndex):
             result = idx * idx
             tm.assert_index_equal(result, idx ** 2)
 
@@ -680,7 +690,7 @@ def test_pow_float(self, op, numeric_idx, box_with_array):
         # test power calculations both ways, GH#14973
         box = box_with_array
         idx = numeric_idx
-        expected = pd.Float64Index(op(idx.values, 2.0))
+        expected = Float64Index(op(idx.values, 2.0))
 
         idx = tm.box_expected(idx, box)
         expected = tm.box_expected(expected, box)
@@ -1040,74 +1050,70 @@ def test_series_divmod_zero(self):
 class TestUFuncCompat:
     @pytest.mark.parametrize(
         "holder",
-        [pd.Int64Index, pd.UInt64Index, pd.Float64Index, pd.RangeIndex, Series],
+        [Int64Index, UInt64Index, Float64Index, RangeIndex, Series],
     )
     def test_ufunc_compat(self, holder):
         box = Series if holder is Series else Index
 
-        if holder is pd.RangeIndex:
-            idx = pd.RangeIndex(0, 5)
+        if holder is RangeIndex:
+            idx = RangeIndex(0, 5)
         else:
             idx = holder(np.arange(5, dtype="int64"))
         result = np.sin(idx)
         expected = box(np.sin(np.arange(5, dtype="int64")))
         tm.assert_equal(result, expected)
 
-    @pytest.mark.parametrize(
-        "holder", [pd.Int64Index, pd.UInt64Index, pd.Float64Index, Series]
-    )
+    @pytest.mark.parametrize("holder", [Int64Index, UInt64Index, Float64Index, Series])
     def test_ufunc_coercions(self, holder):
         idx = holder([1, 2, 3, 4, 5], name="x")
         box = Series if holder is Series else Index
 
         result = np.sqrt(idx)
         assert result.dtype == "f8" and isinstance(result, box)
-        exp = pd.Float64Index(np.sqrt(np.array([1, 2, 3, 4, 5])), name="x")
+        exp = Float64Index(np.sqrt(np.array([1, 2, 3, 4, 5])), name="x")
         exp = tm.box_expected(exp, box)
         tm.assert_equal(result, exp)
 
         result = np.divide(idx, 2.0)
         assert result.dtype == "f8" and isinstance(result, box)
-        exp = pd.Float64Index([0.5, 1.0, 1.5, 2.0, 2.5], name="x")
+        exp = Float64Index([0.5, 1.0, 1.5, 2.0, 2.5], name="x")
         exp = tm.box_expected(exp, box)
         tm.assert_equal(result, exp)
 
         # _evaluate_numeric_binop
         result = idx + 2.0
         assert result.dtype == "f8" and isinstance(result, box)
-        exp = pd.Float64Index([3.0, 4.0, 5.0, 6.0, 7.0], name="x")
+        exp = Float64Index([3.0, 4.0, 5.0, 6.0, 7.0], name="x")
         exp = tm.box_expected(exp, box)
         tm.assert_equal(result, exp)
 
         result = idx - 2.0
         assert result.dtype == "f8" and isinstance(result, box)
-        exp = pd.Float64Index([-1.0, 0.0, 1.0, 2.0, 3.0], name="x")
+        exp = Float64Index([-1.0, 0.0, 1.0, 2.0, 3.0], name="x")
         exp = tm.box_expected(exp, box)
         tm.assert_equal(result, exp)
 
         result = idx * 1.0
         assert result.dtype == "f8" and isinstance(result, box)
-        exp = pd.Float64Index([1.0, 2.0, 3.0, 4.0, 5.0], name="x")
+        exp = Float64Index([1.0, 2.0, 3.0, 4.0, 5.0], name="x")
         exp = tm.box_expected(exp, box)
         tm.assert_equal(result, exp)
 
         result = idx / 2.0
         assert result.dtype == "f8" and isinstance(result, box)
-        exp = pd.Float64Index([0.5, 1.0, 1.5, 2.0, 2.5], name="x")
+        exp = Float64Index([0.5, 1.0, 1.5, 2.0, 2.5], name="x")
         exp = tm.box_expected(exp, box)
         tm.assert_equal(result, exp)
 
-    @pytest.mark.parametrize(
-        "holder", [pd.Int64Index, pd.UInt64Index, pd.Float64Index, Series]
-    )
+    @pytest.mark.parametrize("holder", [Int64Index, UInt64Index, Float64Index, Series])
     def test_ufunc_multiple_return_values(self, holder):
         obj = holder([1, 2, 3], name="x")
         box = Series if holder is Series else Index
 
         result = np.modf(obj)
         assert isinstance(result, tuple)
-        exp1 = pd.Float64Index([0.0, 0.0, 0.0], name="x")
-        exp2 = pd.Float64Index([1.0, 2.0, 3.0], name="x")
+        exp1 = Float64Index([0.0, 0.0, 0.0], name="x")
+        exp2 = Float64Index([1.0, 2.0, 3.0], name="x")
         tm.assert_equal(result[0], tm.box_expected(exp1, box))
         tm.assert_equal(result[1], tm.box_expected(exp2, box))
 
@@ -1173,12 +1179,12 @@ def check_binop(self, ops, scalars, idxs):
         for op in ops:
             for a, b in combinations(idxs, 2):
                 result = op(a, b)
-                expected = op(pd.Int64Index(a), pd.Int64Index(b))
+                expected = op(Int64Index(a), Int64Index(b))
                 tm.assert_index_equal(result, expected)
             for idx in idxs:
                 for scalar in scalars:
                     result = op(idx, scalar)
-                    expected = op(pd.Int64Index(idx), scalar)
+                    expected = op(Int64Index(idx), scalar)
                     tm.assert_index_equal(result, expected)
 
     def test_binops(self):
@@ -1191,10 +1197,10 @@ def test_binops(self):
         ]
         scalars = [-1, 1, 2]
         idxs = [
-            pd.RangeIndex(0, 10, 1),
-            pd.RangeIndex(0, 20, 2),
-            pd.RangeIndex(-10, 10, 2),
-            pd.RangeIndex(5, -5, -1),
+            RangeIndex(0, 10, 1),
+            RangeIndex(0, 20, 2),
+            RangeIndex(-10, 10, 2),
+            RangeIndex(5, -5, -1),
         ]
         self.check_binop(ops, scalars, idxs)
 
@@ -1203,7 +1209,7 @@ def test_binops_pow(self):
         # https://github.com/numpy/numpy/pull/8127
         ops = [pow]
         scalars = [1, 2]
-        idxs = [pd.RangeIndex(0, 10, 1), pd.RangeIndex(0, 20, 2)]
+        idxs = [RangeIndex(0, 10, 1), RangeIndex(0, 20, 2)]
         self.check_binop(ops, scalars, idxs)
 
     # TODO: mod, divmod?
@@ -1221,7 +1227,7 @@ def test_binops_pow(self):
     def test_arithmetic_with_frame_or_series(self, op):
         # check that we return NotImplemented when operating with Series
         # or DataFrame
-        index = pd.RangeIndex(5)
+        index = RangeIndex(5)
         other = Series(np.random.randn(5))
 
         expected = op(Series(index), other)
@@ -1237,26 +1243,26 @@ def test_numeric_compat2(self):
         # validate that we are handling the RangeIndex overrides to numeric ops
         # and returning RangeIndex where possible
 
-        idx = pd.RangeIndex(0, 10, 2)
+        idx = RangeIndex(0, 10, 2)
 
         result = idx * 2
-        expected = pd.RangeIndex(0, 20, 4)
+        expected = RangeIndex(0, 20, 4)
         tm.assert_index_equal(result, expected, exact=True)
 
         result = idx + 2
-        expected = pd.RangeIndex(2, 12, 2)
+        expected = RangeIndex(2, 12, 2)
         tm.assert_index_equal(result, expected, exact=True)
 
         result = idx - 2
-        expected = pd.RangeIndex(-2, 8, 2)
+        expected = RangeIndex(-2, 8, 2)
         tm.assert_index_equal(result, expected, exact=True)
 
         result = idx / 2
-        expected = pd.RangeIndex(0, 5, 1).astype("float64")
+        expected = RangeIndex(0, 5, 1).astype("float64")
         tm.assert_index_equal(result, expected, exact=True)
 
         result = idx / 4
-        expected = pd.RangeIndex(0, 10, 2) / 4
+        expected = RangeIndex(0, 10, 2) / 4
         tm.assert_index_equal(result, expected, exact=True)
 
         result = idx // 1
@@ -1269,25 +1275,25 @@ def test_numeric_compat2(self):
         tm.assert_index_equal(result, expected, exact=True)
 
         # __pow__
-        idx = pd.RangeIndex(0, 1000, 2)
+        idx = RangeIndex(0, 1000, 2)
         result = idx ** 2
         expected = idx._int64index ** 2
         tm.assert_index_equal(Index(result.values), expected, exact=True)
 
         # __floordiv__
         cases_exact = [
-            (pd.RangeIndex(0, 1000, 2), 2, pd.RangeIndex(0, 500, 1)),
-            (pd.RangeIndex(-99, -201, -3), -3, pd.RangeIndex(33, 67, 1)),
-            (pd.RangeIndex(0, 1000, 1), 2, pd.RangeIndex(0, 1000, 1)._int64index // 2),
+            (RangeIndex(0, 1000, 2), 2, RangeIndex(0, 500, 1)),
+            (RangeIndex(-99, -201, -3), -3, RangeIndex(33, 67, 1)),
+            (RangeIndex(0, 1000, 1), 2, RangeIndex(0, 1000, 1)._int64index // 2),
             (
-                pd.RangeIndex(0, 100, 1),
+                RangeIndex(0, 100, 1),
                 2.0,
-                pd.RangeIndex(0, 100, 1)._int64index // 2.0,
+                RangeIndex(0, 100, 1)._int64index // 2.0,
             ),
-            (pd.RangeIndex(0), 50, pd.RangeIndex(0)),
-            (pd.RangeIndex(2, 4, 2), 3, pd.RangeIndex(0, 1, 1)),
-            (pd.RangeIndex(-5, -10, -6), 4, pd.RangeIndex(-2, -1, 1)),
-            (pd.RangeIndex(-100, -200, 3), 2, pd.RangeIndex(0)),
+            (RangeIndex(0), 50, RangeIndex(0)),
+            (RangeIndex(2, 4, 2), 3, RangeIndex(0, 1, 1)),
+            (RangeIndex(-5, -10, -6), 4, RangeIndex(-2, -1, 1)),
+            (RangeIndex(-100, -200, 3), 2, RangeIndex(0)),
         ]
         for idx, div, expected in cases_exact:
             tm.assert_index_equal(idx // div, expected, exact=True)

pandas/tests/dtypes/test_inference.py

@@ -45,6 +45,7 @@
     Index,
     Interval,
     Period,
+    PeriodIndex,
     Series,
     Timedelta,
     TimedeltaIndex,
@@ -884,30 +885,30 @@ def test_infer_dtype_timedelta_with_na(self, na_value, delta):
 
     def test_infer_dtype_period(self):
         # GH 13664
-        arr = np.array([pd.Period("2011-01", freq="D"), pd.Period("2011-02", freq="D")])
+        arr = np.array([Period("2011-01", freq="D"), Period("2011-02", freq="D")])
         assert lib.infer_dtype(arr, skipna=True) == "period"
 
-        arr = np.array([pd.Period("2011-01", freq="D"), pd.Period("2011-02", freq="M")])
+        arr = np.array([Period("2011-01", freq="D"), Period("2011-02", freq="M")])
         assert lib.infer_dtype(arr, skipna=True) == "period"
 
     def test_infer_dtype_period_mixed(self):
         arr = np.array(
-            [pd.Period("2011-01", freq="M"), np.datetime64("nat")], dtype=object
+            [Period("2011-01", freq="M"), np.datetime64("nat")], dtype=object
         )
         assert lib.infer_dtype(arr, skipna=False) == "mixed"
 
         arr = np.array(
-            [np.datetime64("nat"), pd.Period("2011-01", freq="M")], dtype=object
+            [np.datetime64("nat"), Period("2011-01", freq="M")], dtype=object
         )
         assert lib.infer_dtype(arr, skipna=False) == "mixed"
 
     @pytest.mark.parametrize("na_value", [pd.NaT, np.nan])
     def test_infer_dtype_period_with_na(self, na_value):
         # starts with nan
-        arr = np.array([na_value, pd.Period("2011-01", freq="D")])
+        arr = np.array([na_value, Period("2011-01", freq="D")])
         assert lib.infer_dtype(arr, skipna=True) == "period"
 
-        arr = np.array([na_value, pd.Period("2011-01", freq="D"), na_value])
+        arr = np.array([na_value, Period("2011-01", freq="D"), na_value])
         assert lib.infer_dtype(arr, skipna=True) == "period"
 
     @pytest.mark.parametrize(
@@ -1192,8 +1193,8 @@ def test_to_object_array_width(self):
         tm.assert_numpy_array_equal(out, expected)
 
     def test_is_period(self):
-        assert lib.is_period(pd.Period("2011-01", freq="M"))
-        assert not lib.is_period(pd.PeriodIndex(["2011-01"], freq="M"))
+        assert lib.is_period(Period("2011-01", freq="M"))
+        assert not lib.is_period(PeriodIndex(["2011-01"], freq="M"))
         assert not lib.is_period(Timestamp("2011-01"))
         assert not lib.is_period(1)
         assert not lib.is_period(np.nan)

pandas/tests/groupby/test_groupby.py

@@ -8,15 +8,24 @@
 from pandas.errors import PerformanceWarning
 
 import pandas as pd
-from pandas import DataFrame, Index, MultiIndex, Series, Timestamp, date_range, read_csv
+from pandas import (
+    DataFrame,
+    Grouper,
+    Index,
+    MultiIndex,
+    Series,
+    Timestamp,
+    date_range,
+    read_csv,
+)
 import pandas._testing as tm
 from pandas.core.base import SpecificationError
 import pandas.core.common as com
 
 
 def test_repr():
     # GH18203
-    result = repr(pd.Grouper(key="A", level="B"))
+    result = repr(Grouper(key="A", level="B"))
     expected = "Grouper(key='A', level='B', axis=0, sort=False)"
     assert result == expected
 
@@ -1218,7 +1227,7 @@ def test_groupby_keys_same_size_as_index():
         start=Timestamp("2015-09-29T11:34:44-0700"), periods=2, freq=freq
     )
     df = DataFrame([["A", 10], ["B", 15]], columns=["metric", "values"], index=index)
-    result = df.groupby([pd.Grouper(level=0, freq=freq), "metric"]).mean()
+    result = df.groupby([Grouper(level=0, freq=freq), "metric"]).mean()
     expected = df.set_index([df.index, "metric"])
 
     tm.assert_frame_equal(result, expected)
@@ -1815,7 +1824,7 @@ def test_groupby_agg_ohlc_non_first():
         index=pd.date_range("2018-01-01", periods=2, freq="D"),
     )
 
-    result = df.groupby(pd.Grouper(freq="D")).agg(["sum", "ohlc"])
+    result = df.groupby(Grouper(freq="D")).agg(["sum", "ohlc"])
 
     tm.assert_frame_equal(result, expected)
 
@@ -1866,11 +1875,11 @@ def test_groupby_groups_in_BaseGrouper():
     # Test if DataFrame grouped with a pandas.Grouper has correct groups
     mi = MultiIndex.from_product([["A", "B"], ["C", "D"]], names=["alpha", "beta"])
     df = DataFrame({"foo": [1, 2, 1, 2], "bar": [1, 2, 3, 4]}, index=mi)
-    result = df.groupby([pd.Grouper(level="alpha"), "beta"])
+    result = df.groupby([Grouper(level="alpha"), "beta"])
     expected = df.groupby(["alpha", "beta"])
     assert result.groups == expected.groups
 
-    result = df.groupby(["beta", pd.Grouper(level="alpha")])
+    result = df.groupby(["beta", Grouper(level="alpha")])
     expected = df.groupby(["beta", "alpha"])
     assert result.groups == expected.groups
 

pandas/tests/groupby/test_timegrouper.py

@@ -61,10 +61,10 @@ def test_groupby_with_timegrouper(self):
             tm.assert_frame_equal(result1, expected)
 
             df_sorted = df.sort_index()
-            result2 = df_sorted.groupby(pd.Grouper(freq="5D")).sum()
+            result2 = df_sorted.groupby(Grouper(freq="5D")).sum()
             tm.assert_frame_equal(result2, expected)
 
-            result3 = df.groupby(pd.Grouper(freq="5D")).sum()
+            result3 = df.groupby(Grouper(freq="5D")).sum()
             tm.assert_frame_equal(result3, expected)
 
     @pytest.mark.parametrize("should_sort", [True, False])
@@ -92,7 +92,7 @@ def test_groupby_with_timegrouper_methods(self, should_sort):
             df = df.sort_values(by="Quantity", ascending=False)
 
         df = df.set_index("Date", drop=False)
-        g = df.groupby(pd.Grouper(freq="6M"))
+        g = df.groupby(Grouper(freq="6M"))
         assert g.group_keys
 
         assert isinstance(g.grouper, BinGrouper)
@@ -138,7 +138,7 @@ def test_timegrouper_with_reg_groups(self):
                 }
             ).set_index(["Date", "Buyer"])
 
-            result = df.groupby([pd.Grouper(freq="A"), "Buyer"]).sum()
+            result = df.groupby([Grouper(freq="A"), "Buyer"]).sum()
             tm.assert_frame_equal(result, expected)
 
             expected = DataFrame(
@@ -153,7 +153,7 @@ def test_timegrouper_with_reg_groups(self):
                     ],
                 }
             ).set_index(["Date", "Buyer"])
-            result = df.groupby([pd.Grouper(freq="6MS"), "Buyer"]).sum()
+            result = df.groupby([Grouper(freq="6MS"), "Buyer"]).sum()
             tm.assert_frame_equal(result, expected)
 
         df_original = DataFrame(
@@ -191,10 +191,10 @@ def test_timegrouper_with_reg_groups(self):
                 }
             ).set_index(["Date", "Buyer"])
 
-            result = df.groupby([pd.Grouper(freq="1D"), "Buyer"]).sum()
+            result = df.groupby([Grouper(freq="1D"), "Buyer"]).sum()
             tm.assert_frame_equal(result, expected)
 
-            result = df.groupby([pd.Grouper(freq="1M"), "Buyer"]).sum()
+            result = df.groupby([Grouper(freq="1M"), "Buyer"]).sum()
             expected = DataFrame(
                 {
                     "Buyer": "Carl Joe Mark".split(),
@@ -210,26 +210,26 @@ def test_timegrouper_with_reg_groups(self):
 
             # passing the name
             df = df.reset_index()
-            result = df.groupby([pd.Grouper(freq="1M", key="Date"), "Buyer"]).sum()
+            result = df.groupby([Grouper(freq="1M", key="Date"), "Buyer"]).sum()
             tm.assert_frame_equal(result, expected)
 
             with pytest.raises(KeyError, match="'The grouper name foo is not found'"):
-                df.groupby([pd.Grouper(freq="1M", key="foo"), "Buyer"]).sum()
+                df.groupby([Grouper(freq="1M", key="foo"), "Buyer"]).sum()
 
             # passing the level
             df = df.set_index("Date")
-            result = df.groupby([pd.Grouper(freq="1M", level="Date"), "Buyer"]).sum()
+            result = df.groupby([Grouper(freq="1M", level="Date"), "Buyer"]).sum()
             tm.assert_frame_equal(result, expected)
-            result = df.groupby([pd.Grouper(freq="1M", level=0), "Buyer"]).sum()
+            result = df.groupby([Grouper(freq="1M", level=0), "Buyer"]).sum()
             tm.assert_frame_equal(result, expected)
 
             with pytest.raises(ValueError, match="The level foo is not valid"):
-                df.groupby([pd.Grouper(freq="1M", level="foo"), "Buyer"]).sum()
+                df.groupby([Grouper(freq="1M", level="foo"), "Buyer"]).sum()
 
             # multi names
             df = df.copy()
             df["Date"] = df.index + pd.offsets.MonthEnd(2)
-            result = df.groupby([pd.Grouper(freq="1M", key="Date"), "Buyer"]).sum()
+            result = df.groupby([Grouper(freq="1M", key="Date"), "Buyer"]).sum()
             expected = DataFrame(
                 {
                     "Buyer": "Carl Joe Mark".split(),
@@ -247,7 +247,7 @@ def test_timegrouper_with_reg_groups(self):
             msg = "The Grouper cannot specify both a key and a level!"
             with pytest.raises(ValueError, match=msg):
                 df.groupby(
-                    [pd.Grouper(freq="1M", key="Date", level="Date"), "Buyer"]
+                    [Grouper(freq="1M", key="Date", level="Date"), "Buyer"]
                 ).sum()
 
             # single groupers
@@ -258,18 +258,18 @@ def test_timegrouper_with_reg_groups(self):
                     [datetime(2013, 10, 31, 0, 0)], freq=offsets.MonthEnd(), name="Date"
                 ),
             )
-            result = df.groupby(pd.Grouper(freq="1M")).sum()
+            result = df.groupby(Grouper(freq="1M")).sum()
             tm.assert_frame_equal(result, expected)
 
-            result = df.groupby([pd.Grouper(freq="1M")]).sum()
+            result = df.groupby([Grouper(freq="1M")]).sum()
             tm.assert_frame_equal(result, expected)
 
             expected.index = expected.index.shift(1)
             assert expected.index.freq == offsets.MonthEnd()
-            result = df.groupby(pd.Grouper(freq="1M", key="Date")).sum()
+            result = df.groupby(Grouper(freq="1M", key="Date")).sum()
             tm.assert_frame_equal(result, expected)
 
-            result = df.groupby([pd.Grouper(freq="1M", key="Date")]).sum()
+            result = df.groupby([Grouper(freq="1M", key="Date")]).sum()
             tm.assert_frame_equal(result, expected)
 
     @pytest.mark.parametrize("freq", ["D", "M", "A", "Q-APR"])
@@ -324,13 +324,11 @@ def test_timegrouper_with_reg_groups_freq(self, freq):
         expected.name = "whole_cost"
 
         result1 = (
-            df.sort_index()
-            .groupby([pd.Grouper(freq=freq), "user_id"])["whole_cost"]
-            .sum()
+            df.sort_index().groupby([Grouper(freq=freq), "user_id"])["whole_cost"].sum()
         )
         tm.assert_series_equal(result1, expected)
 
-        result2 = df.groupby([pd.Grouper(freq=freq), "user_id"])["whole_cost"].sum()
+        result2 = df.groupby([Grouper(freq=freq), "user_id"])["whole_cost"].sum()
         tm.assert_series_equal(result2, expected)
 
     def test_timegrouper_get_group(self):
@@ -361,7 +359,7 @@ def test_timegrouper_get_group(self):
         dt_list = ["2013-09-30", "2013-10-31", "2013-12-31"]
 
         for df in [df_original, df_reordered]:
-            grouped = df.groupby(pd.Grouper(freq="M", key="Date"))
+            grouped = df.groupby(Grouper(freq="M", key="Date"))
             for t, expected in zip(dt_list, expected_list):
                 dt = Timestamp(t)
                 result = grouped.get_group(dt)
@@ -376,7 +374,7 @@ def test_timegrouper_get_group(self):
         g_list = [("Joe", "2013-09-30"), ("Carl", "2013-10-31"), ("Joe", "2013-12-31")]
 
         for df in [df_original, df_reordered]:
-            grouped = df.groupby(["Buyer", pd.Grouper(freq="M", key="Date")])
+            grouped = df.groupby(["Buyer", Grouper(freq="M", key="Date")])
             for (b, t), expected in zip(g_list, expected_list):
                 dt = Timestamp(t)
                 result = grouped.get_group((b, dt))
@@ -393,7 +391,7 @@ def test_timegrouper_get_group(self):
         ]
 
         for df in [df_original, df_reordered]:
-            grouped = df.groupby(pd.Grouper(freq="M"))
+            grouped = df.groupby(Grouper(freq="M"))
             for t, expected in zip(dt_list, expected_list):
                 dt = Timestamp(t)
                 result = grouped.get_group(dt)
@@ -410,8 +408,8 @@ def test_timegrouper_apply_return_type_series(self):
         def sumfunc_series(x):
             return Series([x["value"].sum()], ("sum",))
 
-        expected = df.groupby(pd.Grouper(key="date")).apply(sumfunc_series)
-        result = df_dt.groupby(pd.Grouper(freq="M", key="date")).apply(sumfunc_series)
+        expected = df.groupby(Grouper(key="date")).apply(sumfunc_series)
+        result = df_dt.groupby(Grouper(freq="M", key="date")).apply(sumfunc_series)
         tm.assert_frame_equal(
             result.reset_index(drop=True), expected.reset_index(drop=True)
         )
@@ -427,7 +425,7 @@ def test_timegrouper_apply_return_type_value(self):
         def sumfunc_value(x):
             return x.value.sum()
 
-        expected = df.groupby(pd.Grouper(key="date")).apply(sumfunc_value)
+        expected = df.groupby(Grouper(key="date")).apply(sumfunc_value)
         result = df_dt.groupby(Grouper(freq="M", key="date")).apply(sumfunc_value)
         tm.assert_series_equal(
             result.reset_index(drop=True), expected.reset_index(drop=True)
@@ -744,7 +742,7 @@ def test_nunique_with_timegrouper_and_nat(self):
             }
         )
 
-        grouper = pd.Grouper(key="time", freq="h")
+        grouper = Grouper(key="time", freq="h")
         result = test.groupby(grouper)["data"].nunique()
         expected = test[test.time.notnull()].groupby(grouper)["data"].nunique()
         expected.index = expected.index._with_freq(None)
@@ -761,7 +759,7 @@ def test_scalar_call_versus_list_call(self):
             "value": [1, 2, 3],
         }
         data_frame = DataFrame(data_frame).set_index("time")
-        grouper = pd.Grouper(freq="D")
+        grouper = Grouper(freq="D")
 
         grouped = data_frame.groupby(grouper)
         result = grouped.count()

pandas/tests/indexes/categorical/test_map.py

@@ -25,16 +25,16 @@ def test_map_str(self, data, categories, ordered):
         tm.assert_index_equal(result, expected)
 
     def test_map(self):
-        ci = pd.CategoricalIndex(list("ABABC"), categories=list("CBA"), ordered=True)
+        ci = CategoricalIndex(list("ABABC"), categories=list("CBA"), ordered=True)
         result = ci.map(lambda x: x.lower())
-        exp = pd.CategoricalIndex(list("ababc"), categories=list("cba"), ordered=True)
+        exp = CategoricalIndex(list("ababc"), categories=list("cba"), ordered=True)
         tm.assert_index_equal(result, exp)
 
-        ci = pd.CategoricalIndex(
+        ci = CategoricalIndex(
             list("ABABC"), categories=list("BAC"), ordered=False, name="XXX"
         )
         result = ci.map(lambda x: x.lower())
-        exp = pd.CategoricalIndex(
+        exp = CategoricalIndex(
             list("ababc"), categories=list("bac"), ordered=False, name="XXX"
         )
         tm.assert_index_equal(result, exp)
@@ -45,13 +45,13 @@ def test_map(self):
         )
 
         # change categories dtype
-        ci = pd.CategoricalIndex(list("ABABC"), categories=list("BAC"), ordered=False)
+        ci = CategoricalIndex(list("ABABC"), categories=list("BAC"), ordered=False)
 
         def f(x):
             return {"A": 10, "B": 20, "C": 30}.get(x)
 
         result = ci.map(f)
-        exp = pd.CategoricalIndex(
+        exp = CategoricalIndex(
             [10, 20, 10, 20, 30], categories=[20, 10, 30], ordered=False
         )
         tm.assert_index_equal(result, exp)

pandas/tests/indexes/interval/test_interval.py

@@ -869,7 +869,7 @@ def test_set_closed_errors(self, bad_closed):
 
     def test_is_all_dates(self):
         # GH 23576
-        year_2017 = pd.Interval(
+        year_2017 = Interval(
             Timestamp("2017-01-01 00:00:00"), Timestamp("2018-01-01 00:00:00")
         )
         year_2017_index = pd.IntervalIndex([year_2017])

pandas/tests/indexes/period/test_ops.py

@@ -270,17 +270,17 @@ def test_order(self):
             assert ordered.freq == "D"
 
     def test_nat(self):
-        assert pd.PeriodIndex._na_value is NaT
-        assert pd.PeriodIndex([], freq="M")._na_value is NaT
+        assert PeriodIndex._na_value is NaT
+        assert PeriodIndex([], freq="M")._na_value is NaT
 
-        idx = pd.PeriodIndex(["2011-01-01", "2011-01-02"], freq="D")
+        idx = PeriodIndex(["2011-01-01", "2011-01-02"], freq="D")
         assert idx._can_hold_na
 
         tm.assert_numpy_array_equal(idx._isnan, np.array([False, False]))
         assert idx.hasnans is False
         tm.assert_numpy_array_equal(idx._nan_idxs, np.array([], dtype=np.intp))
 
-        idx = pd.PeriodIndex(["2011-01-01", "NaT"], freq="D")
+        idx = PeriodIndex(["2011-01-01", "NaT"], freq="D")
         assert idx._can_hold_na
 
         tm.assert_numpy_array_equal(idx._isnan, np.array([False, True]))
@@ -290,7 +290,7 @@ def test_nat(self):
     @pytest.mark.parametrize("freq", ["D", "M"])
     def test_equals(self, freq):
         # GH#13107
-        idx = pd.PeriodIndex(["2011-01-01", "2011-01-02", "NaT"], freq=freq)
+        idx = PeriodIndex(["2011-01-01", "2011-01-02", "NaT"], freq=freq)
         assert idx.equals(idx)
         assert idx.equals(idx.copy())
         assert idx.equals(idx.astype(object))
@@ -299,7 +299,7 @@ def test_equals(self, freq):
         assert not idx.equals(list(idx))
         assert not idx.equals(Series(idx))
 
-        idx2 = pd.PeriodIndex(["2011-01-01", "2011-01-02", "NaT"], freq="H")
+        idx2 = PeriodIndex(["2011-01-01", "2011-01-02", "NaT"], freq="H")
         assert not idx.equals(idx2)
         assert not idx.equals(idx2.copy())
         assert not idx.equals(idx2.astype(object))
@@ -308,7 +308,7 @@ def test_equals(self, freq):
         assert not idx.equals(Series(idx2))
 
         # same internal, different tz
-        idx3 = pd.PeriodIndex._simple_new(
+        idx3 = PeriodIndex._simple_new(
             idx._values._simple_new(idx._values.asi8, freq="H")
         )
         tm.assert_numpy_array_equal(idx.asi8, idx3.asi8)

pandas/tests/series/test_constructors.py

@@ -27,6 +27,7 @@
     MultiIndex,
     NaT,
     Period,
+    RangeIndex,
     Series,
     Timestamp,
     date_range,
@@ -267,7 +268,7 @@ def test_constructor_index_dtype(self, dtype):
             (["1", "2"]),
             (list(pd.date_range("1/1/2011", periods=2, freq="H"))),
             (list(pd.date_range("1/1/2011", periods=2, freq="H", tz="US/Eastern"))),
-            ([pd.Interval(left=0, right=5)]),
+            ([Interval(left=0, right=5)]),
         ],
     )
     def test_constructor_list_str(self, input_vals, string_dtype):
@@ -624,7 +625,7 @@ def test_constructor_copy(self):
             pd.period_range("2012Q1", periods=3, freq="Q"),
             Index(list("abc")),
             pd.Int64Index([1, 2, 3]),
-            pd.RangeIndex(0, 3),
+            RangeIndex(0, 3),
         ],
         ids=lambda x: type(x).__name__,
     )
@@ -1004,7 +1005,7 @@ def test_construction_interval(self, interval_constructor):
     )
     def test_constructor_infer_interval(self, data_constructor):
         # GH 23563: consistent closed results in interval dtype
-        data = [pd.Interval(0, 1), pd.Interval(0, 2), None]
+        data = [Interval(0, 1), Interval(0, 2), None]
         result = Series(data_constructor(data))
         expected = Series(IntervalArray(data))
         assert result.dtype == "interval[float64]"
@@ -1015,7 +1016,7 @@ def test_constructor_infer_interval(self, data_constructor):
     )
     def test_constructor_interval_mixed_closed(self, data_constructor):
         # GH 23563: mixed closed results in object dtype (not interval dtype)
-        data = [pd.Interval(0, 1, closed="both"), pd.Interval(0, 2, closed="neither")]
+        data = [Interval(0, 1, closed="both"), Interval(0, 2, closed="neither")]
         result = Series(data_constructor(data))
         assert result.dtype == object
         assert result.tolist() == data