more refactoring

christinafan · christinafan · commit a5df69ebf60e · 2023-07-12T20:10:05.000-07:00
diff --git a/modin/core/storage_formats/pandas/query_compiler.py b/modin/core/storage_formats/pandas/query_compiler.py
@@ -1412,7 +1412,7 @@ def expanding_corr(
 
     old_window_mean = Fold.register(
         lambda df, rolling_kwargs, *args, **kwargs: pandas.DataFrame(
-            df.rolling(*rolling_kwargs).mean(*args, **kwargs)
+            df.rolling(**rolling_kwargs).mean(*args, **kwargs)
         )
     )
 
@@ -1425,15 +1425,15 @@ def window_mean(self, axis, window_kwargs, *args, **kwargs):
                 self._modin_frame.window(
                     axis,
                     window,
-                    lambda df: df.rolling(*window_kwargs).mean(*args, **kwargs),
+                    lambda df: df.rolling(**window_kwargs).mean(*args, **kwargs),
                 )
             )
         else:
             return self.old_window_mean(axis, window_kwargs, *args, **kwargs)
 
     old_window_sum = Fold.register(
         lambda df, rolling_kwargs, *args, **kwargs: pandas.DataFrame(
-            df.rolling(*rolling_kwargs).sum(*args, **kwargs)
+            df.rolling(**rolling_kwargs).sum(*args, **kwargs)
         )
     )
 
@@ -1446,15 +1446,15 @@ def window_sum(self, axis, window_kwargs, *args, **kwargs):
                 self._modin_frame.window(
                     axis,
                     window,
-                    lambda df: df.rolling(*window_kwargs).sum(*args, **kwargs),
+                    lambda df: df.rolling(**window_kwargs).sum(*args, **kwargs),
                 )
             )
         else:
             return self.old_window_sum(axis, window_kwargs, *args, **kwargs)
 
     old_window_var = Fold.register(
         lambda df, rolling_kwargs, ddof, *args, **kwargs: pandas.DataFrame(
-            df.rolling(*rolling_kwargs).var(ddof=ddof, *args, **kwargs)
+            df.rolling(**rolling_kwargs).var(ddof=ddof, *args, **kwargs)
         )
     )
 
@@ -1467,15 +1467,15 @@ def window_var(self, axis, window_kwargs, ddof, *args, **kwargs):
                 self._modin_frame.window(
                     axis,
                     window,
-                    lambda df: df.rolling(*window_kwargs).var(ddof, *args, **kwargs),
+                    lambda df: df.rolling(**window_kwargs).var(ddof, *args, **kwargs),
                 )
             )
         else:
             return self.old_window_var(axis, window_kwargs, ddof, *args, **kwargs)
 
     old_window_std = Fold.register(
         lambda df, rolling_kwargs, ddof, *args, **kwargs: pandas.DataFrame(
-            df.rolling(*rolling_kwargs).std(ddof=ddof, *args, **kwargs)
+            df.rolling(**rolling_kwargs).std(ddof=ddof, *args, **kwargs)
         )
     )
 
@@ -1488,14 +1488,14 @@ def window_std(self, axis, window_kwargs, ddof, *args, **kwargs):
                 self._modin_frame.window(
                     axis,
                     window,
-                    lambda df: df.rolling(*window_kwargs).std(ddof=ddof, *args, **kwargs),
+                    lambda df: df.rolling(**window_kwargs).std(ddof=ddof, *args, **kwargs),
                 )
             )
         else:
             return self.old_window_std(axis, window_kwargs, ddof, *args, **kwargs)
 
     old_rolling_count = Fold.register(
-        lambda df, rolling_kwargs: pandas.DataFrame(df.rolling(*rolling_kwargs).count())
+        lambda df, rolling_kwargs: pandas.DataFrame(df.rolling(**rolling_kwargs).count())
     )
 
     def rolling_count(self, axis, rolling_kwargs):
@@ -1505,15 +1505,15 @@ def rolling_count(self, axis, rolling_kwargs):
         if _can_use_cell_wise_window(center, window, win_type):
             return self.__constructor__(
                 self._modin_frame.window(
-                    axis, window, lambda df: df.rolling(*rolling_kwargs).count()
+                    axis, window, lambda df: df.rolling(**rolling_kwargs).count()
                 )
             )
         else:
             return self.old_rolling_count(axis, rolling_kwargs)
 
     old_rolling_sum = Fold.register(
         lambda df, rolling_kwargs, *args, **kwargs: pandas.DataFrame(
-            df.rolling(*rolling_kwargs).sum(*args, **kwargs)
+            df.rolling(**rolling_kwargs).sum(*args, **kwargs)
         )
     )
 
@@ -1526,15 +1526,15 @@ def rolling_sum(self, axis, rolling_kwargs, *args, **kwargs):
                 self._modin_frame.window(
                     axis,
                     window,
-                    lambda df: df.rolling(*rolling_kwargs).sum(*args, **kwargs),
+                    lambda df: df.rolling(**rolling_kwargs).sum(*args, **kwargs),
                 )
             )
         else:
             return self.old_rolling_sum(axis, rolling_kwargs, *args, **kwargs)
 
     old_rolling_sem = Fold.register(
         lambda df, rolling_kwargs, *args, **kwargs: pandas.DataFrame(
-            df.rolling(*rolling_kwargs).sem(*args, **kwargs)
+            df.rolling(**rolling_kwargs).sem(*args, **kwargs)
         )
     )
 
