diff --git a/pandas/tests/arithmetic/test_numeric.py b/pandas/tests/arithmetic/test_numeric.py index 836b1dcddf0dd..f4f258b559939 100644 --- a/pandas/tests/arithmetic/test_numeric.py +++ b/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,7 +644,7 @@ 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) @@ -642,7 +652,7 @@ 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) diff --git a/pandas/tests/dtypes/test_inference.py b/pandas/tests/dtypes/test_inference.py index 438a22c99a4eb..014094923185f 100644 --- a/pandas/tests/dtypes/test_inference.py +++ b/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) diff --git a/pandas/tests/groupby/test_groupby.py b/pandas/tests/groupby/test_groupby.py index cd1fc67772849..da556523a3341 100644 --- a/pandas/tests/groupby/test_groupby.py +++ b/pandas/tests/groupby/test_groupby.py @@ -8,7 +8,16 @@ 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 @@ -16,7 +25,7 @@ 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 diff --git a/pandas/tests/groupby/test_timegrouper.py b/pandas/tests/groupby/test_timegrouper.py index c3282758a23f2..2340168415382 100644 --- a/pandas/tests/groupby/test_timegrouper.py +++ b/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() diff --git a/pandas/tests/indexes/categorical/test_map.py b/pandas/tests/indexes/categorical/test_map.py index 1a326c1acea46..c15818bc87f7c 100644 --- a/pandas/tests/indexes/categorical/test_map.py +++ b/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) diff --git a/pandas/tests/indexes/interval/test_interval.py b/pandas/tests/indexes/interval/test_interval.py index 45683ba48b4c4..ff871ee45daed 100644 --- a/pandas/tests/indexes/interval/test_interval.py +++ b/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]) diff --git a/pandas/tests/indexes/period/test_ops.py b/pandas/tests/indexes/period/test_ops.py index 10134b20e7d3e..8e7cb7d86edf5 100644 --- a/pandas/tests/indexes/period/test_ops.py +++ b/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) diff --git a/pandas/tests/series/test_constructors.py b/pandas/tests/series/test_constructors.py index c8fbbcf9aed20..1d75ed25ad2e9 100644 --- a/pandas/tests/series/test_constructors.py +++ b/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