BUG: resampling PeriodIndex now returns PeriodIndex (GH 12884, 15944)

Exceptions:
- force conversion to DatetimeIndex by kind='timestamp' param
- if loffset is given, convert to timestamps in any case

Author: winklerand

pandas/core/resample.py

@@ -808,16 +808,15 @@ def _convert_obj(self, obj):
                    " use .set_index(...) to explicitly set index")
             raise NotImplementedError(msg)
 
-        offset = to_offset(self.freq)
-        if offset.n > 1:
-            if self.kind == 'period':  # pragma: no cover
-                print('Warning: multiple of frequency -> timestamps')
-
-            # Cannot have multiple of periods, convert to timestamp
+        if self.loffset is not None:
+            if self.kind == 'period':
+                print('Warning: loffset -> convert PeriodIndex to timestamps')
+                # Cannot apply loffset/timedelta to PeriodIndex -> convert to
+                # timestamps
             self.kind = 'timestamp'
 
         # convert to timestamp
-        if not (self.kind is None or self.kind == 'period'):
+        if self.kind == 'timestamp':
             obj = obj.to_timestamp(how=self.convention)
 
         return obj
@@ -1254,8 +1253,10 @@ def _get_period_bins(self, ax):
 
         memb = ax.asfreq(self.freq, how=self.convention)
         i8 = memb.asi8
-        rng = np.arange(i8[0], i8[-1] + 1)
-        bins = memb.searchsorted(rng, side='right')
+        freq_mult = self.freq.n
+        rng = np.arange(i8[0], i8[-1] + 1, freq_mult)
+        rng += freq_mult
+        bins = memb.searchsorted(rng, side='left')
 
         return binner, bins, labels
 

pandas/tests/test_resample.py

@@ -2179,49 +2179,75 @@ def create_series(self):
         return Series(np.arange(len(i)), index=i, name='pi')
 
     def test_asfreq_downsample(self):
+        # GH 12884, 15944
 
-        # series
         s = self.create_series()
-        expected = s.reindex(s.index.take(np.arange(0, len(s.index), 2)))
-        expected.index = expected.index.to_timestamp()
-        expected.index.freq = to_offset('2D')
+        start = s.index[0].to_timestamp(how='start')
+        end = (s.index[-1] + 1).to_timestamp(how='start')
 
-        # this is a bug, this *should* return a PeriodIndex
-        # directly
-        # GH 12884
+        new_index = date_range(start=start, end=end, freq='2D', closed='left')
+        # series
+        expected = s.to_timestamp().reindex(new_index).to_period('2D')
         result = s.resample('2D').asfreq()
         assert_series_equal(result, expected)
+        result_kind_period = s.resample('2D', kind='period').asfreq()
+        assert_series_equal(result_kind_period, expected)
 
         # frame
         frame = s.to_frame('value')
-        expected = frame.reindex(
-            frame.index.take(np.arange(0, len(frame.index), 2)))
-        expected.index = expected.index.to_timestamp()
-        expected.index.freq = to_offset('2D')
+        expected = frame.to_timestamp().reindex(new_index).to_period('2D')
         result = frame.resample('2D').asfreq()
         assert_frame_equal(result, expected)
+        result_kind_period = frame.resample('2D', kind='period').asfreq()
+        assert_frame_equal(result_kind_period, expected)
+
+    def test_asfreq_downsample_kind_timestamp(self):
+        # series
+        s = self.create_series()
+        expected = s.to_timestamp().resample('2D').asfreq()
+        result = s.resample('2D', kind='timestamp').asfreq()
+        assert_series_equal(result, expected)
+
+        # frame
+        frame = s.to_frame('value')
+        expected = frame.to_timestamp().resample('2D').asfreq()
+        result = frame.resample('2D', kind='timestamp').asfreq()
+        assert_frame_equal(result, expected)
 
     def test_asfreq_upsample(self):
+        # GH 12884, 15944
 
-        # this is a bug, this *should* return a PeriodIndex
-        # directly
-        # GH 12884
         s = self.create_series()
-        new_index = date_range(s.index[0].to_timestamp(how='start'),
-                               (s.index[-1] + 1).to_timestamp(how='start'),
-                               freq='1H',
-                               closed='left')
-        expected = s.to_timestamp().reindex(new_index).to_period()
-        result = s.resample('1H').asfreq()
+        start = s.index[0].to_timestamp(how='start')
+        end = (s.index[-1] + 1).to_timestamp(how='start')
+        for freq in ['1H', '2H']:
+            # check base frequency and frequency multiple
+            new_index = date_range(start=start, end=end, freq=freq,
+                                   closed='left')
+            # series
+            expected = s.to_timestamp().reindex(new_index).to_period(freq)
+            result = s.resample(freq).asfreq()
+            assert_series_equal(result, expected)
+            result_kind_period = s.resample(freq, kind='period').asfreq()
+            assert_series_equal(result_kind_period, expected)
+
+            # frame
+            frame = s.to_frame('value')
+            expected = frame.to_timestamp().reindex(new_index).to_period(freq)
+            result = frame.resample(freq).asfreq()
+            assert_frame_equal(result, expected)
+            result_kind_period = frame.resample(freq, kind='period').asfreq()
+            assert_frame_equal(result_kind_period, expected)
+
+    def test_asfreq_upsample_kind_timestamp(self):
+        s = self.create_series()
+        expected = s.to_timestamp().resample('1H').asfreq()
+        result = s.resample('1H', kind='timestamp').asfreq()
         assert_series_equal(result, expected)
 
         frame = s.to_frame('value')
