BUG: Non-string loffset not applied when resampling a timeseries (GH13218)

Author: wcwagner

doc/source/whatsnew/v0.20.0.txt

@@ -321,3 +321,4 @@ Bug Fixes
 - Require at least 0.23 version of cython to avoid problems with character encodings (:issue:`14699`)
 - Bug in converting object elements of array-like objects to unsigned 64-bit integers (:issue:`4471`)
 - Bug in ``pd.pivot_table()`` where no error was raised when values argument was not in the columns (:issue:`14938`)
+- Bug in ``resample``, where a non-string ```loffset`` argument would not be applied when resampling a timeseries (:issue:`13218`)

pandas/tseries/resample.py

@@ -323,6 +323,11 @@ def aggregate(self, arg, *args, **kwargs):
                                                *args,
                                                **kwargs)
 
+        # if arg was a string, _aggregate called resampler's _downsample or
+        # _groupby_and_agg methods, which would've already applied the loffset
+        if not isinstance(arg, compat.string_types):
+            result = self._apply_loffset(result)
+
         return result
 
     agg = aggregate
@@ -381,7 +386,7 @@ def _gotitem(self, key, ndim, subset=None):
             return grouped
 
     def _groupby_and_aggregate(self, how, grouper=None, *args, **kwargs):
-        """ revaluate the obj with a groupby aggregation """
+        """ re-evaluate the obj with a groupby aggregation """
 
         if grouper is None:
             self._set_binner()
@@ -409,7 +414,14 @@ def _groupby_and_aggregate(self, how, grouper=None, *args, **kwargs):
         return self._wrap_result(result)
 
     def _apply_loffset(self, result):
-        """if loffset if set, offset the result index"""
+        """
+        if loffset is set, offset the result index
+
+        Parameters
+        ----------
+        result : Series or DataFrame
+            the result of resample
+        """
         loffset = self.loffset
         if isinstance(loffset, compat.string_types):
             loffset = to_offset(self.loffset)
@@ -419,6 +431,7 @@ def _apply_loffset(self, result):
             isinstance(result.index, DatetimeIndex) and
             len(result.index) > 0
         )
+
         if needs_offset:
             result.index = result.index + loffset
 
@@ -797,6 +810,11 @@ def aggregate(self, arg, *args, **kwargs):
         if result is None:
             result = self._downsample(arg, *args, **kwargs)
 
+        # if arg was a string, _aggregate called resamplers' _downsample or
+        # _groupby_and_agg methods, which would've already applied the loffset
+        if not isinstance(arg, compat.string_types):
+            result = self._apply_loffset(result)
+
         return result
 
     agg = aggregate

pandas/tseries/tests/test_resample.py

@@ -1188,6 +1188,29 @@ def test_resample_loffset_count(self):
 
         assert_series_equal(result, expected)
 
+    def test_resample_loffset_arg_type(self):
+        # GH 13218, 15002
+        s = self.create_series()
+        expected_means = [s.values[i:i + 2].mean()
+                          for i in range(0, len(s.values), 2)]
+        df = s.to_frame('value')
+        for arg in ['mean', {'value': 'mean'}, ['mean']]:
+            result_agg = df.resample('2D', loffset='2H').agg(arg)
+            with tm.assert_produces_warning(FutureWarning,
+                                            check_stacklevel=False):
+                result_how = df.resample('2D', how=arg, loffset='2H')
+            expected_index = DatetimeIndex(start=df.index[0],
+                                           freq='2D',
+                                           periods=len(df.index) / 2)
+            expected_index = expected_index + timedelta(hours=2)
+            expected = DataFrame({'value': expected_means},
+                                 index=expected_index)
+            if isinstance(arg, list):
+                expected.columns = pd.MultiIndex.from_tuples([('value',
+                                                               'mean')])
+            assert_frame_equal(result_agg, expected)
+            assert_frame_equal(result_how, expected)
+
     def test_resample_upsample(self):
         # from daily
         dti = DatetimeIndex(start=datetime(2005, 1, 1),
@@ -2655,6 +2678,28 @@ def test_evenly_divisible_with_no_extra_bins(self):
         result = df.resample('7D').sum()
         assert_frame_equal(result, expected)
 
+    def test_resample_loffset_arg_type(self):
+        # GH 13218, 15002
+        s = self.create_series()
+        expected_means = [s.values[i:i + 2].mean()
+                          for i in range(0, len(s.values), 2)]
+        df = s.to_frame('value')
+        for arg in ['mean', {'value': 'mean'}, ['mean']]:
+            result_agg = df.resample('2D', loffset='2H').agg(arg)
+            with tm.assert_produces_warning(FutureWarning,
+                                            check_stacklevel=False):
+                result_how = df.resample('2D', how=arg, loffset='2H')
+            expected_index = df.index.take(
+                np.arange(0, len(df.index), 2)).to_timestamp()
+            expected_index = expected_index + timedelta(hours=2)
+            expected = DataFrame({'value': expected_means},
+                                 index=expected_index)
+            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):
     _multiprocess_can_split_ = True
@@ -2677,6 +2722,30 @@ def test_asfreq_bug(self):
                                                    freq='1T'))
         assert_frame_equal(result, expected)
 
+    def test_resample_loffset_arg_type(self):
+        # GH 13218, 15002
+        s = self.create_series()
+        expected_means = [s.values[i:i + 2].mean()
+                          for i in range(0, len(s.values), 2)]
+        df = s.to_frame('value')
+        for arg in ['mean', {'value': 'mean'}, ['mean']]:
+            result_agg = df.resample('2D', loffset='2H').agg(arg)
+            with tm.assert_produces_warning(FutureWarning,
+                                            check_stacklevel=False):
+                result_how = df.resample('2D', how=arg, loffset='2H')
+            expected_index = timedelta_range(start=df.index[0],
+                                             freq='2D',
+                                             periods=len(df.index) / 2)
+            expected = DataFrame({'value': expected_means},
+                                 index=expected_index)
+            if isinstance(arg, list):
+                expected.columns = pd.MultiIndex.from_tuples([('value',
+                                                               'mean')])
+            # GH 13022, 7687 - TODO: fix resample w/ TimedeltaIndex
+            with tm.assertRaises(AssertionError):
+                assert_frame_equal(result_agg, expected)
+                assert_frame_equal(result_how, expected)
+
 
 class TestResamplerGrouper(tm.TestCase):
     def setUp(self):