GH39992 update inconsistent namespace usage for reductions

pandas/tests/reductions/test_reductions.py

@@ -83,16 +83,16 @@ def test_nanminmax(self, opname, dtype, val, index_or_series):
         # GH#7261
         klass = index_or_series
 
-        if dtype in ["Int64", "boolean"] and klass == pd.Index:
+        if dtype in ["Int64", "boolean"] and klass == Index:
             pytest.skip("EAs can't yet be stored in an index")
 
         def check_missing(res):
             if dtype == "datetime64[ns]":
-                return res is pd.NaT
+                return res is NaT
             elif dtype == "Int64":
                 return res is pd.NA
             else:
-                return pd.isna(res)
+                return isna(res)
 
         obj = klass([None], dtype=dtype)
         assert check_missing(getattr(obj, opname)())
@@ -120,15 +120,15 @@ def test_nanargminmax(self, opname, index_or_series):
         klass = index_or_series
         arg_op = "arg" + opname if klass is Index else "idx" + opname
 
-        obj = klass([pd.NaT, datetime(2011, 11, 1)])
+        obj = klass([NaT, datetime(2011, 11, 1)])
         assert getattr(obj, arg_op)() == 1
         result = getattr(obj, arg_op)(skipna=False)
         if klass is Series:
             assert np.isnan(result)
         else:
             assert result == -1
 
-        obj = klass([pd.NaT, datetime(2011, 11, 1), pd.NaT])
+        obj = klass([NaT, datetime(2011, 11, 1), NaT])
         # check DatetimeIndex non-monotonic path
         assert getattr(obj, arg_op)() == 1
         result = getattr(obj, arg_op)(skipna=False)
@@ -145,8 +145,8 @@ def test_nanops_empty_object(self, opname, index_or_series, dtype):
 
         obj = klass([], dtype=dtype)
 
-        assert getattr(obj, opname)() is pd.NaT
-        assert getattr(obj, opname)(skipna=False) is pd.NaT
+        assert getattr(obj, opname)() is NaT
+        assert getattr(obj, opname)(skipna=False) is NaT
 
         with pytest.raises(ValueError, match="empty sequence"):
             getattr(obj, arg_op)()
@@ -170,13 +170,13 @@ def test_argminmax(self):
         assert obj.argmin(skipna=False) == -1
         assert obj.argmax(skipna=False) == -1
 
-        obj = Index([pd.NaT, datetime(2011, 11, 1), datetime(2011, 11, 2), pd.NaT])
+        obj = Index([NaT, datetime(2011, 11, 1), datetime(2011, 11, 2), NaT])
         assert obj.argmin() == 1
         assert obj.argmax() == 2
         assert obj.argmin(skipna=False) == -1
         assert obj.argmax(skipna=False) == -1
 
-        obj = Index([pd.NaT])
+        obj = Index([NaT])
         assert obj.argmin() == -1
         assert obj.argmax() == -1
         assert obj.argmin(skipna=False) == -1
@@ -186,7 +186,7 @@ def test_argminmax(self):
     def test_same_tz_min_max_axis_1(self, op, expected_col):
         # GH 10390
         df = DataFrame(
-            pd.date_range("2016-01-01 00:00:00", periods=3, tz="UTC"), columns=["a"]
+            date_range("2016-01-01 00:00:00", periods=3, tz="UTC"), columns=["a"]
         )
         df["b"] = df.a.subtract(Timedelta(seconds=3600))
         result = getattr(df, op)(axis=1)
@@ -262,13 +262,13 @@ def test_minmax_timedelta64(self):
     def test_minmax_timedelta_empty_or_na(self, op):
         # Return NaT
         obj = TimedeltaIndex([])
-        assert getattr(obj, op)() is pd.NaT
+        assert getattr(obj, op)() is NaT
 
-        obj = TimedeltaIndex([pd.NaT])
-        assert getattr(obj, op)() is pd.NaT
+        obj = TimedeltaIndex([NaT])
+        assert getattr(obj, op)() is NaT
 
-        obj = TimedeltaIndex([pd.NaT, pd.NaT, pd.NaT])
-        assert getattr(obj, op)() is pd.NaT
+        obj = TimedeltaIndex([NaT, NaT, NaT])
+        assert getattr(obj, op)() is NaT
 
     def test_numpy_minmax_timedelta64(self):
         td = timedelta_range("16815 days", "16820 days", freq="D")
@@ -373,7 +373,7 @@ def test_minmax_tz(self, tz_naive_fixture):
 
         # non-monotonic
         idx2 = DatetimeIndex(
-            ["2011-01-01", pd.NaT, "2011-01-03", "2011-01-02", pd.NaT], tz=tz
+            ["2011-01-01", NaT, "2011-01-03", "2011-01-02", NaT], tz=tz
         )
         assert not idx2.is_monotonic
 
@@ -387,13 +387,13 @@ def test_minmax_tz(self, tz_naive_fixture):
     def test_minmax_nat_datetime64(self, op):
         # Return NaT
         obj = DatetimeIndex([])