-        new_index = date_range(frame.index[0].to_timestamp(how='start'),
-                               (frame.index[-1] + 1).to_timestamp(how='start'),
-                               freq='1H',
-                               closed='left')
-        expected = frame.to_timestamp().reindex(new_index).to_period()
-        result = frame.resample('1H').asfreq()
+        expected = frame.to_timestamp().resample('1H').asfreq()
+        result = frame.resample('1H', kind='timestamp').asfreq()
         assert_frame_equal(result, expected)
 
     def test_asfreq_fill_value(self):
@@ -2333,12 +2359,11 @@ def test_basic_upsample(self):
         ts = _simple_pts('1/1/1990', '6/30/1995', freq='M')
         result = ts.resample('a-dec').mean()
 
-        resampled = result.resample('D', convention='end').ffill()
-
-        expected = result.to_timestamp('D', how='end')
-        expected = expected.asfreq('D', 'ffill').to_period()
-
-        assert_series_equal(resampled, expected)
+        for freq in ['D', '2D']:
+            resampled = result.resample(freq, convention='end').ffill()
+            expected = result.to_timestamp(freq, how='end')
+            expected = expected.asfreq(freq, 'ffill').to_period(freq)
+            assert_series_equal(resampled, expected)
 
     def test_upsample_with_limit(self):
         rng = period_range('1/1/2000', periods=5, freq='A')
@@ -2409,10 +2434,13 @@ def test_resample_count(self):
         series = pd.Series(1, index=pd.period_range(start='2000',
                                                     periods=100))
         result = series.resample('M').count()
-
         expected_index = pd.period_range(start='2000', freq='M', periods=4)
         expected = pd.Series([31, 29, 31, 9], index=expected_index)
+        assert_series_equal(result, expected)
 
+        result = series.resample('2M').count()
+        expected_index = pd.period_range(start='2000', freq='2M', periods=2)
+        expected = pd.Series([31 + 29, 31 + 9], index=expected_index)
         assert_series_equal(result, expected)
 
     def test_resample_same_freq(self):
@@ -2560,7 +2588,17 @@ def test_resample_5minute(self):
         rng = period_range('1/1/2000', '1/5/2000', freq='T')
         ts = Series(np.random.randn(len(rng)), index=rng)
 
+        expected = ts.to_timestamp().resample('5min').mean().to_period('5min')
         result = ts.resample('5min').mean()
+        assert_series_equal(result, expected)
+        result_kind_period = ts.resample('5min', kind='period').mean()
+        assert_series_equal(result_kind_period, expected)
+
+    def test_resample_5minute_kind_timestamp(self):
+        rng = period_range('1/1/2000', '1/5/2000', freq='T')
+        ts = Series(np.random.randn(len(rng)), index=rng)
+
+        result = ts.resample('5min', kind='timestamp').mean()
         expected = ts.to_timestamp().resample('5min').mean()
         assert_series_equal(result, expected)
 
@@ -2781,6 +2819,34 @@ def test_evenly_divisible_with_no_extra_bins(self):
         result = df.resample('7D').sum()
         assert_frame_equal(result, expected)
 
+    def test_loffset_returns_datetimeindex(self):
+        # make sure passing loffset returns DatetimeIndex in all cases
+        # basic method taken from Base.test_resample_loffset_arg_type()
+        df = self.create_series().to_frame('value')
+        expected_means = [df.values[i:i + 2].mean()
+                          for i in range(0, len(df.values), 2)]
+        expected_index = self.create_index(df.index[0], periods=len(df.index) /
+                                           2, freq='2D')
+
+        # loffset coreces PeriodIndex to DateTimeIndex
+        expected_index = expected_index.to_timestamp()
+        expected_index += timedelta(hours=2)
+        expected = DataFrame({'value': expected_means}, index=expected_index)
+
+        for arg in ['mean', {'value': 'mean'}, ['mean']]:
+            for kind_param in [None, 'period', 'timestamp']:
+                result_agg = (df.resample('2D', loffset='2H', kind=kind_param)
+                              .agg(arg))
+                with tm.assert_produces_warning(FutureWarning,
+                                                check_stacklevel=False):
+                    result_how = df.resample('2D', how=arg, loffset='2H',
+                                             kind=kind_param)
+                if isinstance(arg, list):
+                    expected.columns = (pd.MultiIndex
+                                        .from_tuples([('value', 'mean')]))
+                assert_frame_equal(result_agg, expected)
+                assert_frame_equal(result_how, expected)
+
 
 class TestTimedeltaIndex(Base, tm.TestCase):
     _index_factory = lambda x: timedelta_range