@@ -1547,15 +1547,15 @@ def rolling_sem(self, axis, rolling_kwargs, *args, **kwargs):
                 self._modin_frame.window(
                     axis,
                     window,
-                    lambda df: df.rolling(*rolling_kwargs).sem(*args, **kwargs),
+                    lambda df: df.rolling(**rolling_kwargs).sem(*args, **kwargs),
                 )
             )
         else:
             return self.old_rolling_sem(axis, rolling_kwargs, *args, **kwargs)
 
     old_rolling_mean = Fold.register(
         lambda df, rolling_kwargs, *args, **kwargs: pandas.DataFrame(
-            df.rolling(*rolling_kwargs).mean(*args, **kwargs)
+            df.rolling(**rolling_kwargs).mean(*args, **kwargs)
         )
     )
 
@@ -1568,15 +1568,15 @@ def rolling_mean(self, axis, rolling_kwargs, *args, **kwargs):
                 self._modin_frame.window(
                     axis,
                     window,
-                    lambda df: df.rolling(*rolling_kwargs).mean(*args, **kwargs),
+                    lambda df: df.rolling(**rolling_kwargs).mean(*args, **kwargs),
                 )
             )
         else:
             return self.old_rolling_mean(axis, rolling_kwargs, *args, **kwargs)
 
     old_rolling_median = Fold.register(
         lambda df, rolling_kwargs, **kwargs: pandas.DataFrame(
-            df.rolling(*rolling_kwargs).median(**kwargs)
+            df.rolling(**rolling_kwargs).median(**kwargs)
         )
     )
 
@@ -1587,15 +1587,15 @@ def rolling_median(self, axis, rolling_kwargs, **kwargs):
         if _can_use_cell_wise_window(center, window, win_type):
             return self.__constructor__(
                 self._modin_frame.window(
-                    axis, window, lambda df: df.rolling(*rolling_kwargs).median(**kwargs)
+                    axis, window, lambda df: df.rolling(**rolling_kwargs).median(**kwargs)
                 )
             )
         else:
             return self.old_rolling_median(axis, rolling_kwargs, **kwargs)
 
     old_rolling_var = Fold.register(
         lambda df, rolling_kwargs, ddof, *args, **kwargs: pandas.DataFrame(
-            df.rolling(*rolling_kwargs).var(ddof=ddof, *args, **kwargs)
+            df.rolling(**rolling_kwargs).var(ddof=ddof, *args, **kwargs)
         )
     )
 
@@ -1608,7 +1608,7 @@ def rolling_var(self, axis, rolling_kwargs, ddof, *args, **kwargs):
                 self._modin_frame.window(
                     axis,
                     window,
-                    lambda df: df.rolling(*rolling_kwargs).var(
+                    lambda df: df.rolling(**rolling_kwargs).var(
                         ddof=ddof, *args, **kwargs
                     ),
                 )
@@ -1618,7 +1618,7 @@ def rolling_var(self, axis, rolling_kwargs, ddof, *args, **kwargs):
 
     old_rolling_std = Fold.register(
         lambda df, rolling_kwargs, ddof, *args, **kwargs: pandas.DataFrame(
-            df.rolling(*rolling_kwargs).std(ddof=ddof, *args, **kwargs)
+            df.rolling(**rolling_kwargs).std(ddof=ddof, *args, **kwargs)
         )
     )
 
@@ -1631,7 +1631,7 @@ def rolling_std(self, axis, rolling_kwargs, ddof, *args, **kwargs):
                 self._modin_frame.window(
                     axis,
                     window,
-                    lambda df: df.rolling(*rolling_kwargs).std(
+                    lambda df: df.rolling(**rolling_kwargs).std(
                         ddof=ddof, *args, **kwargs
                     ),
                 )
@@ -1641,7 +1641,7 @@ def rolling_std(self, axis, rolling_kwargs, ddof, *args, **kwargs):
 
     old_rolling_min = Fold.register(
         lambda df, rolling_kwargs, *args, **kwargs: pandas.DataFrame(
-            df.rolling(*rolling_kwargs).min(*args, **kwargs)
+            df.rolling(**rolling_kwargs).min(*args, **kwargs)
         )
     )
 
@@ -1654,15 +1654,15 @@ def rolling_min(self, axis, rolling_kwargs, *args, **kwargs):
                 self._modin_frame.window(
                     axis,
                     window,
-                    lambda df: df.rolling(*rolling_kwargs).min(*args, **kwargs),
+                    lambda df: df.rolling(**rolling_kwargs).min(*args, **kwargs),
                 )
             )
         else:
             return self.old_rolling_min(axis, rolling_kwargs, *args, **kwargs)
 
     old_rolling_max = Fold.register(
         lambda df, rolling_kwargs, *args, **kwargs: pandas.DataFrame(
-            df.rolling(*rolling_kwargs).max(*args, **kwargs)
+            df.rolling(**rolling_kwargs).max(*args, **kwargs)
         )
     )
 
@@ -1675,15 +1675,15 @@ def rolling_max(self, axis, rolling_kwargs, *args, **kwargs):
                 self._modin_frame.window(
                     axis,
                     window,
-                    lambda df: df.rolling(*rolling_kwargs).max(*args, **kwargs),
+                    lambda df: df.rolling(**rolling_kwargs).max(*args, **kwargs),
                 )
             )
         else:
             return self.old_rolling_max(axis, rolling_kwargs, *args, **kwargs)
 
     old_rolling_skew = Fold.register(
         lambda df, rolling_kwargs, **kwargs: pandas.DataFrame(
-            df.rolling(*rolling_kwargs).skew(**kwargs)
+            df.rolling(**rolling_kwargs).skew(**kwargs)
         )
     )
 