-        assert pd.isna(getattr(obj, op)())
+        assert isna(getattr(obj, op)())
 
-        obj = DatetimeIndex([pd.NaT])
-        assert pd.isna(getattr(obj, op)())
+        obj = DatetimeIndex([NaT])
+        assert isna(getattr(obj, op)())
 
-        obj = DatetimeIndex([pd.NaT, pd.NaT, pd.NaT])
-        assert pd.isna(getattr(obj, op)())
+        obj = DatetimeIndex([NaT, NaT, NaT])
+        assert isna(getattr(obj, op)())
 
     def test_numpy_minmax_integer(self):
         # GH#26125
@@ -449,7 +449,7 @@ def test_numpy_minmax_range(self):
         # is the same as basic integer index
 
     def test_numpy_minmax_datetime64(self):
-        dr = pd.date_range(start="2016-01-15", end="2016-01-20")
+        dr = date_range(start="2016-01-15", end="2016-01-20")
 
         assert np.min(dr) == Timestamp("2016-01-15 00:00:00", freq="D")
         assert np.max(dr) == Timestamp("2016-01-20 00:00:00", freq="D")
@@ -588,7 +588,7 @@ def test_empty(self, method, unit, use_bottleneck, dtype):
             assert result == unit
 
             result = getattr(s, method)(min_count=1)
-            assert pd.isna(result)
+            assert isna(result)
 
             # Skipna, default
             result = getattr(s, method)(skipna=True)
@@ -599,13 +599,13 @@ def test_empty(self, method, unit, use_bottleneck, dtype):
             assert result == unit
 
             result = getattr(s, method)(skipna=True, min_count=1)
-            assert pd.isna(result)
+            assert isna(result)
 
             result = getattr(s, method)(skipna=False, min_count=0)
             assert result == unit
 
             result = getattr(s, method)(skipna=False, min_count=1)
-            assert pd.isna(result)
+            assert isna(result)
 
             # All-NA
             s = Series([np.nan], dtype=dtype)
@@ -618,7 +618,7 @@ def test_empty(self, method, unit, use_bottleneck, dtype):
             assert result == unit
 
             result = getattr(s, method)(min_count=1)
-            assert pd.isna(result)
+            assert isna(result)
 
             # Skipna, default
             result = getattr(s, method)(skipna=True)
@@ -629,7 +629,7 @@ def test_empty(self, method, unit, use_bottleneck, dtype):
             assert result == unit
 
             result = getattr(s, method)(skipna=True, min_count=1)
-            assert pd.isna(result)
+            assert isna(result)
 
             # Mix of valid, empty
             s = Series([np.nan, 1], dtype=dtype)
@@ -657,18 +657,18 @@ def test_empty(self, method, unit, use_bottleneck, dtype):
 
             s = Series([1], dtype=dtype)
             result = getattr(s, method)(min_count=2)
-            assert pd.isna(result)
+            assert isna(result)
 
             result = getattr(s, method)(skipna=False, min_count=2)
-            assert pd.isna(result)
+            assert isna(result)
 
             s = Series([np.nan], dtype=dtype)
             result = getattr(s, method)(min_count=2)
-            assert pd.isna(result)
+            assert isna(result)
 
             s = Series([np.nan, 1], dtype=dtype)
             result = getattr(s, method)(min_count=2)
-            assert pd.isna(result)
+            assert isna(result)
 
     @pytest.mark.parametrize("method, unit", [("sum", 0.0), ("prod", 1.0)])
     def test_empty_multi(self, method, unit):
@@ -716,7 +716,7 @@ def test_ops_consistency_on_empty(self, method):
 
         # float
         result = getattr(Series(dtype=float), method)()
-        assert pd.isna(result)
+        assert isna(result)
 
         # timedelta64[ns]
         tdser = Series([], dtype="m8[ns]")
@@ -732,7 +732,7 @@ def test_ops_consistency_on_empty(self, method):
                 getattr(tdser, method)()
         else:
             result = getattr(tdser, method)()
-            assert result is pd.NaT
+            assert result is NaT
 
     def test_nansum_buglet(self):
         ser = Series([1.0, np.nan], index=[0, 1])
@@ -770,10 +770,10 @@ def test_sum_overflow(self, use_bottleneck):
     def test_empty_timeseries_reductions_return_nat(self):
         # covers GH#11245
         for dtype in ("m8[ns]", "m8[ns]", "M8[ns]", "M8[ns, UTC]"):
-            assert Series([], dtype=dtype).min() is pd.NaT
-            assert Series([], dtype=dtype).max() is pd.NaT
-            assert Series([], dtype=dtype).min(skipna=False) is pd.NaT
-            assert Series([], dtype=dtype).max(skipna=False) is pd.NaT
+            assert Series([], dtype=dtype).min() is NaT
+            assert Series([], dtype=dtype).max() is NaT
+            assert Series([], dtype=dtype).min(skipna=False) is NaT
+            assert Series([], dtype=dtype).max(skipna=False) is NaT
 
     def test_numpy_argmin(self):
         # See GH#16830
