Rename datetime_frame to more descriptive name

Author: MarcoGorelli

pandas/conftest.py

@@ -112,7 +112,7 @@ def axis_series(request):
 
 
 @pytest.fixture
-def datetime_frame():
+def float_frame_dt_index():
     """
     Fixture for DataFrame of floats with DatetimeIndex
 

pandas/tests/frame/indexing/test_indexing.py

@@ -256,44 +256,48 @@ def inc(x):
         tm.assert_frame_equal(df, expected)
 
     def test_getitem_boolean(
-        self, float_string_frame, mixed_float_frame, mixed_int_frame, datetime_frame
+        self,
+        float_string_frame,
+        mixed_float_frame,
+        mixed_int_frame,
+        float_frame_dt_index,
     ):
         # boolean indexing
-        d = datetime_frame.index[10]
-        indexer = datetime_frame.index > d
+        d = float_frame_dt_index.index[10]
+        indexer = float_frame_dt_index.index > d
         indexer_obj = indexer.astype(object)
 
-        subindex = datetime_frame.index[indexer]
-        subframe = datetime_frame[indexer]
+        subindex = float_frame_dt_index.index[indexer]
+        subframe = float_frame_dt_index[indexer]
 
         tm.assert_index_equal(subindex, subframe.index)
         with pytest.raises(ValueError, match="Item wrong length"):
-            datetime_frame[indexer[:-1]]
+            float_frame_dt_index[indexer[:-1]]
 
-        subframe_obj = datetime_frame[indexer_obj]
+        subframe_obj = float_frame_dt_index[indexer_obj]
         tm.assert_frame_equal(subframe_obj, subframe)
 
         with pytest.raises(ValueError, match="Boolean array expected"):
-            datetime_frame[datetime_frame]
+            float_frame_dt_index[float_frame_dt_index]
 
         # test that Series work
-        indexer_obj = Series(indexer_obj, datetime_frame.index)
+        indexer_obj = Series(indexer_obj, float_frame_dt_index.index)
 
-        subframe_obj = datetime_frame[indexer_obj]
+        subframe_obj = float_frame_dt_index[indexer_obj]
         tm.assert_frame_equal(subframe_obj, subframe)
 
         # test that Series indexers reindex
         # we are producing a warning that since the passed boolean
         # key is not the same as the given index, we will reindex
         # not sure this is really necessary
         with tm.assert_produces_warning(UserWarning, check_stacklevel=False):
-            indexer_obj = indexer_obj.reindex(datetime_frame.index[::-1])
-            subframe_obj = datetime_frame[indexer_obj]
+            indexer_obj = indexer_obj.reindex(float_frame_dt_index.index[::-1])
+            subframe_obj = float_frame_dt_index[indexer_obj]
             tm.assert_frame_equal(subframe_obj, subframe)
 
         # test df[df > 0]
         for df in [
-            datetime_frame,
+            float_frame_dt_index,
             float_string_frame,
             mixed_float_frame,
             mixed_int_frame,
@@ -320,10 +324,10 @@ def test_getitem_boolean(
                 if bif[c].dtype != bifw[c].dtype:
                     assert bif[c].dtype == df[c].dtype
 
-    def test_getitem_boolean_casting(self, datetime_frame):
+    def test_getitem_boolean_casting(self, float_frame_dt_index):
 
         # don't upcast if we don't need to
-        df = datetime_frame.copy()
+        df = float_frame_dt_index.copy()
         df["E"] = 1
         df["E"] = df["E"].astype("int32")
         df["E1"] = df["E"].copy()

pandas/tests/frame/indexing/test_xs.py

@@ -11,7 +11,7 @@
 
 
 class TestXS:
-    def test_xs(self, float_frame, datetime_frame):
+    def test_xs(self, float_frame, float_frame_dt_index):
         idx = float_frame.index[5]
         xs = float_frame.xs(idx)
         for item, value in xs.items():
@@ -31,7 +31,7 @@ def test_xs(self, float_frame, datetime_frame):
         with pytest.raises(
             KeyError, match=re.escape("Timestamp('1999-12-31 00:00:00', freq='B')")
         ):
-            datetime_frame.xs(datetime_frame.index[0] - BDay())
+            float_frame_dt_index.xs(float_frame_dt_index.index[0] - BDay())
 
         # xs get column
         series = float_frame.xs("A", axis=1)

pandas/tests/frame/methods/test_cov_corr.py

@@ -155,11 +155,11 @@ def test_corr_int(self):
 
 
 class TestDataFrameCorrWith:
-    def test_corrwith(self, datetime_frame):
-        a = datetime_frame
+    def test_corrwith(self, float_frame_dt_index):
+        a = float_frame_dt_index
         noise = Series(np.random.randn(len(a)), index=a.index)
 
-        b = datetime_frame.add(noise, axis=0)
+        b = float_frame_dt_index.add(noise, axis=0)
 
         # make sure order does not matter
         b = b.reindex(columns=b.columns[::-1], index=b.index[::-1][10:])
@@ -203,9 +203,9 @@ def test_corrwith_with_objects(self):
         expected = df1.loc[:, cols].corrwith(df2.loc[:, cols], axis=1)
         tm.assert_series_equal(result, expected)
 
-    def test_corrwith_series(self, datetime_frame):
-        result = datetime_frame.corrwith(datetime_frame["A"])
-        expected = datetime_frame.apply(datetime_frame["A"].corr)
+    def test_corrwith_series(self, float_frame_dt_index):
+        result = float_frame_dt_index.corrwith(float_frame_dt_index["A"])
+        expected = float_frame_dt_index.apply(float_frame_dt_index["A"].corr)
 
         tm.assert_series_equal(result, expected)
 

pandas/tests/frame/methods/test_diff.py

@@ -7,11 +7,12 @@
 
 
 class TestDataFrameDiff:
-    def test_diff(self, datetime_frame):
-        the_diff = datetime_frame.diff(1)
+    def test_diff(self, float_frame_dt_index):
+        the_diff = float_frame_dt_index.diff(1)
 
         tm.assert_series_equal(
-            the_diff["A"], datetime_frame["A"] - datetime_frame["A"].shift(1)
+            the_diff["A"],
+            float_frame_dt_index["A"] - float_frame_dt_index["A"].shift(1),
         )
 
         # int dtype
@@ -23,7 +24,7 @@ def test_diff(self, datetime_frame):
         assert rs.s[1] == 1
 
         # mixed numeric
-        tf = datetime_frame.astype("float32")
+        tf = float_frame_dt_index.astype("float32")
         the_diff = tf.diff(1)
         tm.assert_series_equal(the_diff["A"], tf["A"] - tf["A"].shift(1))
 
@@ -99,14 +100,14 @@ def test_diff_mixed_dtype(self):
         result = df.diff()
         assert result[0].dtype == np.float64
 
-    def test_diff_neg_n(self, datetime_frame):
-        rs = datetime_frame.diff(-1)
-        xp = datetime_frame - datetime_frame.shift(-1)
+    def test_diff_neg_n(self, float_frame_dt_index):
+        rs = float_frame_dt_index.diff(-1)
+        xp = float_frame_dt_index - float_frame_dt_index.shift(-1)
         tm.assert_frame_equal(rs, xp)
 
-    def test_diff_float_n(self, datetime_frame):
-        rs = datetime_frame.diff(1.0)
-        xp = datetime_frame.diff(1)
+    def test_diff_float_n(self, float_frame_dt_index):
+        rs = float_frame_dt_index.diff(1.0)
+        xp = float_frame_dt_index.diff(1)
         tm.assert_frame_equal(rs, xp)
 
     def test_diff_axis(self):

pandas/tests/frame/methods/test_pct_change.py

@@ -21,20 +21,22 @@ def test_pct_change_numeric(self):
 
             tm.assert_frame_equal(result, expected)
 
-    def test_pct_change(self, datetime_frame):
-        rs = datetime_frame.pct_change(fill_method=None)
-        tm.assert_frame_equal(rs, datetime_frame / datetime_frame.shift(1) - 1)
+    def test_pct_change(self, float_frame_dt_index):
+        rs = float_frame_dt_index.pct_change(fill_method=None)
+        tm.assert_frame_equal(
+            rs, float_frame_dt_index / float_frame_dt_index.shift(1) - 1
+        )
 
-        rs = datetime_frame.pct_change(2)
-        filled = datetime_frame.fillna(method="pad")
+        rs = float_frame_dt_index.pct_change(2)
+        filled = float_frame_dt_index.fillna(method="pad")
         tm.assert_frame_equal(rs, filled / filled.shift(2) - 1)
 
-        rs = datetime_frame.pct_change(fill_method="bfill", limit=1)
-        filled = datetime_frame.fillna(method="bfill", limit=1)
+        rs = float_frame_dt_index.pct_change(fill_method="bfill", limit=1)
+        filled = float_frame_dt_index.fillna(method="bfill", limit=1)
         tm.assert_frame_equal(rs, filled / filled.shift(1) - 1)
 
-        rs = datetime_frame.pct_change(freq="5D")
-        filled = datetime_frame.fillna(method="pad")
+        rs = float_frame_dt_index.pct_change(freq="5D")
+        filled = float_frame_dt_index.fillna(method="pad")
         tm.assert_frame_equal(
             rs, (filled / filled.shift(freq="5D") - 1).reindex_like(filled)
         )
@@ -61,18 +63,20 @@ def test_pct_change_shift_over_nas(self):
         ],
     )
     def test_pct_change_periods_freq(
-        self, datetime_frame, freq, periods, fill_method, limit
+        self, float_frame_dt_index, freq, periods, fill_method, limit
     ):
         # GH#7292
-        rs_freq = datetime_frame.pct_change(
+        rs_freq = float_frame_dt_index.pct_change(
             freq=freq, fill_method=fill_method, limit=limit
         )
-        rs_periods = datetime_frame.pct_change(
+        rs_periods = float_frame_dt_index.pct_change(
             periods, fill_method=fill_method, limit=limit
         )
         tm.assert_frame_equal(rs_freq, rs_periods)
 
-        empty_ts = DataFrame(index=datetime_frame.index, columns=datetime_frame.columns)
+        empty_ts = DataFrame(
+            index=float_frame_dt_index.index, columns=float_frame_dt_index.columns
+        )
         rs_freq = empty_ts.pct_change(freq=freq, fill_method=fill_method, limit=limit)
         rs_periods = empty_ts.pct_change(periods, fill_method=fill_method, limit=limit)
         tm.assert_frame_equal(rs_freq, rs_periods)

pandas/tests/frame/methods/test_quantile.py

@@ -17,10 +17,10 @@ def test_quantile_sparse(self):
         expected = pd.Series([1.5, 3.5], name=0.5)
         tm.assert_series_equal(result, expected)
 
-    def test_quantile(self, datetime_frame):
+    def test_quantile(self, float_frame_dt_index):
         from numpy import percentile
 
-        df = datetime_frame
+        df = float_frame_dt_index
         q = df.quantile(0.1, axis=0)
         assert q["A"] == percentile(df["A"], 10)
         tm.assert_index_equal(q.index, df.columns)
@@ -163,11 +163,11 @@ def test_quantile_interpolation(self):
         )
         tm.assert_frame_equal(result, expected)
 
-    def test_quantile_interpolation_datetime(self, datetime_frame):
+    def test_quantile_interpolation_datetime(self, float_frame_dt_index):
         # see gh-10174
 
         # interpolation = linear (default case)
-        df = datetime_frame
+        df = float_frame_dt_index
         q = df.quantile(0.1, axis=0, interpolation="linear")
         assert q["A"] == np.percentile(df["A"], 10)
 
@@ -251,11 +251,11 @@ def test_quantile_datetime(self):
         # result = df[['a', 'c']].quantile(.5)
         # result = df[['a', 'c']].quantile([.5])
 
-    def test_quantile_invalid(self, datetime_frame):
+    def test_quantile_invalid(self, float_frame_dt_index):
         msg = "percentiles should all be in the interval \\[0, 1\\]"
         for invalid in [-1, 2, [0.5, -1], [0.5, 2]]:
             with pytest.raises(ValueError, match=msg):
-                datetime_frame.quantile(invalid)
+                float_frame_dt_index.quantile(invalid)
 
     def test_quantile_box(self):
         df = DataFrame(

pandas/tests/frame/methods/test_replace.py

@@ -22,13 +22,13 @@ def mix_abc() -> Dict[str, List[Union[float, str]]]:
 
 
 class TestDataFrameReplace:
-    def test_replace_inplace(self, datetime_frame, float_string_frame):
-        datetime_frame["A"][:5] = np.nan
-        datetime_frame["A"][-5:] = np.nan
+    def test_replace_inplace(self, float_frame_dt_index, float_string_frame):
+        float_frame_dt_index["A"][:5] = np.nan
+        float_frame_dt_index["A"][-5:] = np.nan
 
-        tsframe = datetime_frame.copy()
+        tsframe = float_frame_dt_index.copy()
         tsframe.replace(np.nan, 0, inplace=True)
-        tm.assert_frame_equal(tsframe, datetime_frame.fillna(0))
+        tm.assert_frame_equal(tsframe, float_frame_dt_index.fillna(0))
 
         # mixed type
         mf = float_string_frame
@@ -39,9 +39,9 @@ def test_replace_inplace(self, datetime_frame, float_string_frame):
         expected = float_string_frame.fillna(value=0)
         tm.assert_frame_equal(result, expected)
 
-        tsframe = datetime_frame.copy()
+        tsframe = float_frame_dt_index.copy()
         tsframe.replace([np.nan], [0], inplace=True)
-        tm.assert_frame_equal(tsframe, datetime_frame.fillna(0))
+        tm.assert_frame_equal(tsframe, float_frame_dt_index.fillna(0))
 
     def test_regex_replace_scalar(self, mix_ab):
         obj = {"a": list("ab.."), "b": list("efgh")}
@@ -582,17 +582,17 @@ def test_replace_regex_metachar(self, metachar):
         expected = DataFrame({"a": ["paren", "else"]})
         tm.assert_frame_equal(result, expected)
 
-    def test_replace(self, datetime_frame):
-        datetime_frame["A"][:5] = np.nan
-        datetime_frame["A"][-5:] = np.nan
+    def test_replace(self, float_frame_dt_index):
+        float_frame_dt_index["A"][:5] = np.nan
+        float_frame_dt_index["A"][-5:] = np.nan
 
-        zero_filled = datetime_frame.replace(np.nan, -1e8)
-        tm.assert_frame_equal(zero_filled, datetime_frame.fillna(-1e8))
-        tm.assert_frame_equal(zero_filled.replace(-1e8, np.nan), datetime_frame)
+        zero_filled = float_frame_dt_index.replace(np.nan, -1e8)
+        tm.assert_frame_equal(zero_filled, float_frame_dt_index.fillna(-1e8))
+        tm.assert_frame_equal(zero_filled.replace(-1e8, np.nan), float_frame_dt_index)
 
-        datetime_frame["A"][:5] = np.nan
-        datetime_frame["A"][-5:] = np.nan
-        datetime_frame["B"][:5] = -1e8
+        float_frame_dt_index["A"][:5] = np.nan
+        float_frame_dt_index["A"][-5:] = np.nan
+        float_frame_dt_index["B"][:5] = -1e8
 
         # empty
         df = DataFrame(index=["a", "b"])
@@ -792,30 +792,30 @@ def test_replace_simple_nested_dict_with_nonexistent_value(self):
         result = df.replace({"col": {-1: "-", 1: "a", 4: "b"}})
         tm.assert_frame_equal(expected, result)
 
-    def test_replace_value_is_none(self, datetime_frame):
-        orig_value = datetime_frame.iloc[0, 0]
-        orig2 = datetime_frame.iloc[1, 0]
+    def test_replace_value_is_none(self, float_frame_dt_index):
+        orig_value = float_frame_dt_index.iloc[0, 0]
+        orig2 = float_frame_dt_index.iloc[1, 0]
 
-        datetime_frame.iloc[0, 0] = np.nan
-        datetime_frame.iloc[1, 0] = 1
+        float_frame_dt_index.iloc[0, 0] = np.nan
+        float_frame_dt_index.iloc[1, 0] = 1
 
-        result = datetime_frame.replace(to_replace={np.nan: 0})
-        expected = datetime_frame.T.replace(to_replace={np.nan: 0}).T
+        result = float_frame_dt_index.replace(to_replace={np.nan: 0})
+        expected = float_frame_dt_index.T.replace(to_replace={np.nan: 0}).T
         tm.assert_frame_equal(result, expected)
 
-        result = datetime_frame.replace(to_replace={np.nan: 0, 1: -1e8})
-        tsframe = datetime_frame.copy()
+        result = float_frame_dt_index.replace(to_replace={np.nan: 0, 1: -1e8})
+        tsframe = float_frame_dt_index.copy()
         tsframe.iloc[0, 0] = 0
         tsframe.iloc[1, 0] = -1e8
         expected = tsframe
         tm.assert_frame_equal(expected, result)
-        datetime_frame.iloc[0, 0] = orig_value
-        datetime_frame.iloc[1, 0] = orig2
+        float_frame_dt_index.iloc[0, 0] = orig_value
+        float_frame_dt_index.iloc[1, 0] = orig2
 
-    def test_replace_for_new_dtypes(self, datetime_frame):
+    def test_replace_for_new_dtypes(self, float_frame_dt_index):
 
         # dtypes
-        tsframe = datetime_frame.copy().astype(np.float32)
+        tsframe = float_frame_dt_index.copy().astype(np.float32)
         tsframe["A"][:5] = np.nan
         tsframe["A"][-5:] = np.nan