@@ -1694,15 +1694,15 @@ def rolling_skew(self, axis, rolling_kwargs, **kwargs):
         if _can_use_cell_wise_window(center, window, win_type):
             return self.__constructor__(
                 self._modin_frame.window(
-                    axis, window, lambda df: df.rolling(*rolling_kwargs).skew(**kwargs)
+                    axis, window, lambda df: df.rolling(**rolling_kwargs).skew(**kwargs)
                 )
             )
         else:
             return self.old_rolling_skew(axis, rolling_kwargs, **kwargs)
 
     old_rolling_kurt = Fold.register(
         lambda df, rolling_kwargs, **kwargs: pandas.DataFrame(
-            df.rolling(*rolling_kwargs).kurt(**kwargs)
+            df.rolling(**rolling_kwargs).kurt(**kwargs)
         )
     )
 
@@ -1713,15 +1713,15 @@ def rolling_kurt(self, axis, rolling_kwargs, **kwargs):
         if _can_use_cell_wise_window(center, window, win_type):
             return self.__constructor__(
                 self._modin_frame.window(
-                    axis, window, lambda df: df.rolling(*rolling_kwargs).kurt(**kwargs)
+                    axis, window, lambda df: df.rolling(**rolling_kwargs).kurt(**kwargs)
                 )
             )
         else:
             return self.old_rolling_kurt(axis, rolling_kwargs, **kwargs)
 
     old_rolling_apply = Fold.register(
         lambda df, rolling_kwargs, func, raw, engine, engine_kwargs, args, kwargs: pandas.DataFrame(
-            df.rolling(*rolling_kwargs).apply(
+            df.rolling(**rolling_kwargs).apply(
                 func=func,
                 raw=raw,
                 engine=engine,
@@ -1743,7 +1743,7 @@ def rolling_apply(
                 self._modin_frame.window(
                     axis,
                     window,
-                    lambda df: df.rolling(*rolling_kwargs).apply(
+                    lambda df: df.rolling(**rolling_kwargs).apply(
                         func=func,
                         raw=raw,
                         engine=engine,
@@ -1767,7 +1767,7 @@ def rolling_apply(
 
     old_rolling_rank = Fold.register(
         lambda df, rolling_kwargs, method, ascending, pct, numeric_only, **kwargs: pandas.DataFrame(
-            df.rolling(*rolling_kwargs).rank(
+            df.rolling(**rolling_kwargs).rank(
                 method=method,
                 ascending=ascending,
                 pct=pct,
@@ -1788,7 +1788,7 @@ def rolling_rank(
                 self._modin_frame.window(
                     axis,
                     window,
-                    lambda df: df.rolling(*rolling_kwargs).rank(
+                    lambda df: df.rolling(**rolling_kwargs).rank(
                         method=method,
                         ascending=ascending,
                         pct=pct,
@@ -1804,7 +1804,7 @@ def rolling_rank(
 
     old_rolling_quantile = Fold.register(
         lambda df, rolling_kwargs, quantile, interpolation, **kwargs: pandas.DataFrame(
-            df.rolling(*rolling_kwargs).quantile(
+            df.rolling(**rolling_kwargs).quantile(
                 quantile=quantile, interpolation=interpolation, **kwargs
             )
         )
@@ -1819,7 +1819,7 @@ def rolling_quantile(self, axis, rolling_kwargs, quantile, interpolation, **kwar
                 self._modin_frame.window(
                     axis,
                     window,
-                    lambda df: df.rolling(*rolling_kwargs).quantile(
+                    lambda df: df.rolling(**rolling_kwargs).quantile(
                         quantile=quantile, interpolation=interpolation, **kwargs
                     ),
                 )
@@ -1831,7 +1831,7 @@ def rolling_quantile(self, axis, rolling_kwargs, quantile, interpolation, **kwar
 
     old_rolling_corr = Fold.register(
         lambda df, rolling_kwargs, other, pairwise, *args, **kwargs: pandas.DataFrame(
-            df.rolling(*rolling_kwargs).corr(
+            df.rolling(**rolling_kwargs).corr(
                 other=other, pairwise=pairwise, *args, **kwargs
             )
         )
@@ -1853,7 +1853,7 @@ def rolling_corr(self, axis, rolling_kwargs, other, pairwise, *args, **kwargs):
                     self._modin_frame.window(
                         axis,
                         window,
-                        lambda df: df.rolling(*rolling_kwargs).corr(
+                        lambda df: df.rolling(**rolling_kwargs).corr(
                             other=other, pairwise=pairwise, *args, **kwargs
                         ),
                     )
@@ -1865,7 +1865,7 @@ def rolling_corr(self, axis, rolling_kwargs, other, pairwise, *args, **kwargs):
 
     old_rolling_cov = Fold.register(
         lambda df, rolling_kwargs, other, pairwise, ddof, **kwargs: pandas.DataFrame(
-            df.rolling(*rolling_kwargs).cov(
+            df.rolling(**rolling_kwargs).cov(
                 other=other, pairwise=pairwise, ddof=ddof, **kwargs
             )
         )
@@ -1891,7 +1891,7 @@ def rolling_cov(self, axis, rolling_kwargs, other, pairwise, ddof, **kwargs):
                     self._modin_frame.window(
                         axis,
                         window,
-                        lambda df: df.rolling(*rolling_kwargs).cov(
+                        lambda df: df.rolling(**rolling_kwargs).cov(
                             other=other, pairwise=pairwise, **kwargs
                         ),
                     )
@@ -1907,7 +1907,7 @@ def rolling_aggregate(self, axis, rolling_kwargs, func, *args, **kwargs):
         new_modin_frame = self._modin_frame.apply_full_axis(
             axis,
             lambda df: pandas.DataFrame(
-                df.rolling(*rolling_kwargs).aggregate(func=func, *args, **kwargs)
+                df.rolling(**rolling_kwargs).aggregate(func=func, *args, **kwargs)
             ),
             new_index=self.index,
         )

Original file line number	Diff line number	Diff line change
`@@ -1412,7 +1412,7 @@ def expanding_corr(`
`1412`	`1412`
`1413`	`1413`	`old_window_mean = Fold.register(`
`1414`	`1414`	`lambda df, rolling_kwargs, args, *kwargs: pandas.DataFrame(`
`1415`		`- df.rolling(rolling_kwargs).mean(args, **kwargs)`
	`1415`	`+ df.rolling(*rolling_kwargs).mean(args, **kwargs)`
`1416`	`1416`	`)`
`1417`	`1417`	`)`
`1418`	`1418`
`@@ -1425,15 +1425,15 @@ def window_mean(self, axis, window_kwargs, args, *kwargs):`
`1425`	`1425`	`self._modin_frame.window(`
`1426`	`1426`	`axis,`
`1427`	`1427`	`window,`
`1428`		`- lambda df: df.rolling(window_kwargs).mean(args, **kwargs),`
	`1428`	`+ lambda df: df.rolling(*window_kwargs).mean(args, **kwargs),`
`1429`	`1429`	`)`
`1430`	`1430`	`)`
`1431`	`1431`	`else:`
`1432`	`1432`	`return self.old_window_mean(axis, window_kwargs, args, *kwargs)`
`1433`	`1433`
`1434`	`1434`	`old_window_sum = Fold.register(`
`1435`	`1435`	`lambda df, rolling_kwargs, args, *kwargs: pandas.DataFrame(`
`1436`		`- df.rolling(rolling_kwargs).sum(args, **kwargs)`
	`1436`	`+ df.rolling(*rolling_kwargs).sum(args, **kwargs)`
`1437`	`1437`	`)`
`1438`	`1438`	`)`
`1439`	`1439`
`@@ -1446,15 +1446,15 @@ def window_sum(self, axis, window_kwargs, args, *kwargs):`
`1446`	`1446`	`self._modin_frame.window(`
`1447`	`1447`	`axis,`
`1448`	`1448`	`window,`
`1449`		`- lambda df: df.rolling(window_kwargs).sum(args, **kwargs),`
	`1449`	`+ lambda df: df.rolling(*window_kwargs).sum(args, **kwargs),`
`1450`	`1450`	`)`
`1451`	`1451`	`)`
`1452`	`1452`	`else:`
`1453`	`1453`	`return self.old_window_sum(axis, window_kwargs, args, *kwargs)`
`1454`	`1454`
`1455`	`1455`	`old_window_var = Fold.register(`
`1456`	`1456`	`lambda df, rolling_kwargs, ddof, args, *kwargs: pandas.DataFrame(`
`1457`		`- df.rolling(rolling_kwargs).var(ddof=ddof, args, **kwargs)`
	`1457`	`+ df.rolling(*rolling_kwargs).var(ddof=ddof, args, **kwargs)`
`1458`	`1458`	`)`
`1459`	`1459`	`)`
`1460`	`1460`
`@@ -1467,15 +1467,15 @@ def window_var(self, axis, window_kwargs, ddof, args, *kwargs):`
`1467`	`1467`	`self._modin_frame.window(`
`1468`	`1468`	`axis,`
`1469`	`1469`	`window,`
`1470`		`- lambda df: df.rolling(window_kwargs).var(ddof, args, **kwargs),`
	`1470`	`+ lambda df: df.rolling(*window_kwargs).var(ddof, args, **kwargs),`
`1471`	`1471`	`)`
`1472`	`1472`	`)`
`1473`	`1473`	`else:`
`1474`	`1474`	`return self.old_window_var(axis, window_kwargs, ddof, args, *kwargs)`
`1475`	`1475`
`1476`	`1476`	`old_window_std = Fold.register(`
`1477`	`1477`	`lambda df, rolling_kwargs, ddof, args, *kwargs: pandas.DataFrame(`
`1478`		`- df.rolling(rolling_kwargs).std(ddof=ddof, args, **kwargs)`
	`1478`	`+ df.rolling(*rolling_kwargs).std(ddof=ddof, args, **kwargs)`
`1479`	`1479`	`)`
`1480`	`1480`	`)`
`1481`	`1481`
`@@ -1488,14 +1488,14 @@ def window_std(self, axis, window_kwargs, ddof, args, *kwargs):`
`1488`	`1488`	`self._modin_frame.window(`
`1489`	`1489`	`axis,`
`1490`	`1490`	`window,`
`1491`		`- lambda df: df.rolling(window_kwargs).std(ddof=ddof, args, **kwargs),`
	`1491`	`+ lambda df: df.rolling(*window_kwargs).std(ddof=ddof, args, **kwargs),`
`1492`	`1492`	`)`
`1493`	`1493`	`)`
`1494`	`1494`	`else:`
`1495`	`1495`	`return self.old_window_std(axis, window_kwargs, ddof, args, *kwargs)`
`1496`	`1496`
`1497`	`1497`	`old_rolling_count = Fold.register(`
`1498`		`- lambda df, rolling_kwargs: pandas.DataFrame(df.rolling(*rolling_kwargs).count())`
	`1498`	`+ lambda df, rolling_kwargs: pandas.DataFrame(df.rolling(**rolling_kwargs).count())`
`1499`	`1499`	`)`
`1500`	`1500`
`1501`	`1501`	`def rolling_count(self, axis, rolling_kwargs):`
`@@ -1505,15 +1505,15 @@ def rolling_count(self, axis, rolling_kwargs):`
`1505`	`1505`	`if _can_use_cell_wise_window(center, window, win_type):`
`1506`	`1506`	`return self.__constructor__(`
`1507`	`1507`	`self._modin_frame.window(`
`1508`		`- axis, window, lambda df: df.rolling(*rolling_kwargs).count()`
	`1508`	`+ axis, window, lambda df: df.rolling(**rolling_kwargs).count()`
`1509`	`1509`	`)`
`1510`	`1510`	`)`
`1511`	`1511`	`else:`
`1512`	`1512`	`return self.old_rolling_count(axis, rolling_kwargs)`
`1513`	`1513`
`1514`	`1514`	`old_rolling_sum = Fold.register(`
`1515`	`1515`	`lambda df, rolling_kwargs, args, *kwargs: pandas.DataFrame(`
`1516`		`- df.rolling(rolling_kwargs).sum(args, **kwargs)`
	`1516`	`+ df.rolling(*rolling_kwargs).sum(args, **kwargs)`
`1517`	`1517`	`)`
`1518`	`1518`	`)`
`1519`	`1519`
`@@ -1526,15 +1526,15 @@ def rolling_sum(self, axis, rolling_kwargs, args, *kwargs):`
`1526`	`1526`	`self._modin_frame.window(`
`1527`	`1527`	`axis,`
`1528`	`1528`	`window,`
`1529`		`- lambda df: df.rolling(rolling_kwargs).sum(args, **kwargs),`
	`1529`	`+ lambda df: df.rolling(*rolling_kwargs).sum(args, **kwargs),`
`1530`	`1530`	`)`
`1531`	`1531`	`)`
`1532`	`1532`	`else:`
`1533`	`1533`	`return self.old_rolling_sum(axis, rolling_kwargs, args, *kwargs)`
`1534`	`1534`
`1535`	`1535`	`old_rolling_sem = Fold.register(`
`1536`	`1536`	`lambda df, rolling_kwargs, args, *kwargs: pandas.DataFrame(`
`1537`		`- df.rolling(rolling_kwargs).sem(args, **kwargs)`
	`1537`	`+ df.rolling(*rolling_kwargs).sem(args, **kwargs)`
`1538`	`1538`	`)`
`1539`	`1539`	`)`
`1540`	`1540`
`@@ -1547,15 +1547,15 @@ def rolling_sem(self, axis, rolling_kwargs, args, *kwargs):`
`1547`	`1547`	`self._modin_frame.window(`
`1548`	`1548`	`axis,`
`1549`	`1549`	`window,`
`1550`		`- lambda df: df.rolling(rolling_kwargs).sem(args, **kwargs),`
	`1550`	`+ lambda df: df.rolling(*rolling_kwargs).sem(args, **kwargs),`
`1551`	`1551`	`)`
`1552`	`1552`	`)`
`1553`	`1553`	`else:`
`1554`	`1554`	`return self.old_rolling_sem(axis, rolling_kwargs, args, *kwargs)`
`1555`	`1555`
`1556`	`1556`	`old_rolling_mean = Fold.register(`
`1557`	`1557`	`lambda df, rolling_kwargs, args, *kwargs: pandas.DataFrame(`
`1558`		`- df.rolling(rolling_kwargs).mean(args, **kwargs)`
	`1558`	`+ df.rolling(*rolling_kwargs).mean(args, **kwargs)`
`1559`	`1559`	`)`
`1560`	`1560`	`)`
`1561`	`1561`
`@@ -1568,15 +1568,15 @@ def rolling_mean(self, axis, rolling_kwargs, args, *kwargs):`
`1568`	`1568`	`self._modin_frame.window(`
`1569`	`1569`	`axis,`
`1570`	`1570`	`window,`
`1571`		`- lambda df: df.rolling(rolling_kwargs).mean(args, **kwargs),`
	`1571`	`+ lambda df: df.rolling(*rolling_kwargs).mean(args, **kwargs),`
`1572`	`1572`	`)`
`1573`	`1573`	`)`
`1574`	`1574`	`else:`
`1575`	`1575`	`return self.old_rolling_mean(axis, rolling_kwargs, args, *kwargs)`
`1576`	`1576`
`1577`	`1577`	`old_rolling_median = Fold.register(`
`1578`	`1578`	`lambda df, rolling_kwargs, **kwargs: pandas.DataFrame(`
`1579`		`- df.rolling(rolling_kwargs).median(*kwargs)`
	`1579`	`+ df.rolling(rolling_kwargs).median(kwargs)`
`1580`	`1580`	`)`
`1581`	`1581`	`)`
`1582`	`1582`
`@@ -1587,15 +1587,15 @@ def rolling_median(self, axis, rolling_kwargs, **kwargs):`
`1587`	`1587`	`if _can_use_cell_wise_window(center, window, win_type):`
`1588`	`1588`	`return self.__constructor__(`
`1589`	`1589`	`self._modin_frame.window(`
`1590`		`- axis, window, lambda df: df.rolling(rolling_kwargs).median(*kwargs)`
	`1590`	`+ axis, window, lambda df: df.rolling(rolling_kwargs).median(kwargs)`
`1591`	`1591`	`)`
`1592`	`1592`	`)`
`1593`	`1593`	`else:`
`1594`	`1594`	`return self.old_rolling_median(axis, rolling_kwargs, **kwargs)`
`1595`	`1595`
`1596`	`1596`	`old_rolling_var = Fold.register(`
`1597`	`1597`	`lambda df, rolling_kwargs, ddof, args, *kwargs: pandas.DataFrame(`
`1598`		`- df.rolling(rolling_kwargs).var(ddof=ddof, args, **kwargs)`
	`1598`	`+ df.rolling(*rolling_kwargs).var(ddof=ddof, args, **kwargs)`
`1599`	`1599`	`)`
`1600`	`1600`	`)`
`1601`	`1601`
`@@ -1608,7 +1608,7 @@ def rolling_var(self, axis, rolling_kwargs, ddof, args, *kwargs):`
`1608`	`1608`	`self._modin_frame.window(`
`1609`	`1609`	`axis,`
`1610`	`1610`	`window,`
`1611`		`- lambda df: df.rolling(*rolling_kwargs).var(`
	`1611`	`+ lambda df: df.rolling(**rolling_kwargs).var(`
`1612`	`1612`	`ddof=ddof, args, *kwargs`
`1613`	`1613`	`),`
`1614`	`1614`	`)`
`@@ -1618,7 +1618,7 @@ def rolling_var(self, axis, rolling_kwargs, ddof, args, *kwargs):`
`1618`	`1618`
`1619`	`1619`	`old_rolling_std = Fold.register(`
`1620`	`1620`	`lambda df, rolling_kwargs, ddof, args, *kwargs: pandas.DataFrame(`
`1621`		`- df.rolling(rolling_kwargs).std(ddof=ddof, args, **kwargs)`
	`1621`	`+ df.rolling(*rolling_kwargs).std(ddof=ddof, args, **kwargs)`
`1622`	`1622`	`)`
`1623`	`1623`	`)`
`1624`	`1624`
`@@ -1631,7 +1631,7 @@ def rolling_std(self, axis, rolling_kwargs, ddof, args, *kwargs):`
`1631`	`1631`	`self._modin_frame.window(`
`1632`	`1632`	`axis,`
`1633`	`1633`	`window,`
`1634`		`- lambda df: df.rolling(*rolling_kwargs).std(`
	`1634`	`+ lambda df: df.rolling(**rolling_kwargs).std(`
`1635`	`1635`	`ddof=ddof, args, *kwargs`
`1636`	`1636`	`),`
`1637`	`1637`	`)`
`@@ -1641,7 +1641,7 @@ def rolling_std(self, axis, rolling_kwargs, ddof, args, *kwargs):`
`1641`	`1641`
`1642`	`1642`	`old_rolling_min = Fold.register(`
`1643`	`1643`	`lambda df, rolling_kwargs, args, *kwargs: pandas.DataFrame(`
`1644`		`- df.rolling(rolling_kwargs).min(args, **kwargs)`
	`1644`	`+ df.rolling(*rolling_kwargs).min(args, **kwargs)`
`1645`	`1645`	`)`
`1646`	`1646`	`)`
`1647`	`1647`
`@@ -1654,15 +1654,15 @@ def rolling_min(self, axis, rolling_kwargs, args, *kwargs):`
`1654`	`1654`	`self._modin_frame.window(`
`1655`	`1655`	`axis,`
`1656`	`1656`	`window,`
`1657`		`- lambda df: df.rolling(rolling_kwargs).min(args, **kwargs),`
	`1657`	`+ lambda df: df.rolling(*rolling_kwargs).min(args, **kwargs),`
`1658`	`1658`	`)`
`1659`	`1659`	`)`
`1660`	`1660`	`else:`
`1661`	`1661`	`return self.old_rolling_min(axis, rolling_kwargs, args, *kwargs)`
`1662`	`1662`
`1663`	`1663`	`old_rolling_max = Fold.register(`
`1664`	`1664`	`lambda df, rolling_kwargs, args, *kwargs: pandas.DataFrame(`
`1665`		`- df.rolling(rolling_kwargs).max(args, **kwargs)`
	`1665`	`+ df.rolling(*rolling_kwargs).max(args, **kwargs)`
`1666`	`1666`	`)`
`1667`	`1667`	`)`
`1668`	`1668`
`@@ -1675,15 +1675,15 @@ def rolling_max(self, axis, rolling_kwargs, args, *kwargs):`
`1675`	`1675`	`self._modin_frame.window(`
`1676`	`1676`	`axis,`
`1677`	`1677`	`window,`
`1678`		`- lambda df: df.rolling(rolling_kwargs).max(args, **kwargs),`
	`1678`	`+ lambda df: df.rolling(*rolling_kwargs).max(args, **kwargs),`
`1679`	`1679`	`)`
`1680`	`1680`	`)`
`1681`	`1681`	`else:`
`1682`	`1682`	`return self.old_rolling_max(axis, rolling_kwargs, args, *kwargs)`
`1683`	`1683`
`1684`	`1684`	`old_rolling_skew = Fold.register(`
`1685`	`1685`	`lambda df, rolling_kwargs, **kwargs: pandas.DataFrame(`
`1686`		`- df.rolling(rolling_kwargs).skew(*kwargs)`
	`1686`	`+ df.rolling(rolling_kwargs).skew(kwargs)`
`1687`	`1687`	`)`
`1688`	`1688`	`)`
`1689`	`1689`
`@@ -1694,15 +1694,15 @@ def rolling_skew(self, axis, rolling_kwargs, **kwargs):`
`1694`	`1694`	`if _can_use_cell_wise_window(center, window, win_type):`
`1695`	`1695`	`return self.__constructor__(`
`1696`	`1696`	`self._modin_frame.window(`
`1697`		`- axis, window, lambda df: df.rolling(rolling_kwargs).skew(*kwargs)`
	`1697`	`+ axis, window, lambda df: df.rolling(rolling_kwargs).skew(kwargs)`
`1698`	`1698`	`)`
`1699`	`1699`	`)`
`1700`	`1700`	`else:`
`1701`	`1701`	`return self.old_rolling_skew(axis, rolling_kwargs, **kwargs)`
`1702`	`1702`
`1703`	`1703`	`old_rolling_kurt = Fold.register(`
`1704`	`1704`	`lambda df, rolling_kwargs, **kwargs: pandas.DataFrame(`
`1705`		`- df.rolling(rolling_kwargs).kurt(*kwargs)`
	`1705`	`+ df.rolling(rolling_kwargs).kurt(kwargs)`
`1706`	`1706`	`)`
`1707`	`1707`	`)`
`1708`	`1708`
`@@ -1713,15 +1713,15 @@ def rolling_kurt(self, axis, rolling_kwargs, **kwargs):`
`1713`	`1713`	`if _can_use_cell_wise_window(center, window, win_type):`
`1714`	`1714`	`return self.__constructor__(`
`1715`	`1715`	`self._modin_frame.window(`
`1716`		`- axis, window, lambda df: df.rolling(rolling_kwargs).kurt(*kwargs)`
	`1716`	`+ axis, window, lambda df: df.rolling(rolling_kwargs).kurt(kwargs)`
`1717`	`1717`	`)`
`1718`	`1718`	`)`
`1719`	`1719`	`else:`
`1720`	`1720`	`return self.old_rolling_kurt(axis, rolling_kwargs, **kwargs)`
`1721`	`1721`
`1722`	`1722`	`old_rolling_apply = Fold.register(`
`1723`	`1723`	`lambda df, rolling_kwargs, func, raw, engine, engine_kwargs, args, kwargs: pandas.DataFrame(`
`1724`		`- df.rolling(*rolling_kwargs).apply(`
	`1724`	`+ df.rolling(**rolling_kwargs).apply(`
`1725`	`1725`	`func=func,`
`1726`	`1726`	`raw=raw,`
`1727`	`1727`	`engine=engine,`
`@@ -1743,7 +1743,7 @@ def rolling_apply(`
`1743`	`1743`	`self._modin_frame.window(`
`1744`	`1744`	`axis,`
`1745`	`1745`	`window,`
`1746`		`- lambda df: df.rolling(*rolling_kwargs).apply(`
	`1746`	`+ lambda df: df.rolling(**rolling_kwargs).apply(`
`1747`	`1747`	`func=func,`
`1748`	`1748`	`raw=raw,`
`1749`	`1749`	`engine=engine,`
`@@ -1767,7 +1767,7 @@ def rolling_apply(`
`1767`	`1767`
`1768`	`1768`	`old_rolling_rank = Fold.register(`
`1769`	`1769`	`lambda df, rolling_kwargs, method, ascending, pct, numeric_only, **kwargs: pandas.DataFrame(`
`1770`		`- df.rolling(*rolling_kwargs).rank(`
	`1770`	`+ df.rolling(**rolling_kwargs).rank(`
`1771`	`1771`	`method=method,`
`1772`	`1772`	`ascending=ascending,`
`1773`	`1773`	`pct=pct,`
`@@ -1788,7 +1788,7 @@ def rolling_rank(`
`1788`	`1788`	`self._modin_frame.window(`
`1789`	`1789`	`axis,`
`1790`	`1790`	`window,`
`1791`		`- lambda df: df.rolling(*rolling_kwargs).rank(`
	`1791`	`+ lambda df: df.rolling(**rolling_kwargs).rank(`
`1792`	`1792`	`method=method,`
`1793`	`1793`	`ascending=ascending,`
`1794`	`1794`	`pct=pct,`
`@@ -1804,7 +1804,7 @@ def rolling_rank(`
`1804`	`1804`
`1805`	`1805`	`old_rolling_quantile = Fold.register(`
`1806`	`1806`	`lambda df, rolling_kwargs, quantile, interpolation, **kwargs: pandas.DataFrame(`
`1807`		`- df.rolling(*rolling_kwargs).quantile(`
	`1807`	`+ df.rolling(**rolling_kwargs).quantile(`
`1808`	`1808`	`quantile=quantile, interpolation=interpolation, **kwargs`
`1809`	`1809`	`)`
`1810`	`1810`	`)`
`@@ -1819,7 +1819,7 @@ def rolling_quantile(self, axis, rolling_kwargs, quantile, interpolation, **kwar`
`1819`	`1819`	`self._modin_frame.window(`
`1820`	`1820`	`axis,`
`1821`	`1821`	`window,`
`1822`		`- lambda df: df.rolling(*rolling_kwargs).quantile(`
	`1822`	`+ lambda df: df.rolling(**rolling_kwargs).quantile(`
`1823`	`1823`	`quantile=quantile, interpolation=interpolation, **kwargs`
`1824`	`1824`	`),`
`1825`	`1825`	`)`
`@@ -1831,7 +1831,7 @@ def rolling_quantile(self, axis, rolling_kwargs, quantile, interpolation, **kwar`
`1831`	`1831`
`1832`	`1832`	`old_rolling_corr = Fold.register(`
`1833`	`1833`	`lambda df, rolling_kwargs, other, pairwise, args, *kwargs: pandas.DataFrame(`
`1834`		`- df.rolling(*rolling_kwargs).corr(`
	`1834`	`+ df.rolling(**rolling_kwargs).corr(`
`1835`	`1835`	`other=other, pairwise=pairwise, args, *kwargs`
`1836`	`1836`	`)`
`1837`	`1837`	`)`
`@@ -1853,7 +1853,7 @@ def rolling_corr(self, axis, rolling_kwargs, other, pairwise, args, *kwargs):`
`1853`	`1853`	`self._modin_frame.window(`
`1854`	`1854`	`axis,`
`1855`	`1855`	`window,`
`1856`		`- lambda df: df.rolling(*rolling_kwargs).corr(`
	`1856`	`+ lambda df: df.rolling(**rolling_kwargs).corr(`
`1857`	`1857`	`other=other, pairwise=pairwise, args, *kwargs`
`1858`	`1858`	`),`
`1859`	`1859`	`)`
`@@ -1865,7 +1865,7 @@ def rolling_corr(self, axis, rolling_kwargs, other, pairwise, args, *kwargs):`
`1865`	`1865`
`1866`	`1866`	`old_rolling_cov = Fold.register(`
`1867`	`1867`	`lambda df, rolling_kwargs, other, pairwise, ddof, **kwargs: pandas.DataFrame(`
`1868`		`- df.rolling(*rolling_kwargs).cov(`
	`1868`	`+ df.rolling(**rolling_kwargs).cov(`
`1869`	`1869`	`other=other, pairwise=pairwise, ddof=ddof, **kwargs`
`1870`	`1870`	`)`
`1871`	`1871`	`)`
`@@ -1891,7 +1891,7 @@ def rolling_cov(self, axis, rolling_kwargs, other, pairwise, ddof, **kwargs):`
`1891`	`1891`	`self._modin_frame.window(`
`1892`	`1892`	`axis,`
`1893`	`1893`	`window,`
`1894`		`- lambda df: df.rolling(*rolling_kwargs).cov(`
	`1894`	`+ lambda df: df.rolling(**rolling_kwargs).cov(`
`1895`	`1895`	`other=other, pairwise=pairwise, **kwargs`
`1896`	`1896`	`),`
`1897`	`1897`	`)`
`@@ -1907,7 +1907,7 @@ def rolling_aggregate(self, axis, rolling_kwargs, func, args, *kwargs):`
`1907`	`1907`	`new_modin_frame = self._modin_frame.apply_full_axis(`
`1908`	`1908`	`axis,`
`1909`	`1909`	`lambda df: pandas.DataFrame(`
`1910`		`- df.rolling(rolling_kwargs).aggregate(func=func, args, **kwargs)`
	`1910`	`+ df.rolling(*rolling_kwargs).aggregate(func=func, args, **kwargs)`
`1911`	`1911`	`),`
`1912`	`1912`	`new_index=self.index,`
`1913`	`1913`	`)`