diff --git a/doc/source/whatsnew/v0.21.0.rst b/doc/source/whatsnew/v0.21.0.rst index 43719cd53b0ff..59c92b14b6525 100644 --- a/doc/source/whatsnew/v0.21.0.rst +++ b/doc/source/whatsnew/v0.21.0.rst @@ -635,22 +635,17 @@ Previous behavior: New behavior: -.. code-block:: ipython +.. ipython:: python - In [1]: pi = pd.period_range('2017-01', periods=12, freq='M') + pi = pd.period_range('2017-01', periods=12, freq='M') - In [2]: s = pd.Series(np.arange(12), index=pi) + s = pd.Series(np.arange(12), index=pi) - In [3]: resampled = s.resample('2Q').mean() + resampled = s.resample('2Q').mean() - In [4]: resampled - Out[4]: - 2017Q1 2.5 - 2017Q3 8.5 - Freq: 2Q-DEC, dtype: float64 + resampled - In [5]: resampled.index - Out[5]: PeriodIndex(['2017Q1', '2017Q3'], dtype='period[2Q-DEC]') + resampled.index Upsampling and calling ``.ohlc()`` previously returned a ``Series``, basically identical to calling ``.asfreq()``. OHLC upsampling now returns a DataFrame with columns ``open``, ``high``, ``low`` and ``close`` (:issue:`13083`). This is consistent with downsampling and ``DatetimeIndex`` behavior. diff --git a/doc/source/whatsnew/v2.2.0.rst b/doc/source/whatsnew/v2.2.0.rst index e32417e367427..9bb87e8f2df90 100644 --- a/doc/source/whatsnew/v2.2.0.rst +++ b/doc/source/whatsnew/v2.2.0.rst @@ -664,7 +664,7 @@ Other Deprecations - Deprecated :meth:`DatetimeArray.__init__` and :meth:`TimedeltaArray.__init__`, use :func:`array` instead (:issue:`55623`) - Deprecated :meth:`Index.format`, use ``index.astype(str)`` or ``index.map(formatter)`` instead (:issue:`55413`) - Deprecated :meth:`Series.ravel`, the underlying array is already 1D, so ravel is not necessary (:issue:`52511`) -- Deprecated :meth:`Series.resample` and :meth:`DataFrame.resample` with a :class:`PeriodIndex` (and the 'convention' keyword), convert to :class:`DatetimeIndex` (with ``.to_timestamp()``) before resampling instead (:issue:`53481`) +- Deprecated :meth:`Series.resample` and :meth:`DataFrame.resample` with a :class:`PeriodIndex` (and the 'convention' keyword), convert to :class:`DatetimeIndex` (with ``.to_timestamp()``) before resampling instead (:issue:`53481`). Note: this deprecation was later undone in pandas 2.3.3 (:issue:`57033`) - Deprecated :meth:`Series.view`, use :meth:`Series.astype` instead to change the dtype (:issue:`20251`) - Deprecated :meth:`offsets.Tick.is_anchored`, use ``False`` instead (:issue:`55388`) - Deprecated ``core.internals`` members ``Block``, ``ExtensionBlock``, and ``DatetimeTZBlock``, use public APIs instead (:issue:`55139`) diff --git a/doc/source/whatsnew/v2.3.3.rst b/doc/source/whatsnew/v2.3.3.rst index eeba61a686c73..0accd07eb366a 100644 --- a/doc/source/whatsnew/v2.3.3.rst +++ b/doc/source/whatsnew/v2.3.3.rst @@ -57,6 +57,14 @@ Bug fixes - The :meth:`DataFrame.iloc` now works correctly with ``copy_on_write`` option when assigning values after subsetting the columns of a homogeneous DataFrame (:issue:`60309`) +Other changes +~~~~~~~~~~~~~ + +- The deprecation of using :meth:`Series.resample` and :meth:`DataFrame.resample` + with a :class:`PeriodIndex` (and the 'convention' keyword) has been undone. + Resampling with a :class:`PeriodIndex` is supported again, but a subset of + methods that return incorrect results will raise an error in pandas 3.0 (:issue:`57033`) + .. --------------------------------------------------------------------------- .. _whatsnew_233.contributors: diff --git a/pandas/core/generic.py b/pandas/core/generic.py index 65d9829a4cce9..169f4726146be 100644 --- a/pandas/core/generic.py +++ b/pandas/core/generic.py @@ -8811,7 +8811,7 @@ def resample( rule, closed: Literal["right", "left"] | None = None, label: Literal["right", "left"] | None = None, - convention: Literal["start", "end", "s", "e"] | lib.NoDefault = lib.no_default, + convention: Literal["start", "end", "s", "e"] = "start", on: Level | None = None, level: Level | None = None, origin: str | TimestampConvertibleTypes = "start_day", @@ -8841,9 +8841,6 @@ def resample( convention : {{'start', 'end', 's', 'e'}}, default 'start' For `PeriodIndex` only, controls whether to use the start or end of `rule`. - - .. deprecated:: 2.2.0 - Convert PeriodIndex to DatetimeIndex before resampling instead. on : str, optional For a DataFrame, column to use instead of index for resampling. Column must be datetime-like. @@ -8999,6 +8996,55 @@ def resample( 2000-01-01 00:06:00 26 Freq: 3min, dtype: int64 + For a Series with a PeriodIndex, the keyword `convention` can be + used to control whether to use the start or end of `rule`. + + Resample a year by quarter using 'start' `convention`. Values are + assigned to the first quarter of the period. + + >>> s = pd.Series( + ... [1, 2], index=pd.period_range("2012-01-01", freq="Y", periods=2) + ... ) + >>> s + 2012 1 + 2013 2 + Freq: Y-DEC, dtype: int64 + >>> s.resample("Q", convention="start").asfreq() + 2012Q1 1.0 + 2012Q2 NaN + 2012Q3 NaN + 2012Q4 NaN + 2013Q1 2.0 + 2013Q2 NaN + 2013Q3 NaN + 2013Q4 NaN + Freq: Q-DEC, dtype: float64 + + Resample quarters by month using 'end' `convention`. Values are + assigned to the last month of the period. + + >>> q = pd.Series( + ... [1, 2, 3, 4], index=pd.period_range("2018-01-01", freq="Q", periods=4) + ... ) + >>> q + 2018Q1 1 + 2018Q2 2 + 2018Q3 3 + 2018Q4 4 + Freq: Q-DEC, dtype: int64 + >>> q.resample("M", convention="end").asfreq() + 2018-03 1.0 + 2018-04 NaN + 2018-05 NaN + 2018-06 2.0 + 2018-07 NaN + 2018-08 NaN + 2018-09 3.0 + 2018-10 NaN + 2018-11 NaN + 2018-12 4.0 + Freq: M, dtype: float64 + For DataFrame objects, the keyword `on` can be used to specify the column instead of the index for resampling. @@ -9135,19 +9181,6 @@ def resample( """ from pandas.core.resample import get_resampler - if convention is not lib.no_default: - # TODO: Enforce in 3.0 (#55968) - warnings.warn( - f"The 'convention' keyword in {type(self).__name__}.resample is " - "deprecated and will be removed in a future version. " - "Explicitly cast PeriodIndex to DatetimeIndex before resampling " - "instead.", - FutureWarning, # pdlint: ignore[warning_class] - stacklevel=find_stack_level(), - ) - else: - convention = "start" - return get_resampler( cast("Series | DataFrame", self), freq=rule, diff --git a/pandas/core/resample.py b/pandas/core/resample.py index a7004bfaf0d86..e8803b6f30fce 100644 --- a/pandas/core/resample.py +++ b/pandas/core/resample.py @@ -1932,13 +1932,6 @@ class PeriodIndexResampler(DatetimeIndexResampler): @property def _resampler_for_grouping(self): - # TODO: Enforce in 3.0 (#55968) - warnings.warn( - "Resampling a groupby with a PeriodIndex is deprecated. " - "Cast to DatetimeIndex before resampling instead.", - FutureWarning, # pdlint: ignore[warning_class] - stacklevel=find_stack_level(), - ) return PeriodIndexResamplerGroupby def _get_binner_for_time(self): @@ -2265,15 +2258,6 @@ def _get_resampler(self, obj: NDFrame) -> Resampler: gpr_index=ax, ) elif isinstance(ax, PeriodIndex): - if isinstance(ax, PeriodIndex): - # TODO: Enforce in 3.0 (#53481) - # GH#53481 - warnings.warn( - "Resampling with a PeriodIndex is deprecated. " - "Cast index to DatetimeIndex before resampling instead.", - FutureWarning, # pdlint: ignore[warning_class] - stacklevel=find_stack_level(), - ) return PeriodIndexResampler( obj, timegrouper=self, diff --git a/pandas/plotting/_matplotlib/timeseries.py b/pandas/plotting/_matplotlib/timeseries.py index 98ac394f4e51e..1e355c5535503 100644 --- a/pandas/plotting/_matplotlib/timeseries.py +++ b/pandas/plotting/_matplotlib/timeseries.py @@ -82,12 +82,9 @@ def maybe_resample(series: Series, ax: Axes, kwargs: dict[str, Any]): ) freq = ax_freq elif _is_sup(freq, ax_freq): # one is weekly - # Resampling with PeriodDtype is deprecated, so we convert to - # DatetimeIndex, resample, then convert back. - ser_ts = series.to_timestamp() - ser_d = ser_ts.resample("D").last().dropna() - ser_freq = ser_d.resample(ax_freq).last().dropna() - series = ser_freq.to_period(ax_freq) + how = "last" + series = getattr(series.resample("D"), how)().dropna() + series = getattr(series.resample(ax_freq), how)().dropna() freq = ax_freq elif is_subperiod(freq, ax_freq) or _is_sub(freq, ax_freq): _upsample_others(ax, freq, kwargs) diff --git a/pandas/tests/resample/test_base.py b/pandas/tests/resample/test_base.py index d9bd89af61aaf..12128be7c2d30 100644 --- a/pandas/tests/resample/test_base.py +++ b/pandas/tests/resample/test_base.py @@ -104,13 +104,8 @@ def test_asfreq_fill_value(index): def test_resample_interpolate(index): # GH#12925 df = DataFrame(range(len(index)), index=index) - warn = None - if isinstance(df.index, PeriodIndex): - warn = FutureWarning - msg = "Resampling with a PeriodIndex is deprecated" - with tm.assert_produces_warning(warn, match=msg): - result = df.resample("1min").asfreq().interpolate() - expected = df.resample("1min").interpolate() + result = df.resample("1min").asfreq().interpolate() + expected = df.resample("1min").interpolate() tm.assert_frame_equal(result, expected) @@ -199,13 +194,7 @@ def test_resample_empty_series(freq, index, resample_method): elif freq == "ME" and isinstance(ser.index, PeriodIndex): # index is PeriodIndex, so convert to corresponding Period freq freq = "M" - - warn = None - if isinstance(ser.index, PeriodIndex): - warn = FutureWarning - msg = "Resampling with a PeriodIndex is deprecated" - with tm.assert_produces_warning(warn, match=msg): - rs = ser.resample(freq) + rs = ser.resample(freq) result = getattr(rs, resample_method)() if resample_method == "ohlc": @@ -261,9 +250,7 @@ def test_resample_nat_index_series(freq, resample_method): ser = Series(range(5), index=PeriodIndex([NaT] * 5, freq=freq)) - msg = "Resampling with a PeriodIndex is deprecated" - with tm.assert_produces_warning(FutureWarning, match=msg): - rs = ser.resample(freq) + rs = ser.resample(freq) result = getattr(rs, resample_method)() if resample_method == "ohlc": @@ -302,13 +289,7 @@ def test_resample_count_empty_series(freq, index, resample_method): elif freq == "ME" and isinstance(ser.index, PeriodIndex): # index is PeriodIndex, so convert to corresponding Period freq freq = "M" - - warn = None - if isinstance(ser.index, PeriodIndex): - warn = FutureWarning - msg = "Resampling with a PeriodIndex is deprecated" - with tm.assert_produces_warning(warn, match=msg): - rs = ser.resample(freq) + rs = ser.resample(freq) result = getattr(rs, resample_method)() @@ -338,13 +319,7 @@ def test_resample_empty_dataframe(index, freq, resample_method): elif freq == "ME" and isinstance(df.index, PeriodIndex): # index is PeriodIndex, so convert to corresponding Period freq freq = "M" - - warn = None - if isinstance(df.index, PeriodIndex): - warn = FutureWarning - msg = "Resampling with a PeriodIndex is deprecated" - with tm.assert_produces_warning(warn, match=msg): - rs = df.resample(freq, group_keys=False) + rs = df.resample(freq, group_keys=False) result = getattr(rs, resample_method)() if resample_method == "ohlc": # TODO: no tests with len(df.columns) > 0 @@ -386,14 +361,7 @@ def test_resample_count_empty_dataframe(freq, index): elif freq == "ME" and isinstance(empty_frame_dti.index, PeriodIndex): # index is PeriodIndex, so convert to corresponding Period freq freq = "M" - - warn = None - if isinstance(empty_frame_dti.index, PeriodIndex): - warn = FutureWarning - msg = "Resampling with a PeriodIndex is deprecated" - with tm.assert_produces_warning(warn, match=msg): - rs = empty_frame_dti.resample(freq) - result = rs.count() + result = empty_frame_dti.resample(freq).count() index = _asfreq_compat(empty_frame_dti.index, freq) @@ -422,14 +390,7 @@ def test_resample_size_empty_dataframe(freq, index): elif freq == "ME" and isinstance(empty_frame_dti.index, PeriodIndex): # index is PeriodIndex, so convert to corresponding Period freq freq = "M" - - msg = "Resampling with a PeriodIndex" - warn = None - if isinstance(empty_frame_dti.index, PeriodIndex): - warn = FutureWarning - with tm.assert_produces_warning(warn, match=msg): - rs = empty_frame_dti.resample(freq) - result = rs.size() + result = empty_frame_dti.resample(freq).size() index = _asfreq_compat(empty_frame_dti.index, freq) @@ -465,21 +426,12 @@ def test_resample_apply_empty_dataframe(index, freq, method): ], ) @pytest.mark.parametrize("dtype", [float, int, object, "datetime64[ns]"]) -@pytest.mark.filterwarnings(r"ignore:PeriodDtype\[B\] is deprecated:FutureWarning") def test_resample_empty_dtypes(index, dtype, resample_method): # Empty series were sometimes causing a segfault (for the functions # with Cython bounds-checking disabled) or an IndexError. We just run # them to ensure they no longer do. (GH #10228) - warn = None - if isinstance(index, PeriodIndex): - # GH#53511 - index = PeriodIndex([], freq="B", name=index.name) - warn = FutureWarning - msg = "Resampling with a PeriodIndex is deprecated" - empty_series_dti = Series([], index, dtype) - with tm.assert_produces_warning(warn, match=msg): - rs = empty_series_dti.resample("D", group_keys=False) + rs = empty_series_dti.resample("D", group_keys=False) try: getattr(rs, resample_method)() except DataError: @@ -512,18 +464,8 @@ def test_apply_to_empty_series(index, freq): elif freq == "ME" and isinstance(ser.index, PeriodIndex): # index is PeriodIndex, so convert to corresponding Period freq freq = "M" - - msg = "Resampling with a PeriodIndex" - warn = None - if isinstance(ser.index, PeriodIndex): - warn = FutureWarning - - with tm.assert_produces_warning(warn, match=msg): - rs = ser.resample(freq, group_keys=False) - - result = rs.apply(lambda x: 1) - with tm.assert_produces_warning(warn, match=msg): - expected = ser.resample(freq).apply("sum") + result = ser.resample(freq, group_keys=False).apply(lambda x: 1) + expected = ser.resample(freq).apply("sum") tm.assert_series_equal(result, expected, check_dtype=False) @@ -541,16 +483,8 @@ def test_resampler_is_iterable(index): series = Series(range(len(index)), index=index) freq = "h" tg = Grouper(freq=freq, convention="start") - msg = "Resampling with a PeriodIndex" - warn = None - if isinstance(series.index, PeriodIndex): - warn = FutureWarning - - with tm.assert_produces_warning(warn, match=msg): - grouped = series.groupby(tg) - - with tm.assert_produces_warning(warn, match=msg): - resampled = series.resample(freq) + grouped = series.groupby(tg) + resampled = series.resample(freq) for (rk, rv), (gk, gv) in zip(resampled, grouped): assert rk == gk tm.assert_series_equal(rv, gv) @@ -570,13 +504,8 @@ def test_resample_quantile(index): q = 0.75 freq = "h" - msg = "Resampling with a PeriodIndex" - warn = None - if isinstance(ser.index, PeriodIndex): - warn = FutureWarning - with tm.assert_produces_warning(warn, match=msg): - result = ser.resample(freq).quantile(q) - expected = ser.resample(freq).agg(lambda x: x.quantile(q)).rename(ser.name) + result = ser.resample(freq).quantile(q) + expected = ser.resample(freq).agg(lambda x: x.quantile(q)).rename(ser.name) tm.assert_series_equal(result, expected) diff --git a/pandas/tests/resample/test_datetime_index.py b/pandas/tests/resample/test_datetime_index.py index 7b02b62bfd10c..ab88d221864c0 100644 --- a/pandas/tests/resample/test_datetime_index.py +++ b/pandas/tests/resample/test_datetime_index.py @@ -169,9 +169,6 @@ def test_resample_basic_grouper(unit): tm.assert_series_equal(result, expected) -@pytest.mark.filterwarnings( - "ignore:The 'convention' keyword in Series.resample:FutureWarning" -) @pytest.mark.parametrize( "keyword,value", [("label", "righttt"), ("closed", "righttt"), ("convention", "starttt")], @@ -1014,10 +1011,7 @@ def test_period_with_agg(): ) expected = s2.to_timestamp().resample("D").mean().to_period() - msg = "Resampling with a PeriodIndex is deprecated" - with tm.assert_produces_warning(FutureWarning, match=msg): - rs = s2.resample("D") - result = rs.agg(lambda x: x.mean()) + result = s2.resample("D").agg(lambda x: x.mean()) tm.assert_series_equal(result, expected) diff --git a/pandas/tests/resample/test_period_index.py b/pandas/tests/resample/test_period_index.py index 2669e48e6a55d..fa8eef8835285 100644 --- a/pandas/tests/resample/test_period_index.py +++ b/pandas/tests/resample/test_period_index.py @@ -34,10 +34,6 @@ from pandas.tseries import offsets -pytestmark = pytest.mark.filterwarnings( - "ignore:Resampling with a PeriodIndex is deprecated:FutureWarning" -) - @pytest.fixture def simple_period_range_series(): @@ -137,9 +133,6 @@ def test_annual_upsample_cases( ts = simple_period_range_series("1/1/1990", "12/31/1991", freq=f"Y-{month}") warn = FutureWarning if period == "B" else None msg = r"PeriodDtype\[B\] is deprecated" - if warn is None: - msg = "Resampling with a PeriodIndex is deprecated" - warn = FutureWarning with tm.assert_produces_warning(warn, match=msg): result = getattr(ts.resample(period, convention=conv), meth)() expected = result.to_timestamp(period, how=conv) @@ -182,9 +175,7 @@ def test_basic_upsample(self, freq, simple_period_range_series): ts = simple_period_range_series("1/1/1990", "6/30/1995", freq="M") result = ts.resample("Y-DEC").mean() - msg = "The 'convention' keyword in Series.resample is deprecated" - with tm.assert_produces_warning(FutureWarning, match=msg): - resampled = result.resample(freq, convention="end").ffill() + resampled = result.resample(freq, convention="end").ffill() expected = result.to_timestamp(freq, how="end") expected = expected.asfreq(freq, "ffill").to_period(freq) tm.assert_series_equal(resampled, expected) @@ -193,9 +184,7 @@ def test_upsample_with_limit(self): rng = period_range("1/1/2000", periods=5, freq="Y") ts = Series(np.random.default_rng(2).standard_normal(len(rng)), rng) - msg = "The 'convention' keyword in Series.resample is deprecated" - with tm.assert_produces_warning(FutureWarning, match=msg): - result = ts.resample("M", convention="end").ffill(limit=2) + result = ts.resample("M", convention="end").ffill(limit=2) expected = ts.asfreq("M").reindex(result.index, method="ffill", limit=2) tm.assert_series_equal(result, expected) @@ -228,9 +217,6 @@ def test_quarterly_upsample( ts = simple_period_range_series("1/1/1990", "12/31/1995", freq=freq) warn = FutureWarning if period == "B" else None msg = r"PeriodDtype\[B\] is deprecated" - if warn is None: - msg = "Resampling with a PeriodIndex is deprecated" - warn = FutureWarning with tm.assert_produces_warning(warn, match=msg): result = ts.resample(period, convention=convention).ffill() expected = result.to_timestamp(period, how=convention) @@ -244,9 +230,6 @@ def test_monthly_upsample(self, target, convention, simple_period_range_series): warn = None if target == "D" else FutureWarning msg = r"PeriodDtype\[B\] is deprecated" - if warn is None: - msg = "Resampling with a PeriodIndex is deprecated" - warn = FutureWarning with tm.assert_produces_warning(warn, match=msg): result = ts.resample(target, convention=convention).ffill() expected = result.to_timestamp(target, how=convention) @@ -417,9 +400,6 @@ def test_weekly_upsample(self, day, target, convention, simple_period_range_seri warn = None if target == "D" else FutureWarning msg = r"PeriodDtype\[B\] is deprecated" - if warn is None: - msg = "Resampling with a PeriodIndex is deprecated" - warn = FutureWarning with tm.assert_produces_warning(warn, match=msg): result = ts.resample(target, convention=convention).ffill() expected = result.to_timestamp(target, how=convention) @@ -454,9 +434,7 @@ def test_resample_to_quarterly(self, simple_period_range_series, month): def test_resample_to_quarterly_start_end(self, simple_period_range_series, how): # conforms, but different month ts = simple_period_range_series("1990", "1992", freq="Y-JUN") - msg = "The 'convention' keyword in Series.resample is deprecated" - with tm.assert_produces_warning(FutureWarning, match=msg): - result = ts.resample("Q-MAR", convention=how).ffill() + result = ts.resample("Q-MAR", convention=how).ffill() expected = ts.asfreq("Q-MAR", how=how) expected = expected.reindex(result.index, method="ffill") @@ -504,9 +482,7 @@ def test_upsample_daily_business_daily(self, simple_period_range_series): tm.assert_series_equal(result, expected) ts = simple_period_range_series("1/1/2000", "2/1/2000") - msg = "The 'convention' keyword in Series.resample is deprecated" - with tm.assert_produces_warning(FutureWarning, match=msg): - result = ts.resample("h", convention="s").asfreq() + result = ts.resample("h", convention="s").asfreq() exp_rng = period_range("1/1/2000", "2/1/2000 23:00", freq="h") expected = ts.asfreq("h", how="s").reindex(exp_rng) tm.assert_series_equal(result, expected) @@ -867,10 +843,7 @@ def test_resample_with_nat(self, periods, values, freq, expected_values): "1970-01-01 00:00:00", periods=len(expected_values), freq=freq ) expected = DataFrame(expected_values, index=expected_index) - msg = "Resampling with a PeriodIndex is deprecated" - with tm.assert_produces_warning(FutureWarning, match=msg): - rs = frame.resample(freq) - result = rs.mean() + result = frame.resample(freq).mean() tm.assert_frame_equal(result, expected) def test_resample_with_only_nat(self): @@ -906,10 +879,7 @@ def test_resample_with_offset(self, start, end, start_freq, end_freq, offset): # GH 23882 & 31809 pi = period_range(start, end, freq=start_freq) ser = Series(np.arange(len(pi)), index=pi) - msg = "Resampling with a PeriodIndex is deprecated" - with tm.assert_produces_warning(FutureWarning, match=msg): - rs = ser.resample(end_freq, offset=offset) - result = rs.mean() + result = ser.resample(end_freq, offset=offset).mean() result = result.to_timestamp(end_freq) expected = ser.to_timestamp().resample(end_freq, offset=offset).mean() @@ -919,10 +889,7 @@ def test_resample_with_offset_month(self): # GH 23882 & 31809 pi = period_range("19910905 12:00", "19910909 1:00", freq="h") ser = Series(np.arange(len(pi)), index=pi) - msg = "Resampling with a PeriodIndex is deprecated" - with tm.assert_produces_warning(FutureWarning, match=msg): - rs = ser.resample("M") - result = rs.mean() + result = ser.resample("M").mean() result = result.to_timestamp("M") expected = ser.to_timestamp().resample("ME").mean() # TODO: is non-tick the relevant characteristic? (GH 33815) @@ -967,10 +934,7 @@ def test_sum_min_count(self): data = np.ones(6) data[3:6] = np.nan s = Series(data, index).to_period() - msg = "Resampling with a PeriodIndex is deprecated" - with tm.assert_produces_warning(FutureWarning, match=msg): - rs = s.resample("Q") - result = rs.sum(min_count=1) + result = s.resample("Q").sum(min_count=1) expected = Series( [3.0, np.nan], index=PeriodIndex(["2018Q1", "2018Q2"], freq="Q-DEC") ) @@ -1055,9 +1019,7 @@ def test_corner_cases_period(simple_period_range_series): # miscellaneous test coverage len0pts = simple_period_range_series("2007-01", "2010-05", freq="M")[:0] # it works - msg = "Resampling with a PeriodIndex is deprecated" - with tm.assert_produces_warning(FutureWarning, match=msg): - result = len0pts.resample("Y-DEC").mean() + result = len0pts.resample("Y-DEC").mean() assert len(result) == 0