From 5abb16aa9b8b5ec52f4362a9ac379899d2ec5d48 Mon Sep 17 00:00:00 2001 From: Brock Date: Tue, 14 Nov 2023 09:40:27 -0800 Subject: [PATCH] TST: parametrize tests over dt64 unit --- .../indexes/datetimes/test_date_range.py | 6 ++ .../tests/indexes/interval/test_interval.py | 6 +- pandas/tests/reductions/test_reductions.py | 19 +++-- pandas/tests/resample/test_datetime_index.py | 71 ++++++++++--------- .../tests/scalar/timedelta/test_arithmetic.py | 6 +- pandas/tests/series/methods/test_map.py | 32 +++++---- pandas/tests/series/methods/test_quantile.py | 4 +- .../tests/series/methods/test_tz_localize.py | 6 +- .../tests/series/methods/test_value_counts.py | 16 ++--- pandas/tests/series/test_arithmetic.py | 10 ++- pandas/tests/test_algos.py | 36 +++++----- pandas/tests/tseries/holiday/test_calendar.py | 7 +- pandas/tests/tseries/holiday/test_holiday.py | 1 + .../tseries/offsets/test_business_hour.py | 6 -- pandas/tests/window/test_rolling.py | 51 ++++++------- pandas/tests/window/test_timeseries_window.py | 55 +++++++------- 16 files changed, 181 insertions(+), 151 deletions(-) diff --git a/pandas/tests/indexes/datetimes/test_date_range.py b/pandas/tests/indexes/datetimes/test_date_range.py index b0a91401b5181..b1b4e738a6365 100644 --- a/pandas/tests/indexes/datetimes/test_date_range.py +++ b/pandas/tests/indexes/datetimes/test_date_range.py @@ -473,6 +473,12 @@ def test_date_range_businesshour(self): rng = date_range("2014-07-04 09:00", "2014-07-08 16:00", freq="bh") tm.assert_index_equal(idx, rng) + def test_date_range_business_hour_short(self, unit): + # GH#49835 + idx4 = date_range(start="2014-07-01 10:00", freq="bh", periods=1, unit=unit) + expected4 = DatetimeIndex(["2014-07-01 10:00"], freq="bh").as_unit(unit) + tm.assert_index_equal(idx4, expected4) + def test_date_range_timedelta(self): start = "2020-01-01" end = "2020-01-11" diff --git a/pandas/tests/indexes/interval/test_interval.py b/pandas/tests/indexes/interval/test_interval.py index fcf297fd1b092..dea40eff8d2ac 100644 --- a/pandas/tests/indexes/interval/test_interval.py +++ b/pandas/tests/indexes/interval/test_interval.py @@ -86,7 +86,11 @@ def test_properties(self, closed): [ [1, 1, 2, 5, 15, 53, 217, 1014, 5335, 31240, 201608], [-np.inf, -100, -10, 0.5, 1, 1.5, 3.8, 101, 202, np.inf], - pd.to_datetime(["20170101", "20170202", "20170303", "20170404"]), + date_range("2017-01-01", "2017-01-04"), + pytest.param( + date_range("2017-01-01", "2017-01-04", unit="s"), + marks=pytest.mark.xfail(reason="mismatched result unit"), + ), pd.to_timedelta(["1ns", "2ms", "3s", "4min", "5h", "6D"]), ], ) diff --git a/pandas/tests/reductions/test_reductions.py b/pandas/tests/reductions/test_reductions.py index 560b2377ada70..17227e7cfabc7 100644 --- a/pandas/tests/reductions/test_reductions.py +++ b/pandas/tests/reductions/test_reductions.py @@ -822,24 +822,23 @@ def test_numpy_argmax(self): # See GH#16830 data = np.arange(1, 11) - s = Series(data, index=data) - result = np.argmax(s) + ser = Series(data, index=data) + result = np.argmax(ser) expected = np.argmax(data) assert result == expected - result = s.argmax() + result = ser.argmax() assert result == expected msg = "the 'out' parameter is not supported" with pytest.raises(ValueError, match=msg): - np.argmax(s, out=data) + np.argmax(ser, out=data) - def test_idxmin_dt64index(self): + def test_idxmin_dt64index(self, unit): # GH#43587 should have NaT instead of NaN - ser = Series( - [1.0, 2.0, np.nan], index=DatetimeIndex(["NaT", "2015-02-08", "NaT"]) - ) + dti = DatetimeIndex(["NaT", "2015-02-08", "NaT"]).as_unit(unit) + ser = Series([1.0, 2.0, np.nan], index=dti) msg = "The behavior of Series.idxmin with all-NA values" with tm.assert_produces_warning(FutureWarning, match=msg): res = ser.idxmin(skipna=False) @@ -853,12 +852,12 @@ def test_idxmin_dt64index(self): msg = "The behavior of DataFrame.idxmin with all-NA values" with tm.assert_produces_warning(FutureWarning, match=msg): res = df.idxmin(skipna=False) - assert res.dtype == "M8[ns]" + assert res.dtype == f"M8[{unit}]" assert res.isna().all() msg = "The behavior of DataFrame.idxmax with all-NA values" with tm.assert_produces_warning(FutureWarning, match=msg): res = df.idxmax(skipna=False) - assert res.dtype == "M8[ns]" + assert res.dtype == f"M8[{unit}]" assert res.isna().all() def test_idxmin(self): diff --git a/pandas/tests/resample/test_datetime_index.py b/pandas/tests/resample/test_datetime_index.py index 21937a35629a0..16c1c7caa9e3a 100644 --- a/pandas/tests/resample/test_datetime_index.py +++ b/pandas/tests/resample/test_datetime_index.py @@ -1357,15 +1357,16 @@ def test_resample_consistency(unit): @pytest.mark.parametrize("dates", [dates1, dates2, dates3]) -def test_resample_timegrouper(dates): +def test_resample_timegrouper(dates, unit): # GH 7227 + dates = DatetimeIndex(dates).as_unit(unit) df = DataFrame({"A": dates, "B": np.arange(len(dates))}) result = df.set_index("A").resample("ME").count() exp_idx = DatetimeIndex( ["2014-07-31", "2014-08-31", "2014-09-30", "2014-10-31", "2014-11-30"], freq="ME", name="A", - ) + ).as_unit(unit) expected = DataFrame({"B": [1, 0, 2, 2, 1]}, index=exp_idx) if df["A"].isna().any(): expected.index = expected.index._with_freq(None) @@ -2039,26 +2040,39 @@ def test_resample_BM_deprecated(): tm.assert_series_equal(result, expected) -def test_resample_ms_closed_right(): +def test_resample_ms_closed_right(unit): # https://github.com/pandas-dev/pandas/issues/55271 - dti = date_range(start="2020-01-31", freq="1min", periods=6000) + dti = date_range(start="2020-01-31", freq="1min", periods=6000, unit=unit) df = DataFrame({"ts": dti}, index=dti) grouped = df.resample("MS", closed="right") result = grouped.last() + exp_dti = DatetimeIndex( + [datetime(2020, 1, 1), datetime(2020, 2, 1)], freq="MS" + ).as_unit(unit) expected = DataFrame( {"ts": [datetime(2020, 2, 1), datetime(2020, 2, 4, 3, 59)]}, - index=DatetimeIndex([datetime(2020, 1, 1), datetime(2020, 2, 1)], freq="MS"), - ) + index=exp_dti, + ).astype(f"M8[{unit}]") tm.assert_frame_equal(result, expected) @pytest.mark.parametrize("freq", ["B", "C"]) -def test_resample_c_b_closed_right(freq: str): +def test_resample_c_b_closed_right(freq: str, unit): # https://github.com/pandas-dev/pandas/issues/55281 - dti = date_range(start="2020-01-31", freq="1min", periods=6000) + dti = date_range(start="2020-01-31", freq="1min", periods=6000, unit=unit) df = DataFrame({"ts": dti}, index=dti) grouped = df.resample(freq, closed="right") result = grouped.last() + + exp_dti = DatetimeIndex( + [ + datetime(2020, 1, 30), + datetime(2020, 1, 31), + datetime(2020, 2, 3), + datetime(2020, 2, 4), + ], + freq=freq, + ).as_unit(unit) expected = DataFrame( { "ts": [ @@ -2068,35 +2082,28 @@ def test_resample_c_b_closed_right(freq: str): datetime(2020, 2, 4, 3, 59), ] }, - index=DatetimeIndex( - [ - datetime(2020, 1, 30), - datetime(2020, 1, 31), - datetime(2020, 2, 3), - datetime(2020, 2, 4), - ], - freq=freq, - ), - ) + index=exp_dti, + ).astype(f"M8[{unit}]") tm.assert_frame_equal(result, expected) -def test_resample_b_55282(): +def test_resample_b_55282(unit): # https://github.com/pandas-dev/pandas/issues/55282 - s = Series( - [1, 2, 3, 4, 5, 6], index=date_range("2023-09-26", periods=6, freq="12h") - ) - result = s.resample("B", closed="right", label="right").mean() + dti = date_range("2023-09-26", periods=6, freq="12h", unit=unit) + ser = Series([1, 2, 3, 4, 5, 6], index=dti) + result = ser.resample("B", closed="right", label="right").mean() + + exp_dti = DatetimeIndex( + [ + datetime(2023, 9, 26), + datetime(2023, 9, 27), + datetime(2023, 9, 28), + datetime(2023, 9, 29), + ], + freq="B", + ).as_unit(unit) expected = Series( [1.0, 2.5, 4.5, 6.0], - index=DatetimeIndex( - [ - datetime(2023, 9, 26), - datetime(2023, 9, 27), - datetime(2023, 9, 28), - datetime(2023, 9, 29), - ], - freq="B", - ), + index=exp_dti, ) tm.assert_series_equal(result, expected) diff --git a/pandas/tests/scalar/timedelta/test_arithmetic.py b/pandas/tests/scalar/timedelta/test_arithmetic.py index e583de1f489db..363ae1fa9c644 100644 --- a/pandas/tests/scalar/timedelta/test_arithmetic.py +++ b/pandas/tests/scalar/timedelta/test_arithmetic.py @@ -309,13 +309,13 @@ def test_td_add_sub_td64_ndarray(self): def test_td_add_sub_dt64_ndarray(self): td = Timedelta("1 day") - other = pd.to_datetime(["2000-01-01"]).values + other = np.array(["2000-01-01"], dtype="M8[ns]") - expected = pd.to_datetime(["2000-01-02"]).values + expected = np.array(["2000-01-02"], dtype="M8[ns]") tm.assert_numpy_array_equal(td + other, expected) tm.assert_numpy_array_equal(other + td, expected) - expected = pd.to_datetime(["1999-12-31"]).values + expected = np.array(["1999-12-31"], dtype="M8[ns]") tm.assert_numpy_array_equal(-td + other, expected) tm.assert_numpy_array_equal(other - td, expected) diff --git a/pandas/tests/series/methods/test_map.py b/pandas/tests/series/methods/test_map.py index 6b357281c831b..6d78ecd61cdcb 100644 --- a/pandas/tests/series/methods/test_map.py +++ b/pandas/tests/series/methods/test_map.py @@ -418,38 +418,44 @@ def __missing__(self, key): tm.assert_series_equal(result, expected) -def test_map_box(): +def test_map_box_dt64(unit): vals = [pd.Timestamp("2011-01-01"), pd.Timestamp("2011-01-02")] - s = Series(vals) - assert s.dtype == "datetime64[ns]" + ser = Series(vals).dt.as_unit(unit) + assert ser.dtype == f"datetime64[{unit}]" # boxed value must be Timestamp instance - res = s.map(lambda x: f"{type(x).__name__}_{x.day}_{x.tz}") + res = ser.map(lambda x: f"{type(x).__name__}_{x.day}_{x.tz}") exp = Series(["Timestamp_1_None", "Timestamp_2_None"]) tm.assert_series_equal(res, exp) + +def test_map_box_dt64tz(unit): vals = [ pd.Timestamp("2011-01-01", tz="US/Eastern"), pd.Timestamp("2011-01-02", tz="US/Eastern"), ] - s = Series(vals) - assert s.dtype == "datetime64[ns, US/Eastern]" - res = s.map(lambda x: f"{type(x).__name__}_{x.day}_{x.tz}") + ser = Series(vals).dt.as_unit(unit) + assert ser.dtype == f"datetime64[{unit}, US/Eastern]" + res = ser.map(lambda x: f"{type(x).__name__}_{x.day}_{x.tz}") exp = Series(["Timestamp_1_US/Eastern", "Timestamp_2_US/Eastern"]) tm.assert_series_equal(res, exp) + +def test_map_box_td64(unit): # timedelta vals = [pd.Timedelta("1 days"), pd.Timedelta("2 days")] - s = Series(vals) - assert s.dtype == "timedelta64[ns]" - res = s.map(lambda x: f"{type(x).__name__}_{x.days}") + ser = Series(vals).dt.as_unit(unit) + assert ser.dtype == f"timedelta64[{unit}]" + res = ser.map(lambda x: f"{type(x).__name__}_{x.days}") exp = Series(["Timedelta_1", "Timedelta_2"]) tm.assert_series_equal(res, exp) + +def test_map_box_period(): # period vals = [pd.Period("2011-01-01", freq="M"), pd.Period("2011-01-02", freq="M")] - s = Series(vals) - assert s.dtype == "Period[M]" - res = s.map(lambda x: f"{type(x).__name__}_{x.freqstr}") + ser = Series(vals) + assert ser.dtype == "Period[M]" + res = ser.map(lambda x: f"{type(x).__name__}_{x.freqstr}") exp = Series(["Period_M", "Period_M"]) tm.assert_series_equal(res, exp) diff --git a/pandas/tests/series/methods/test_quantile.py b/pandas/tests/series/methods/test_quantile.py index 70ad6b3016a57..016635a50fdf4 100644 --- a/pandas/tests/series/methods/test_quantile.py +++ b/pandas/tests/series/methods/test_quantile.py @@ -48,7 +48,8 @@ def test_quantile(self, datetime_series): with pytest.raises(ValueError, match=msg): s.quantile(percentile_array) - def test_quantile_multi(self, datetime_series): + def test_quantile_multi(self, datetime_series, unit): + datetime_series.index = datetime_series.index.as_unit(unit) qs = [0.1, 0.9] result = datetime_series.quantile(qs) expected = Series( @@ -68,6 +69,7 @@ def test_quantile_multi(self, datetime_series): [Timestamp("2000-01-10 19:12:00"), Timestamp("2000-01-10 19:12:00")], index=[0.2, 0.2], name="xxx", + dtype=f"M8[{unit}]", ) tm.assert_series_equal(result, expected) diff --git a/pandas/tests/series/methods/test_tz_localize.py b/pandas/tests/series/methods/test_tz_localize.py index c2b1569d3f391..45620a721f442 100644 --- a/pandas/tests/series/methods/test_tz_localize.py +++ b/pandas/tests/series/methods/test_tz_localize.py @@ -70,11 +70,11 @@ def test_series_tz_localize_matching_index(self): ["foo", "invalid"], ], ) - def test_tz_localize_nonexistent(self, warsaw, method, exp): + def test_tz_localize_nonexistent(self, warsaw, method, exp, unit): # GH 8917 tz = warsaw n = 60 - dti = date_range(start="2015-03-29 02:00:00", periods=n, freq="min") + dti = date_range(start="2015-03-29 02:00:00", periods=n, freq="min", unit=unit) ser = Series(1, index=dti) df = ser.to_frame() @@ -101,7 +101,7 @@ def test_tz_localize_nonexistent(self, warsaw, method, exp): else: result = ser.tz_localize(tz, nonexistent=method) - expected = Series(1, index=DatetimeIndex([exp] * n, tz=tz)) + expected = Series(1, index=DatetimeIndex([exp] * n, tz=tz).as_unit(unit)) tm.assert_series_equal(result, expected) result = df.tz_localize(tz, nonexistent=method) diff --git a/pandas/tests/series/methods/test_value_counts.py b/pandas/tests/series/methods/test_value_counts.py index bde9902fec6e9..859010d9c79c6 100644 --- a/pandas/tests/series/methods/test_value_counts.py +++ b/pandas/tests/series/methods/test_value_counts.py @@ -12,7 +12,7 @@ class TestSeriesValueCounts: - def test_value_counts_datetime(self): + def test_value_counts_datetime(self, unit): # most dtypes are tested in tests/base values = [ pd.Timestamp("2011-01-01 09:00"), @@ -26,13 +26,13 @@ def test_value_counts_datetime(self): exp_idx = pd.DatetimeIndex( ["2011-01-01 09:00", "2011-01-01 11:00", "2011-01-01 10:00"], name="xxx", - ) + ).as_unit(unit) exp = Series([3, 2, 1], index=exp_idx, name="count") - ser = Series(values, name="xxx") + ser = Series(values, name="xxx").dt.as_unit(unit) tm.assert_series_equal(ser.value_counts(), exp) # check DatetimeIndex outputs the same result - idx = pd.DatetimeIndex(values, name="xxx") + idx = pd.DatetimeIndex(values, name="xxx").as_unit(unit) tm.assert_series_equal(idx.value_counts(), exp) # normalize @@ -40,7 +40,7 @@ def test_value_counts_datetime(self): tm.assert_series_equal(ser.value_counts(normalize=True), exp) tm.assert_series_equal(idx.value_counts(normalize=True), exp) - def test_value_counts_datetime_tz(self): + def test_value_counts_datetime_tz(self, unit): values = [ pd.Timestamp("2011-01-01 09:00", tz="US/Eastern"), pd.Timestamp("2011-01-01 10:00", tz="US/Eastern"), @@ -54,12 +54,12 @@ def test_value_counts_datetime_tz(self): ["2011-01-01 09:00", "2011-01-01 11:00", "2011-01-01 10:00"], tz="US/Eastern", name="xxx", - ) + ).as_unit(unit) exp = Series([3, 2, 1], index=exp_idx, name="count") - ser = Series(values, name="xxx") + ser = Series(values, name="xxx").dt.as_unit(unit) tm.assert_series_equal(ser.value_counts(), exp) - idx = pd.DatetimeIndex(values, name="xxx") + idx = pd.DatetimeIndex(values, name="xxx").as_unit(unit) tm.assert_series_equal(idx.value_counts(), exp) exp = Series(np.array([3.0, 2.0, 1]) / 6.0, index=exp_idx, name="proportion") diff --git a/pandas/tests/series/test_arithmetic.py b/pandas/tests/series/test_arithmetic.py index 656f6736f03ee..b835be6d8e501 100644 --- a/pandas/tests/series/test_arithmetic.py +++ b/pandas/tests/series/test_arithmetic.py @@ -749,13 +749,17 @@ def test_series_add_aware_naive_raises(self): with pytest.raises(Exception, match=msg): ser_utc + ser - def test_datetime_understood(self): + # TODO: belongs in tests/arithmetic? + def test_datetime_understood(self, unit): # Ensures it doesn't fail to create the right series # reported in issue#16726 - series = Series(date_range("2012-01-01", periods=3)) + series = Series(date_range("2012-01-01", periods=3, unit=unit)) offset = pd.offsets.DateOffset(days=6) result = series - offset - expected = Series(pd.to_datetime(["2011-12-26", "2011-12-27", "2011-12-28"])) + exp_dti = pd.to_datetime(["2011-12-26", "2011-12-27", "2011-12-28"]).as_unit( + unit + ) + expected = Series(exp_dti) tm.assert_series_equal(result, expected) def test_align_date_objects_with_datetimeindex(self): diff --git a/pandas/tests/test_algos.py b/pandas/tests/test_algos.py index e1a78136935db..97119127b1665 100644 --- a/pandas/tests/test_algos.py +++ b/pandas/tests/test_algos.py @@ -757,23 +757,6 @@ def test_order_of_appearance(self): result = pd.unique(Series([2] + [1] * 5)) tm.assert_numpy_array_equal(result, np.array([2, 1], dtype="int64")) - result = pd.unique(Series([Timestamp("20160101"), Timestamp("20160101")])) - expected = np.array(["2016-01-01T00:00:00.000000000"], dtype="datetime64[ns]") - tm.assert_numpy_array_equal(result, expected) - - result = pd.unique( - Index( - [ - Timestamp("20160101", tz="US/Eastern"), - Timestamp("20160101", tz="US/Eastern"), - ] - ) - ) - expected = DatetimeIndex( - ["2016-01-01 00:00:00"], dtype="datetime64[ns, US/Eastern]", freq=None - ) - tm.assert_index_equal(result, expected) - msg = "unique with argument that is not not a Series, Index," with tm.assert_produces_warning(FutureWarning, match=msg): result = pd.unique(list("aabc")) @@ -784,6 +767,25 @@ def test_order_of_appearance(self): expected = Categorical(list("abc")) tm.assert_categorical_equal(result, expected) + def test_order_of_appearance_dt64(self, unit): + ser = Series([Timestamp("20160101"), Timestamp("20160101")]).dt.as_unit(unit) + result = pd.unique(ser) + expected = np.array(["2016-01-01T00:00:00.000000000"], dtype=f"M8[{unit}]") + tm.assert_numpy_array_equal(result, expected) + + def test_order_of_appearance_dt64tz(self, unit): + dti = DatetimeIndex( + [ + Timestamp("20160101", tz="US/Eastern"), + Timestamp("20160101", tz="US/Eastern"), + ] + ).as_unit(unit) + result = pd.unique(dti) + expected = DatetimeIndex( + ["2016-01-01 00:00:00"], dtype=f"datetime64[{unit}, US/Eastern]", freq=None + ) + tm.assert_index_equal(result, expected) + @pytest.mark.parametrize( "arg ,expected", [ diff --git a/pandas/tests/tseries/holiday/test_calendar.py b/pandas/tests/tseries/holiday/test_calendar.py index 57acf15443ca8..99829857e6836 100644 --- a/pandas/tests/tseries/holiday/test_calendar.py +++ b/pandas/tests/tseries/holiday/test_calendar.py @@ -57,8 +57,11 @@ def __init__(self, name=None, rules=None) -> None: jan2 = TestCalendar(rules=[Holiday("jan2", year=2015, month=1, day=2)]) # Getting holidays for Jan 1 should not alter results for Jan 2. - tm.assert_index_equal(jan1.holidays(), DatetimeIndex(["01-Jan-2015"])) - tm.assert_index_equal(jan2.holidays(), DatetimeIndex(["02-Jan-2015"])) + expected = DatetimeIndex(["01-Jan-2015"]).as_unit("ns") + tm.assert_index_equal(jan1.holidays(), expected) + + expected2 = DatetimeIndex(["02-Jan-2015"]).as_unit("ns") + tm.assert_index_equal(jan2.holidays(), expected2) def test_calendar_observance_dates(): diff --git a/pandas/tests/tseries/holiday/test_holiday.py b/pandas/tests/tseries/holiday/test_holiday.py index e751339ca2cd0..b2eefd04ef93b 100644 --- a/pandas/tests/tseries/holiday/test_holiday.py +++ b/pandas/tests/tseries/holiday/test_holiday.py @@ -327,5 +327,6 @@ def test_holidays_with_timezone_specified_but_no_occurences(): start_date, end_date, return_name=True ) expected_results = Series("New Year's Day", index=[start_date]) + expected_results.index = expected_results.index.as_unit("ns") tm.assert_equal(test_case, expected_results) diff --git a/pandas/tests/tseries/offsets/test_business_hour.py b/pandas/tests/tseries/offsets/test_business_hour.py index 28e660f677e28..227cf6a495c91 100644 --- a/pandas/tests/tseries/offsets/test_business_hour.py +++ b/pandas/tests/tseries/offsets/test_business_hour.py @@ -978,12 +978,6 @@ def test_datetimeindex(self): for idx in [idx1, idx2, idx3]: tm.assert_index_equal(idx, expected) - def test_short_datetimeindex_creation(self): - # gh-49835 - idx4 = date_range(start="2014-07-01 10:00", freq="bh", periods=1) - expected4 = DatetimeIndex(["2014-07-01 10:00"], freq="bh") - tm.assert_index_equal(idx4, expected4) - @pytest.mark.parametrize("td_unit", ["s", "ms", "us", "ns"]) @pytest.mark.parametrize("unit", ["s", "ms", "us", "ns"]) def test_bday_ignores_timedeltas(self, unit, td_unit): diff --git a/pandas/tests/window/test_rolling.py b/pandas/tests/window/test_rolling.py index b4f6fde6850a2..f353a7fa2f0fe 100644 --- a/pandas/tests/window/test_rolling.py +++ b/pandas/tests/window/test_rolling.py @@ -977,20 +977,23 @@ def scaled_sum(*args): @pytest.mark.parametrize("add", [0.0, 2.0]) -def test_rolling_numerical_accuracy_kahan_mean(add): +def test_rolling_numerical_accuracy_kahan_mean(add, unit): # GH: 36031 implementing kahan summation - df = DataFrame( - {"A": [3002399751580331.0 + add, -0.0, -0.0]}, - index=[ + dti = DatetimeIndex( + [ Timestamp("19700101 09:00:00"), Timestamp("19700101 09:00:03"), Timestamp("19700101 09:00:06"), - ], + ] + ).as_unit(unit) + df = DataFrame( + {"A": [3002399751580331.0 + add, -0.0, -0.0]}, + index=dti, ) result = ( df.resample("1s").ffill().rolling("3s", closed="left", min_periods=3).mean() ) - dates = date_range("19700101 09:00:00", periods=7, freq="s") + dates = date_range("19700101 09:00:00", periods=7, freq="s", unit=unit) expected = DataFrame( { "A": [ @@ -1196,8 +1199,19 @@ def test_rolling_var_numerical_issues(func, third_value, values): tm.assert_series_equal(result == 0, expected == 0) -def test_timeoffset_as_window_parameter_for_corr(): +def test_timeoffset_as_window_parameter_for_corr(unit): # GH: 28266 + dti = DatetimeIndex( + [ + Timestamp("20130101 09:00:00"), + Timestamp("20130102 09:00:02"), + Timestamp("20130103 09:00:03"), + Timestamp("20130105 09:00:05"), + Timestamp("20130106 09:00:06"), + ] + ).as_unit(unit) + mi = MultiIndex.from_product([dti, ["B", "A"]]) + exp = DataFrame( { "B": [ @@ -1225,31 +1239,12 @@ def test_timeoffset_as_window_parameter_for_corr(): 1.0000000000000002, ], }, - index=MultiIndex.from_tuples( - [ - (Timestamp("20130101 09:00:00"), "B"), - (Timestamp("20130101 09:00:00"), "A"), - (Timestamp("20130102 09:00:02"), "B"), - (Timestamp("20130102 09:00:02"), "A"), - (Timestamp("20130103 09:00:03"), "B"), - (Timestamp("20130103 09:00:03"), "A"), - (Timestamp("20130105 09:00:05"), "B"), - (Timestamp("20130105 09:00:05"), "A"), - (Timestamp("20130106 09:00:06"), "B"), - (Timestamp("20130106 09:00:06"), "A"), - ] - ), + index=mi, ) df = DataFrame( {"B": [0, 1, 2, 4, 3], "A": [7, 4, 6, 9, 3]}, - index=[ - Timestamp("20130101 09:00:00"), - Timestamp("20130102 09:00:02"), - Timestamp("20130103 09:00:03"), - Timestamp("20130105 09:00:05"), - Timestamp("20130106 09:00:06"), - ], + index=dti, ) res = df.rolling(window="3d").corr() diff --git a/pandas/tests/window/test_timeseries_window.py b/pandas/tests/window/test_timeseries_window.py index 482c8992feb13..c99fc8a8eb60f 100644 --- a/pandas/tests/window/test_timeseries_window.py +++ b/pandas/tests/window/test_timeseries_window.py @@ -3,7 +3,7 @@ from pandas import ( DataFrame, - Index, + DatetimeIndex, MultiIndex, NaT, Series, @@ -178,21 +178,22 @@ def test_frame_on(self): result = df.rolling("2s", on="A")[["B"]].sum() tm.assert_frame_equal(result, expected) - def test_frame_on2(self): + def test_frame_on2(self, unit): # using multiple aggregation columns + dti = DatetimeIndex( + [ + Timestamp("20130101 09:00:00"), + Timestamp("20130101 09:00:02"), + Timestamp("20130101 09:00:03"), + Timestamp("20130101 09:00:05"), + Timestamp("20130101 09:00:06"), + ] + ).as_unit(unit) df = DataFrame( { "A": [0, 1, 2, 3, 4], "B": [0, 1, 2, np.nan, 4], - "C": Index( - [ - Timestamp("20130101 09:00:00"), - Timestamp("20130101 09:00:02"), - Timestamp("20130101 09:00:03"), - Timestamp("20130101 09:00:05"), - Timestamp("20130101 09:00:06"), - ] - ), + "C": dti, }, columns=["A", "C", "B"], ) @@ -248,18 +249,22 @@ def test_min_periods(self, regular): result = df.rolling("2s", min_periods=1).sum() tm.assert_frame_equal(result, expected) - def test_closed(self, regular): + def test_closed(self, regular, unit): # xref GH13965 - df = DataFrame( - {"A": [1] * 5}, - index=[ + dti = DatetimeIndex( + [ Timestamp("20130101 09:00:01"), Timestamp("20130101 09:00:02"), Timestamp("20130101 09:00:03"), Timestamp("20130101 09:00:04"), Timestamp("20130101 09:00:06"), - ], + ] + ).as_unit(unit) + + df = DataFrame( + {"A": [1] * 5}, + index=dti, ) # closed must be 'right', 'left', 'both', 'neither' @@ -642,15 +647,17 @@ def test_rolling_cov_offset(self): expected2 = ss.rolling(3, min_periods=1).cov() tm.assert_series_equal(result, expected2) - def test_rolling_on_decreasing_index(self): + def test_rolling_on_decreasing_index(self, unit): # GH-19248, GH-32385 - index = [ - Timestamp("20190101 09:00:30"), - Timestamp("20190101 09:00:27"), - Timestamp("20190101 09:00:20"), - Timestamp("20190101 09:00:18"), - Timestamp("20190101 09:00:10"), - ] + index = DatetimeIndex( + [ + Timestamp("20190101 09:00:30"), + Timestamp("20190101 09:00:27"), + Timestamp("20190101 09:00:20"), + Timestamp("20190101 09:00:18"), + Timestamp("20190101 09:00:10"), + ] + ).as_unit(unit) df = DataFrame({"column": [3, 4, 4, 5, 6]}, index=index) result = df.rolling("5s").min()