REF: test_first_valid_index (pandas-dev#32317)

Author: jbrockmendel

pandas/tests/frame/test_timeseries.py

@@ -1,8 +1,7 @@
 import numpy as np
-import pytest
 
 import pandas as pd
-from pandas import DataFrame, Series, date_range, to_datetime
+from pandas import DataFrame, date_range, to_datetime
 import pandas._testing as tm
 
 
@@ -60,65 +59,6 @@ def test_frame_append_datetime64_col_other_units(self):
 
             assert (tmp["dates"].values == ex_vals).all()
 
-    @pytest.mark.parametrize(
-        "data,idx,expected_first,expected_last",
-        [
-            ({"A": [1, 2, 3]}, [1, 1, 2], 1, 2),
-            ({"A": [1, 2, 3]}, [1, 2, 2], 1, 2),
-            ({"A": [1, 2, 3, 4]}, ["d", "d", "d", "d"], "d", "d"),
-            ({"A": [1, np.nan, 3]}, [1, 1, 2], 1, 2),
-            ({"A": [np.nan, np.nan, 3]}, [1, 1, 2], 2, 2),
-            ({"A": [1, np.nan, 3]}, [1, 2, 2], 1, 2),
-        ],
-    )
-    def test_first_last_valid(
-        self, float_frame, data, idx, expected_first, expected_last
-    ):
-        N = len(float_frame.index)
-        mat = np.random.randn(N)
-        mat[:5] = np.nan
-        mat[-5:] = np.nan
-
-        frame = DataFrame({"foo": mat}, index=float_frame.index)
-        index = frame.first_valid_index()
-
-        assert index == frame.index[5]
-
-        index = frame.last_valid_index()
-        assert index == frame.index[-6]
-
-        # GH12800
-        empty = DataFrame()
-        assert empty.last_valid_index() is None
-        assert empty.first_valid_index() is None
-
-        # GH17400: no valid entries
-        frame[:] = np.nan
-        assert frame.last_valid_index() is None
-        assert frame.first_valid_index() is None
-
-        # GH20499: its preserves freq with holes
-        frame.index = date_range("20110101", periods=N, freq="B")
-        frame.iloc[1] = 1
-        frame.iloc[-2] = 1
-        assert frame.first_valid_index() == frame.index[1]
-        assert frame.last_valid_index() == frame.index[-2]
-        assert frame.first_valid_index().freq == frame.index.freq
-        assert frame.last_valid_index().freq == frame.index.freq
-
-        # GH 21441
-        df = DataFrame(data, index=idx)
-        assert expected_first == df.first_valid_index()
-        assert expected_last == df.last_valid_index()
-
-    @pytest.mark.parametrize("klass", [Series, DataFrame])
-    def test_first_valid_index_all_nan(self, klass):
-        # GH#9752 Series/DataFrame should both return None, not raise
-        obj = klass([np.nan])
-
-        assert obj.first_valid_index() is None
-        assert obj.iloc[:0].first_valid_index() is None
-
     def test_operation_on_NaT(self):
         # Both NaT and Timestamp are in DataFrame.
         df = pd.DataFrame({"foo": [pd.NaT, pd.NaT, pd.Timestamp("2012-05-01")]})

pandas/tests/generic/methods/__init__.py

@@ -0,0 +1,3 @@
+"""
+Tests for methods shared by DataFrame and Series.
+"""

pandas/tests/generic/methods/test_first_valid_index.py

@@ -0,0 +1,90 @@
+"""
+Includes test for last_valid_index.
+"""
+import numpy as np
+import pytest
+
+from pandas import DataFrame, Series, date_range
+import pandas._testing as tm
+
+
+class TestFirstValidIndex:
+    @pytest.mark.parametrize("klass", [Series, DataFrame])
+    def test_first_valid_index_single_nan(self, klass):
+        # GH#9752 Series/DataFrame should both return None, not raise
+        obj = klass([np.nan])
+
+        assert obj.first_valid_index() is None
+        assert obj.iloc[:0].first_valid_index() is None
+
+    @pytest.mark.parametrize(
+        "empty", [DataFrame(), Series(dtype=object), Series([], index=[], dtype=object)]
+    )
+    def test_first_valid_index_empty(self, empty):
+        # GH#12800
+        assert empty.last_valid_index() is None
+        assert empty.first_valid_index() is None
+
+    @pytest.mark.parametrize(
+        "data,idx,expected_first,expected_last",
+        [
+            ({"A": [1, 2, 3]}, [1, 1, 2], 1, 2),
+            ({"A": [1, 2, 3]}, [1, 2, 2], 1, 2),
+            ({"A": [1, 2, 3, 4]}, ["d", "d", "d", "d"], "d", "d"),
+            ({"A": [1, np.nan, 3]}, [1, 1, 2], 1, 2),
+            ({"A": [np.nan, np.nan, 3]}, [1, 1, 2], 2, 2),
+            ({"A": [1, np.nan, 3]}, [1, 2, 2], 1, 2),
+        ],
+    )
+    def test_first_last_valid_frame(self, data, idx, expected_first, expected_last):
+        # GH#21441
+        df = DataFrame(data, index=idx)
+        assert expected_first == df.first_valid_index()
+        assert expected_last == df.last_valid_index()
+
+    @pytest.mark.parametrize("index_func", [tm.makeStringIndex, tm.makeDateIndex])
+    def test_first_last_valid(self, index_func):
+        N = 30
+        index = index_func(N)
+        mat = np.random.randn(N)
+        mat[:5] = np.nan
+        mat[-5:] = np.nan
+
+        frame = DataFrame({"foo": mat}, index=index)
+        assert frame.first_valid_index() == frame.index[5]
+        assert frame.last_valid_index() == frame.index[-6]
+
+        ser = frame["foo"]
+        assert ser.first_valid_index() == frame.index[5]
+        assert ser.last_valid_index() == frame.index[-6]
+
+    @pytest.mark.parametrize("index_func", [tm.makeStringIndex, tm.makeDateIndex])
+    def test_first_last_valid_all_nan(self, index_func):
+        # GH#17400: no valid entries
+        index = index_func(30)
+        frame = DataFrame(np.nan, columns=["foo"], index=index)
+
+        assert frame.last_valid_index() is None
+        assert frame.first_valid_index() is None
+
+        ser = frame["foo"]
+        assert ser.first_valid_index() is None
+        assert ser.last_valid_index() is None
+
+    def test_first_last_valid_preserves_freq(self):
+        # GH#20499: its preserves freq with holes
+        index = date_range("20110101", periods=30, freq="B")
+        frame = DataFrame(np.nan, columns=["foo"], index=index)
+
+        frame.iloc[1] = 1
+        frame.iloc[-2] = 1
+        assert frame.first_valid_index() == frame.index[1]
+        assert frame.last_valid_index() == frame.index[-2]
+        assert frame.first_valid_index().freq == frame.index.freq
+        assert frame.last_valid_index().freq == frame.index.freq
+
+        ts = frame["foo"]
+        assert ts.first_valid_index() == ts.index[1]
+        assert ts.last_valid_index() == ts.index[-2]
+        assert ts.first_valid_index().freq == ts.index.freq
+        assert ts.last_valid_index().freq == ts.index.freq

pandas/tests/series/test_timeseries.py

@@ -48,39 +48,6 @@ def test_autocorr(self, datetime_series):
         else:
             assert corr1 == corr2
 
-    def test_first_last_valid(self, datetime_series):
-        ts = datetime_series.copy()
-        ts[:5] = np.NaN
-
-        index = ts.first_valid_index()
-        assert index == ts.index[5]
-
-        ts[-5:] = np.NaN
-        index = ts.last_valid_index()
-        assert index == ts.index[-6]
-
-        ts[:] = np.nan
-        assert ts.last_valid_index() is None
-        assert ts.first_valid_index() is None
-
-        ser = Series([], index=[], dtype=object)
-        assert ser.last_valid_index() is None
-        assert ser.first_valid_index() is None
-
-        # GH12800
-        empty = Series(dtype=object)
-        assert empty.last_valid_index() is None
-        assert empty.first_valid_index() is None
-
-        # GH20499: its preserves freq with holes
-        ts.index = date_range("20110101", periods=len(ts), freq="B")
-        ts.iloc[1] = 1
-        ts.iloc[-2] = 1
-        assert ts.first_valid_index() == ts.index[1]
-        assert ts.last_valid_index() == ts.index[-2]
-        assert ts.first_valid_index().freq == ts.index.freq
-        assert ts.last_valid_index().freq == ts.index.freq
-
     def test_mpl_compat_hack(self, datetime_series):
 
         # This is currently failing because the test was relying on