Skip to content

Commit 73f5680

Browse files
sfc-gh-jkewsfc-gh-jkew
authored
Merge branch 'main' into jkew/apply.axis.1.row.index.0
2 parents 2727063 + 3b3062a commit 73f5680

File tree

3 files changed

+414
-0
lines changed

3 files changed

+414
-0
lines changed

‎CHANGELOG.md‎

Lines changed: 9 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -84,6 +84,15 @@
8484
- `dt.month_name`
8585
- `dt.day_name`
8686
- `dt.strftime`
87+
- `rolling.min`
88+
- `rolling.max`
89+
- `rolling.count`
90+
- `rolling.sum`
91+
- `rolling.mean`
92+
- `rolling.std`
93+
- `rolling.var`
94+
- `rolling.sem`
95+
- `rolling.corr`
8796
- Make faster pandas disabled by default (opt-in instead of opt-out).
8897

8998
## 1.42.0 (2025-10-28)

‎src/snowflake/snowpark/modin/plugin/compiler/snowflake_query_compiler.py‎

Lines changed: 316 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -16909,6 +16909,35 @@ def rolling_count(
1690916909
numeric_only: bool = False,
1691016910
*args: Any,
1691116911
**kwargs: Any,
16912+
) -> "SnowflakeQueryCompiler":
16913+
"""
16914+
Wrapper around _rolling_count_internal to be supported in faster pandas.
16915+
"""
16916+
relaxed_query_compiler = None
16917+
if self._relaxed_query_compiler is not None:
16918+
relaxed_query_compiler = (
16919+
self._relaxed_query_compiler._rolling_count_internal(
16920+
fold_axis=fold_axis,
16921+
rolling_kwargs=rolling_kwargs,
16922+
numeric_only=numeric_only,
16923+
**kwargs,
16924+
)
16925+
)
16926+
qc = self._rolling_count_internal(
16927+
fold_axis=fold_axis,
16928+
rolling_kwargs=rolling_kwargs,
16929+
numeric_only=numeric_only,
16930+
**kwargs,
16931+
)
16932+
return self._maybe_set_relaxed_qc(qc, relaxed_query_compiler)
16933+
16934+
def _rolling_count_internal(
16935+
self,
16936+
fold_axis: Union[int, str],
16937+
rolling_kwargs: dict,
16938+
numeric_only: bool = False,
16939+
*args: Any,
16940+
**kwargs: Any,
1691216941
) -> "SnowflakeQueryCompiler":
1691316942
return self._window_agg(
1691416943
window_func=WindowFunction.ROLLING,
@@ -16926,6 +16955,39 @@ def rolling_sum(
1692616955
engine_kwargs: Optional[dict[str, bool]] = None,
1692716956
*args: Any,
1692816957
**kwargs: Any,
16958+
) -> "SnowflakeQueryCompiler":
16959+
"""
16960+
Wrapper around _rolling_sum_internal to be supported in faster pandas.
16961+
"""
16962+
relaxed_query_compiler = None
16963+
if self._relaxed_query_compiler is not None:
16964+
relaxed_query_compiler = self._relaxed_query_compiler._rolling_sum_internal(
16965+
fold_axis=fold_axis,
16966+
rolling_kwargs=rolling_kwargs,
16967+
numeric_only=numeric_only,
16968+
engine=engine,
16969+
engine_kwargs=engine_kwargs,
16970+
**kwargs,
16971+
)
16972+
qc = self._rolling_sum_internal(
16973+
fold_axis=fold_axis,
16974+
rolling_kwargs=rolling_kwargs,
16975+
numeric_only=numeric_only,
16976+
engine=engine,
16977+
engine_kwargs=engine_kwargs,
16978+
**kwargs,
16979+
)
16980+
return self._maybe_set_relaxed_qc(qc, relaxed_query_compiler)
16981+
16982+
def _rolling_sum_internal(
16983+
self,
16984+
fold_axis: Union[int, str],
16985+
rolling_kwargs: dict,
16986+
numeric_only: bool = False,
16987+
engine: Optional[Literal["cython", "numba"]] = None,
16988+
engine_kwargs: Optional[dict[str, bool]] = None,
16989+
*args: Any,
16990+
**kwargs: Any,
1692916991
) -> "SnowflakeQueryCompiler":
1693016992
WarningMessage.warning_if_engine_args_is_set(
1693116993
"rolling_sum", engine, engine_kwargs
@@ -16946,6 +17008,41 @@ def rolling_mean(
1694617008
engine_kwargs: Optional[dict[str, bool]] = None,
1694717009
*args: Any,
1694817010
**kwargs: Any,
17011+
) -> "SnowflakeQueryCompiler":
17012+
"""
17013+
Wrapper around _rolling_mean_internal to be supported in faster pandas.
17014+
"""
17015+
relaxed_query_compiler = None
17016+
if self._relaxed_query_compiler is not None:
17017+
relaxed_query_compiler = (
17018+
self._relaxed_query_compiler._rolling_mean_internal(
17019+
fold_axis=fold_axis,
17020+
rolling_kwargs=rolling_kwargs,
17021+
numeric_only=numeric_only,
17022+
engine=engine,
17023+
engine_kwargs=engine_kwargs,
17024+
**kwargs,
17025+
)
17026+
)
17027+
qc = self._rolling_mean_internal(
17028+
fold_axis=fold_axis,
17029+
rolling_kwargs=rolling_kwargs,
17030+
numeric_only=numeric_only,
17031+
engine=engine,
17032+
engine_kwargs=engine_kwargs,
17033+
**kwargs,
17034+
)
17035+
return self._maybe_set_relaxed_qc(qc, relaxed_query_compiler)
17036+
17037+
def _rolling_mean_internal(
17038+
self,
17039+
fold_axis: Union[int, str],
17040+
rolling_kwargs: dict,
17041+
numeric_only: bool = False,
17042+
engine: Optional[Literal["cython", "numba"]] = None,
17043+
engine_kwargs: Optional[dict[str, bool]] = None,
17044+
*args: Any,
17045+
**kwargs: Any,
1694917046
) -> "SnowflakeQueryCompiler":
1695017047
WarningMessage.warning_if_engine_args_is_set(
1695117048
"rolling_mean", engine, engine_kwargs
@@ -16978,6 +17075,42 @@ def rolling_var(
1697817075
engine_kwargs: Optional[dict[str, bool]] = None,
1697917076
*args: Any,
1698017077
**kwargs: Any,
17078+
) -> "SnowflakeQueryCompiler":
17079+
"""
17080+
Wrapper around _rolling_var_internal to be supported in faster pandas.
17081+
"""
17082+
relaxed_query_compiler = None
17083+
if self._relaxed_query_compiler is not None:
17084+
relaxed_query_compiler = self._relaxed_query_compiler._rolling_var_internal(
17085+
fold_axis=fold_axis,
17086+
rolling_kwargs=rolling_kwargs,
17087+
ddof=ddof,
17088+
numeric_only=numeric_only,
17089+
engine=engine,
17090+
engine_kwargs=engine_kwargs,
17091+
**kwargs,
17092+
)
17093+
qc = self._rolling_var_internal(
17094+
fold_axis=fold_axis,
17095+
rolling_kwargs=rolling_kwargs,
17096+
ddof=ddof,
17097+
numeric_only=numeric_only,
17098+
engine=engine,
17099+
engine_kwargs=engine_kwargs,
17100+
**kwargs,
17101+
)
17102+
return self._maybe_set_relaxed_qc(qc, relaxed_query_compiler)
17103+
17104+
def _rolling_var_internal(
17105+
self,
17106+
fold_axis: Union[int, str],
17107+
rolling_kwargs: dict,
17108+
ddof: int = 1,
17109+
numeric_only: bool = False,
17110+
engine: Optional[Literal["cython", "numba"]] = None,
17111+
engine_kwargs: Optional[dict[str, bool]] = None,
17112+
*args: Any,
17113+
**kwargs: Any,
1698117114
) -> "SnowflakeQueryCompiler":
1698217115
WarningMessage.warning_if_engine_args_is_set(
1698317116
"rolling_var", engine, engine_kwargs
@@ -16999,6 +17132,42 @@ def rolling_std(
1699917132
engine_kwargs: Optional[dict[str, bool]] = None,
1700017133
*args: Any,
1700117134
**kwargs: Any,
17135+
) -> "SnowflakeQueryCompiler":
17136+
"""
17137+
Wrapper around _rolling_std_internal to be supported in faster pandas.
17138+
"""
17139+
relaxed_query_compiler = None
17140+
if self._relaxed_query_compiler is not None:
17141+
relaxed_query_compiler = self._relaxed_query_compiler._rolling_std_internal(
17142+
fold_axis=fold_axis,
17143+
rolling_kwargs=rolling_kwargs,
17144+
ddof=ddof,
17145+
numeric_only=numeric_only,
17146+
engine=engine,
17147+
engine_kwargs=engine_kwargs,
17148+
**kwargs,
17149+
)
17150+
qc = self._rolling_std_internal(
17151+
fold_axis=fold_axis,
17152+
rolling_kwargs=rolling_kwargs,
17153+
ddof=ddof,
17154+
numeric_only=numeric_only,
17155+
engine=engine,
17156+
engine_kwargs=engine_kwargs,
17157+
**kwargs,
17158+
)
17159+
return self._maybe_set_relaxed_qc(qc, relaxed_query_compiler)
17160+
17161+
def _rolling_std_internal(
17162+
self,
17163+
fold_axis: Union[int, str],
17164+
rolling_kwargs: dict,
17165+
ddof: int = 1,
17166+
numeric_only: bool = False,
17167+
engine: Optional[Literal["cython", "numba"]] = None,
17168+
engine_kwargs: Optional[dict[str, bool]] = None,
17169+
*args: Any,
17170+
**kwargs: Any,
1700217171
) -> "SnowflakeQueryCompiler":
1700317172
WarningMessage.warning_if_engine_args_is_set(
1700417173
"rolling_var", engine, engine_kwargs
@@ -17019,6 +17188,39 @@ def rolling_min(
1701917188
engine_kwargs: Optional[dict[str, bool]] = None,
1702017189
*args: Any,
1702117190
**kwargs: Any,
17191+
) -> "SnowflakeQueryCompiler":
17192+
"""
17193+
Wrapper around _rolling_min_internal to be supported in faster pandas.
17194+
"""
17195+
relaxed_query_compiler = None
17196+
if self._relaxed_query_compiler is not None:
17197+
relaxed_query_compiler = self._relaxed_query_compiler._rolling_min_internal(
17198+
fold_axis=fold_axis,
17199+
rolling_kwargs=rolling_kwargs,
17200+
numeric_only=numeric_only,
17201+
engine=engine,
17202+
engine_kwargs=engine_kwargs,
17203+
**kwargs,
17204+
)
17205+
qc = self._rolling_min_internal(
17206+
fold_axis=fold_axis,
17207+
rolling_kwargs=rolling_kwargs,
17208+
numeric_only=numeric_only,
17209+
engine=engine,
17210+
engine_kwargs=engine_kwargs,
17211+
**kwargs,
17212+
)
17213+
return self._maybe_set_relaxed_qc(qc, relaxed_query_compiler)
17214+
17215+
def _rolling_min_internal(
17216+
self,
17217+
fold_axis: Union[int, str],
17218+
rolling_kwargs: dict,
17219+
numeric_only: bool = False,
17220+
engine: Optional[Literal["cython", "numba"]] = None,
17221+
engine_kwargs: Optional[dict[str, bool]] = None,
17222+
*args: Any,
17223+
**kwargs: Any,
1702217224
) -> "SnowflakeQueryCompiler":
1702317225
WarningMessage.warning_if_engine_args_is_set(
1702417226
"rolling_min", engine, engine_kwargs
@@ -17039,6 +17241,39 @@ def rolling_max(
1703917241
engine_kwargs: Optional[dict[str, bool]] = None,
1704017242
*args: Any,
1704117243
**kwargs: Any,
17244+
) -> "SnowflakeQueryCompiler":
17245+
"""
17246+
Wrapper around _rolling_max_internal to be supported in faster pandas.
17247+
"""
17248+
relaxed_query_compiler = None
17249+
if self._relaxed_query_compiler is not None:
17250+
relaxed_query_compiler = self._relaxed_query_compiler._rolling_max_internal(
17251+
fold_axis=fold_axis,
17252+
rolling_kwargs=rolling_kwargs,
17253+
numeric_only=numeric_only,
17254+
engine=engine,
17255+
engine_kwargs=engine_kwargs,
17256+
**kwargs,
17257+
)
17258+
qc = self._rolling_max_internal(
17259+
fold_axis=fold_axis,
17260+
rolling_kwargs=rolling_kwargs,
17261+
numeric_only=numeric_only,
17262+
engine=engine,
17263+
engine_kwargs=engine_kwargs,
17264+
**kwargs,
17265+
)
17266+
return self._maybe_set_relaxed_qc(qc, relaxed_query_compiler)
17267+
17268+
def _rolling_max_internal(
17269+
self,
17270+
fold_axis: Union[int, str],
17271+
rolling_kwargs: dict,
17272+
numeric_only: bool = False,
17273+
engine: Optional[Literal["cython", "numba"]] = None,
17274+
engine_kwargs: Optional[dict[str, bool]] = None,
17275+
*args: Any,
17276+
**kwargs: Any,
1704217277
) -> "SnowflakeQueryCompiler":
1704317278
WarningMessage.warning_if_engine_args_is_set(
1704417279
"rolling_max", engine, engine_kwargs
@@ -17059,6 +17294,57 @@ def rolling_corr(
1705917294
ddof: int = 1,
1706017295
numeric_only: bool = False,
1706117296
**kwargs: Any,
17297+
) -> "SnowflakeQueryCompiler":
17298+
"""
17299+
Wrapper around _rolling_corr_internal to be supported in faster pandas.
17300+
"""
17301+
relaxed_query_compiler = None
17302+
if self._relaxed_query_compiler is not None and (
17303+
not isinstance(other, (Series, DataFrame))
17304+
or other._query_compiler._relaxed_query_compiler is not None
17305+
):
17306+
if isinstance(other, (Series, DataFrame)):
17307+
if isinstance(other, Series):
17308+
new_other = Series(
17309+
query_compiler=other._query_compiler._relaxed_query_compiler
17310+
)
17311+
else: # DataFrame
17312+
new_other = DataFrame(
17313+
query_compiler=other._query_compiler._relaxed_query_compiler
17314+
)
17315+
else:
17316+
new_other = other
17317+
relaxed_query_compiler = (
17318+
self._relaxed_query_compiler._rolling_corr_internal(
17319+
fold_axis=fold_axis,
17320+
rolling_kwargs=rolling_kwargs,
17321+
other=new_other,
17322+
pairwise=pairwise,
17323+
ddof=ddof,
17324+
numeric_only=numeric_only,
17325+
**kwargs,
17326+
)
17327+
)
17328+
qc = self._rolling_corr_internal(
17329+
fold_axis=fold_axis,
17330+
rolling_kwargs=rolling_kwargs,
17331+
other=other,
17332+
pairwise=pairwise,
17333+
ddof=ddof,
17334+
numeric_only=numeric_only,
17335+
**kwargs,
17336+
)
17337+
return self._maybe_set_relaxed_qc(qc, relaxed_query_compiler)
17338+
17339+
def _rolling_corr_internal(
17340+
self,
17341+
fold_axis: Union[int, str],
17342+
rolling_kwargs: dict,
17343+
other: Optional[SnowparkDataFrame] = None,
17344+
pairwise: Optional[bool] = None,
17345+
ddof: int = 1,
17346+
numeric_only: bool = False,
17347+
**kwargs: Any,
1706217348
) -> "SnowflakeQueryCompiler":
1706317349
if other is None:
1706417350
ErrorMessage.parameter_not_implemented_error(
@@ -17149,6 +17435,36 @@ def rolling_sem(
1714917435
numeric_only: bool = False,
1715017436
*args: Any,
1715117437
**kwargs: Any,
17438+
) -> "SnowflakeQueryCompiler":
17439+
"""
17440+
Wrapper around _rolling_sem_internal to be supported in faster pandas.
17441+
"""
17442+
relaxed_query_compiler = None
17443+
if self._relaxed_query_compiler is not None:
17444+
relaxed_query_compiler = self._relaxed_query_compiler._rolling_sem_internal(
17445+
fold_axis=fold_axis,
17446+
rolling_kwargs=rolling_kwargs,
17447+
ddof=ddof,
17448+
numeric_only=numeric_only,
17449+
**kwargs,
17450+
)
17451+
qc = self._rolling_sem_internal(
17452+
fold_axis=fold_axis,
17453+
rolling_kwargs=rolling_kwargs,
17454+
ddof=ddof,
17455+
numeric_only=numeric_only,
17456+
**kwargs,
17457+
)
17458+
return self._maybe_set_relaxed_qc(qc, relaxed_query_compiler)
17459+
17460+
def _rolling_sem_internal(
17461+
self,
17462+
fold_axis: Union[int, str],
17463+
rolling_kwargs: dict,
17464+
ddof: int = 1,
17465+
numeric_only: bool = False,
17466+
*args: Any,
17467+
**kwargs: Any,
1715217468
) -> "SnowflakeQueryCompiler":
1715317469
return self._window_agg(
1715417470
window_func=WindowFunction.ROLLING,

0 commit comments

Comments
 (0)