Remove rolling

Author: TomAugspurger

dask/dataframe/rolling.py

@@ -142,27 +142,6 @@ def map_overlap(func, df, before, after, *args, **kwargs):
     return df._constructor(dsk, name, meta, df.divisions)
 
 
-def wrap_rolling(func, method_name):
-    """Create a chunked version of a pandas.rolling_* function"""
-    @wraps(func)
-    def rolling(arg, window, *args, **kwargs):
-        # pd.rolling_* functions are deprecated
-        warnings.warn(("DeprecationWarning: dd.rolling_{0} is deprecated and "
-                       "will be removed in a future version, replace with "
-                       "df.rolling(...).{0}(...)").format(method_name))
-
-        rolling_kwargs = {}
-        method_kwargs = {}
-        for k, v in kwargs.items():
-            if k in {'min_periods', 'center', 'win_type', 'axis', 'freq'}:
-                rolling_kwargs[k] = v
-            else:
-                method_kwargs[k] = v
-        rolling = arg.rolling(window, **rolling_kwargs)
-        return getattr(rolling, method_name)(*args, **method_kwargs)
-    return rolling
-
-
 def _head_timedelta(current, next_, after):
     """Return rows of ``next_`` whose index is before the last
     observation in ``current`` + ``after``.
@@ -197,27 +176,6 @@ def _tail_timedelta(prev, current, before):
     return prev[prev.index > (current.index.min() - before)]
 
 
-rolling_count = wrap_rolling(pd.rolling_count, 'count')
-rolling_sum = wrap_rolling(pd.rolling_sum, 'sum')
-rolling_mean = wrap_rolling(pd.rolling_mean, 'mean')
-rolling_median = wrap_rolling(pd.rolling_median, 'median')
-rolling_min = wrap_rolling(pd.rolling_min, 'min')
-rolling_max = wrap_rolling(pd.rolling_max, 'max')
-rolling_std = wrap_rolling(pd.rolling_std, 'std')
-rolling_var = wrap_rolling(pd.rolling_var, 'var')
-rolling_skew = wrap_rolling(pd.rolling_skew, 'skew')
-rolling_kurt = wrap_rolling(pd.rolling_kurt, 'kurt')
-rolling_quantile = wrap_rolling(pd.rolling_quantile, 'quantile')
-rolling_apply = wrap_rolling(pd.rolling_apply, 'apply')
-
-
-@wraps(pd.rolling_window)
-def rolling_window(arg, window, **kwargs):
-    if kwargs.pop('mean', True):
-        return rolling_mean(arg, window, **kwargs)
-    return rolling_sum(arg, window, **kwargs)
-
-
 def pandas_rolling_method(df, rolling_kwargs, name, *args, **kwargs):
     rolling = df.rolling(**rolling_kwargs)
     return getattr(rolling, name)(*args, **kwargs)

dask/dataframe/tests/test_rolling.py

@@ -93,35 +93,6 @@ def mad(x):
     return np.fabs(x - x.mean()).mean()
 
 
-def rolling_functions_tests(p, d):
-    # Old-fashioned rolling API
-    with pytest.warns(FutureWarning):
-        assert_eq(pd.rolling_count(p, 3), dd.rolling_count(d, 3))
-        assert_eq(pd.rolling_sum(p, 3), dd.rolling_sum(d, 3))
-        assert_eq(pd.rolling_mean(p, 3), dd.rolling_mean(d, 3))
-        assert_eq(pd.rolling_median(p, 3), dd.rolling_median(d, 3))
-        assert_eq(pd.rolling_min(p, 3), dd.rolling_min(d, 3))
-        assert_eq(pd.rolling_max(p, 3), dd.rolling_max(d, 3))
-        assert_eq(pd.rolling_std(p, 3), dd.rolling_std(d, 3))
-        assert_eq(pd.rolling_var(p, 3), dd.rolling_var(d, 3))
-        # see note around test_rolling_dataframe for logic concerning precision
-        assert_eq(pd.rolling_skew(p, 3),
-                  dd.rolling_skew(d, 3), check_less_precise=True)
-        assert_eq(pd.rolling_kurt(p, 3),
-                  dd.rolling_kurt(d, 3), check_less_precise=True)
-        assert_eq(pd.rolling_quantile(p, 3, 0.5), dd.rolling_quantile(d, 3, 0.5))
-        assert_eq(pd.rolling_apply(p, 3, mad), dd.rolling_apply(d, 3, mad))
-        # Test with edge-case window sizes
-        assert_eq(pd.rolling_sum(p, 0), dd.rolling_sum(d, 0))
-        assert_eq(pd.rolling_sum(p, 1), dd.rolling_sum(d, 1))
-        # Test with kwargs
-        assert_eq(pd.rolling_sum(p, 3, min_periods=3),
-                  dd.rolling_sum(d, 3, min_periods=3))
-        pytest.importorskip("scipy")
-        assert_eq(pd.rolling_window(p, 3, win_type='boxcar'),
-                  dd.rolling_window(d, 3, win_type='boxcar'))
-
-
 def test_rolling_functions_series():
     ts = pd.Series(np.random.randn(25).cumsum())
     dts = dd.from_pandas(ts, 3)