@@ -820,7 +820,7 @@ def test_idxmin(self):
 
         # skipna or no
         assert string_series[string_series.idxmin()] == string_series.min()
-        assert pd.isna(string_series.idxmin(skipna=False))
+        assert isna(string_series.idxmin(skipna=False))
 
         # no NaNs
         nona = string_series.dropna()
@@ -829,10 +829,10 @@ def test_idxmin(self):
 
         # all NaNs
         allna = string_series * np.nan
-        assert pd.isna(allna.idxmin())
+        assert isna(allna.idxmin())
 
         # datetime64[ns]
-        s = Series(pd.date_range("20130102", periods=6))
+        s = Series(date_range("20130102", periods=6))
         result = s.idxmin()
         assert result == 0
 
@@ -850,7 +850,7 @@ def test_idxmax(self):
 
         # skipna or no
         assert string_series[string_series.idxmax()] == string_series.max()
-        assert pd.isna(string_series.idxmax(skipna=False))
+        assert isna(string_series.idxmax(skipna=False))
 
         # no NaNs
         nona = string_series.dropna()
@@ -859,7 +859,7 @@ def test_idxmax(self):
 
         # all NaNs
         allna = string_series * np.nan
-        assert pd.isna(allna.idxmax())
+        assert isna(allna.idxmax())
 
         from pandas import date_range
 
@@ -1010,7 +1010,7 @@ def test_any_all_datetimelike(self):
     def test_timedelta64_analytics(self):
 
         # index min/max
-        dti = pd.date_range("2012-1-1", periods=3, freq="D")
+        dti = date_range("2012-1-1", periods=3, freq="D")
         td = Series(dti) - Timestamp("20120101")
 
         result = td.idxmin()
@@ -1030,8 +1030,8 @@ def test_timedelta64_analytics(self):
         assert result == 2
 
         # abs
-        s1 = Series(pd.date_range("20120101", periods=3))
-        s2 = Series(pd.date_range("20120102", periods=3))
+        s1 = Series(date_range("20120101", periods=3))
+        s2 = Series(date_range("20120102", periods=3))
         expected = Series(s2 - s1)
 
         result = np.abs(s1 - s2)
@@ -1108,35 +1108,35 @@ class TestDatetime64SeriesReductions:
     @pytest.mark.parametrize(
         "nat_ser",
         [
-            Series([pd.NaT, pd.NaT]),
-            Series([pd.NaT, Timedelta("nat")]),
+            Series([NaT, NaT]),
+            Series([NaT, Timedelta("nat")]),
             Series([Timedelta("nat"), Timedelta("nat")]),
         ],
     )
     def test_minmax_nat_series(self, nat_ser):
         # GH#23282
-        assert nat_ser.min() is pd.NaT
-        assert nat_ser.max() is pd.NaT
-        assert nat_ser.min(skipna=False) is pd.NaT
-        assert nat_ser.max(skipna=False) is pd.NaT
+        assert nat_ser.min() is NaT
+        assert nat_ser.max() is NaT
+        assert nat_ser.min(skipna=False) is NaT
+        assert nat_ser.max(skipna=False) is NaT
 
     @pytest.mark.parametrize(
         "nat_df",
         [
-            DataFrame([pd.NaT, pd.NaT]),
-            DataFrame([pd.NaT, Timedelta("nat")]),
+            DataFrame([NaT, NaT]),
+            DataFrame([NaT, Timedelta("nat")]),
             DataFrame([Timedelta("nat"), Timedelta("nat")]),
         ],
     )
     def test_minmax_nat_dataframe(self, nat_df):
         # GH#23282
-        assert nat_df.min()[0] is pd.NaT
-        assert nat_df.max()[0] is pd.NaT
-        assert nat_df.min(skipna=False)[0] is pd.NaT
-        assert nat_df.max(skipna=False)[0] is pd.NaT
+        assert nat_df.min()[0] is NaT
+        assert nat_df.max()[0] is NaT
+        assert nat_df.min(skipna=False)[0] is NaT
+        assert nat_df.max(skipna=False)[0] is NaT
 
     def test_min_max(self):
-        rng = pd.date_range("1/1/2000", "12/31/2000")
+        rng = date_range("1/1/2000", "12/31/2000")
         rng2 = rng.take(np.random.permutation(len(rng)))
 
         the_min = rng2.min()
@@ -1150,7 +1150,7 @@ def test_min_max(self):
         assert rng.max() == rng[-1]
 
     def test_min_max_series(self):
-        rng = pd.date_range("1/1/2000", periods=10, freq="4h")
+        rng = date_range("1/1/2000", periods=10, freq="4h")
         lvls = ["A", "A", "A", "B", "B", "B", "C", "C", "C", "C"]
         df = DataFrame({"TS": rng, "V": np.random.randn(len(rng)), "L": lvls})