maxframe 2.2.0__cp312-cp312-macosx_10_9_universal2.whl

maxframe/codegen/spe/dataframe/tests/test_sort.py

@@ -0,0 +1,179 @@
+# Copyright 1999-2025 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import numpy as np
+import pandas as pd
+import pytest
+
+from ..... import dataframe as md
+from ....core import EngineAcceptance
+from ...core import SPECodeContext
+from ..sort import DataFrameSortIndexAdapter, DataFrameSortValuesAdapter
+
+
+@pytest.fixture
+def multi_index():
+    arrays = [
+        ["a1", "a2", "a3"],
+        ["b1", "b2", "b3"],
+        ["c1", "c2", "c3"],
+        ["d1", "d2", "d3"],
+        ["e1", "e2", "e3"],
+    ]
+    return pd.MultiIndex.from_arrays(
+        arrays, names=("idx_a", "idx_b", "idx_c", "idx_d", "idx_e")
+    )
+
+
+@pytest.fixture
+def df1():
+    return md.DataFrame(
+        np.random.randn(6, 4),
+        index=md.Index(["1", "2", "3", "4", "5", "6"], name="test_idx"),
+        columns=list("ABCD"),
+    )
+
+
+@pytest.fixture
+def df2(multi_index):
+    return md.DataFrame(
+        np.random.randn(3, 4),
+        index=multi_index,
+        columns=list("ABCD"),
+    )
+
+
+@pytest.fixture
+def s1():
+    return md.Series([1, 2, 3], index=list("abc"))
+
+
+@pytest.fixture
+def s2(multi_index):
+    return md.Series([1, 2, 3], index=multi_index)
+
+
+def test_series_sort_values(s1):
+    s = s1.sort_values(na_position="last", ascending=False, inplace=False)
+    adapter = DataFrameSortValuesAdapter()
+    context = SPECodeContext()
+    assert adapter.accepts(s.op) == EngineAcceptance.ACCEPT
+    results = adapter.generate_code(s.op, context)
+    expected_results = [
+        "var_1 = var_0.sort_values(axis=0, ascending=False, inplace=False,"
+        " na_position='last', ignore_index=False)"
+    ]
+    assert results == expected_results
+
+
+def test_dataframe_sort_by_values_single_column(df1):
+    s = df1.sort_values(by="A", na_position="first", ascending=True)
+    adapter = DataFrameSortValuesAdapter()
+    context = SPECodeContext()
+    assert adapter.accepts(s.op) == EngineAcceptance.ACCEPT
+    results = adapter.generate_code(s.op, context)
+    expected_results = [
+        "var_1 = var_0.sort_values(axis=0, ascending=True, inplace=False,"
+        " na_position='first', ignore_index=False, by=['A'])"
+    ]
+    assert results == expected_results
+
+
+def test_dataframe_sort_by_values_multi_columns(df1):
+    df1.sort_values(by=["A", "B"], inplace=True)
+    adapter = DataFrameSortValuesAdapter()
+    context = SPECodeContext()
+    assert adapter.accepts(df1.op) == EngineAcceptance.ACCEPT
+    results = adapter.generate_code(df1.op, context)
+    expected_results = [
+        "var_1 = var_0.sort_values(axis=0, ascending=True, inplace=True,"
+        " na_position='last', ignore_index=False, by=['A', 'B'])"
+    ]
+    assert results == expected_results
+
+
+def test_series_sort_index_by_single(s2):
+    s = s2.sort_index(
+        level=1, na_position="first", sort_remaining=False, ignore_index=True
+    )
+    adapter = DataFrameSortIndexAdapter()
+    context = SPECodeContext()
+    assert adapter.accepts(s.op) == EngineAcceptance.ACCEPT
+    results = adapter.generate_code(s.op, context)
+    expected_results = [
+        "var_1 = var_0.sort_index(axis=0, ascending=True, inplace=False,"
+        " na_position='first', ignore_index=True, level=[1], sort_remaining=False)"
+    ]
+    assert results == expected_results
+
+
+def test_series_sort_index_by_multiple(s2):
+    s = s2.sort_index(level=[1, "idx_d"])
+    adapter = DataFrameSortIndexAdapter()
+    context = SPECodeContext()
+    assert adapter.accepts(s.op) == EngineAcceptance.ACCEPT
+    results = adapter.generate_code(s.op, context)
+    expected_results = [
+        "var_1 = var_0.sort_index(axis=0, ascending=True, inplace=False,"
+        " na_position='last', ignore_index=False, level=[1, 'idx_d'],"
+        " sort_remaining=True)"
+    ]
+    assert results == expected_results
+
+
+def test_dataframe_sort_index_by_single(df2):
+    s = df2.sort_index(level="idx_b", na_position="first")
+    adapter = DataFrameSortIndexAdapter()
+    context = SPECodeContext()
+    assert adapter.accepts(s.op) == EngineAcceptance.ACCEPT
+    results = adapter.generate_code(s.op, context)
+    expected_results = [
+        "var_1 = var_0.sort_index(axis=0, ascending=True, inplace=False,"
+        " na_position='first', ignore_index=False, level=['idx_b'],"
+        " sort_remaining=True)"
+    ]
+    assert results == expected_results
+
+
+def test_dataframe_sort_index_by_all(df2):
+    s = df2.sort_index()
+    adapter = DataFrameSortIndexAdapter()
+    context = SPECodeContext()
+    assert adapter.accepts(s.op) == EngineAcceptance.ACCEPT
+    results = adapter.generate_code(s.op, context)
+    expected_results = [
+        "var_1 = var_0.sort_index(axis=0, ascending=True, inplace=False,"
+        " na_position='last', ignore_index=False, level=None, sort_remaining=True)"
+    ]
+    assert results == expected_results
+
+
+def test_dataframe_nlargest(df1):
+    df = df1.nlargest(10, "A", keep="last")
+    adapter = DataFrameSortValuesAdapter()
+    context = SPECodeContext()
+    assert adapter.accepts(df.op) == EngineAcceptance.ACCEPT
+    results = adapter.generate_code(df.op, context)
+    expected_results = ["var_1 = var_0.nlargest(10, keep='last', columns='A')"]
+    assert results == expected_results
+
+
+def test_series_nsmallest(s2):
+    s = s2.nsmallest(10, keep="last")
+    adapter = DataFrameSortValuesAdapter()
+    context = SPECodeContext()
+    assert adapter.accepts(s.op) == EngineAcceptance.ACCEPT
+    results = adapter.generate_code(s.op, context)
+    expected_results = ["var_1 = var_0.nsmallest(10, keep='last')"]
+    assert results == expected_results

maxframe/codegen/spe/dataframe/tests/test_statistics.py

@@ -0,0 +1,70 @@
+# Copyright 1999-2025 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import numpy as np
+import pytest
+
+from ..... import dataframe as md
+from ....core import EngineAcceptance
+from ...core import SPECodeContext
+from ..statistics import DataFrameCorrAdapter, DataFrameQuantileAdapter
+
+
+@pytest.fixture
+def df1():
+    return md.DataFrame(
+        np.random.randn(6, 4),
+        index=md.Index(["1", "2", "3", "4", "5", "6"], name="test_idx"),
+        columns=list("ABCD"),
+    )
+
+
+@pytest.fixture
+def df2():
+    return md.DataFrame(
+        np.random.randn(6, 4),
+        index=md.Index(["6", "5", "4", "4", "5", "6"], name="test_idx"),
+        columns=list("ABCD"),
+    )
+
+
+def test_corr(df1, df2):
+    adapter = DataFrameCorrAdapter()
+    context = SPECodeContext()
+
+    v1 = df1.corr(method="pearson")
+    assert adapter.accepts(v1.op) == EngineAcceptance.ACCEPT
+    results = adapter.generate_code(v1.op, context)
+    expected_results = ["var_1 = var_0.corr(method='pearson', min_periods=1)"]
+    assert results == expected_results
+
+    v2 = df1.corrwith(df2, method="pearson")
+    assert adapter.accepts(v2.op) == EngineAcceptance.ACCEPT
+    results = adapter.generate_code(v2.op, context)
+    expected_results = [
+        "var_2 = var_0.corrwith(var_3, axis=0, drop=False, method='pearson')"
+    ]
+    assert results == expected_results
+
+
+def test_quantile(df1):
+    adapter = DataFrameQuantileAdapter()
+    context = SPECodeContext()
+    v1 = df1.quantile(q=0.75)
+    assert adapter.accepts(v1.op) == EngineAcceptance.ACCEPT
+    results = adapter.generate_code(v1.op, context)
+    expected_results = [
+        "var_1 = var_0.quantile(q=0.75, axis=0, numeric_only=True, interpolation='linear')"
+    ]
+    assert results == expected_results

maxframe/codegen/spe/dataframe/tests/test_tseries.py

@@ -0,0 +1,29 @@
+# Copyright 1999-2025 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from ..... import dataframe as md
+from ...core import SPECodeContext
+from ..tseries import DataFrameToDatetimeAdapter
+
+
+def test_to_datetime():
+    v0 = md.DataFrame([["2023-07-27 14:58:12.1234"]], columns=["dt"], chunk_size=1)
+    v1 = md.to_datetime(v0.dt, format="%Y-%M-%d %h:%m:%s.%f")
+    context = SPECodeContext()
+    results = DataFrameToDatetimeAdapter().generate_code(v1.op, context)
+    assert results[0] == (
+        "var_1 = pd.to_datetime(var_0, errors='raise', dayfirst=False, "
+        "yearfirst=False, format='%Y-%M-%d %h:%m:%s.%f', exact=True, "
+        "infer_datetime_format=False, origin='unix', cache=True)"
+    )

maxframe/codegen/spe/dataframe/tests/test_value_counts.py

@@ -0,0 +1,60 @@
+# Copyright 1999-2025 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import pytest
+
+from ..... import dataframe as md
+from ...core import SPECodeContext
+from ..value_counts import DataFrameValueCountsAdapter
+
+
+@pytest.fixture
+def s1():
+    return md.Series([1, 2, 3], index=list("abc"))
+
+
+def test_value_counts_drop_na(s1):
+    s = s1.value_counts(dropna=True)
+    adapter = DataFrameValueCountsAdapter()
+    context = SPECodeContext()
+    results = adapter.generate_code(s.op, context)
+    expected_results = [
+        "var_1 = var_0.value_counts("
+        "ascending=False, bins=None, dropna=True, normalize=False, sort=True)"
+    ]
+    assert results == expected_results
+
+
+def test_value_counts_asc_order(s1):
+    s = s1.value_counts(dropna=False, sort=True, ascending=True)
+    adapter = DataFrameValueCountsAdapter()
+    context = SPECodeContext()
+    results = adapter.generate_code(s.op, context)
+    expected_results = [
+        "var_1 = var_0.value_counts("
+        "ascending=True, bins=None, dropna=False, normalize=False, sort=True)"
+    ]
+    assert results == expected_results
+
+
+def test_value_counts_normalize(s1):
+    s = s1.value_counts(normalize=True)
+    adapter = DataFrameValueCountsAdapter()
+    context = SPECodeContext()
+    results = adapter.generate_code(s.op, context)
+    expected_results = [
+        "var_1 = var_0.value_counts("
+        "ascending=False, bins=None, dropna=True, normalize=True, sort=True)"
+    ]
+    assert results == expected_results

maxframe/codegen/spe/dataframe/tests/test_window.py

@@ -0,0 +1,69 @@
+# Copyright 1999-2025 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import numpy as np
+import pytest
+
+from ..... import dataframe as md
+from ....core import EngineAcceptance
+from ...core import SPECodeContext
+from ..window import (
+    DataFrameEwmAggAdapter,
+    DataFrameExpandingAggAdapter,
+    DataFrameRollingAggAdapter,
+)
+
+
+@pytest.fixture
+def df1():
+    return md.DataFrame(
+        np.random.randn(6, 4),
+        index=md.Index(["1", "2", "3", "4", "5", "6"], name="test_idx"),
+        columns=list("ABCD"),
+    )
+
+
+def test_expanding_agg(df1):
+    adapter = DataFrameExpandingAggAdapter()
+    context = SPECodeContext()
+    v1 = df1.expanding(1).sum()
+    assert adapter.accepts(v1.op) == EngineAcceptance.ACCEPT
+    results = adapter.generate_code(v1.op, context)
+    expected_results = ["var_1 = var_0.expanding(min_periods=1, axis=0).sum()"]
+    assert results == expected_results
+
+
+def test_ewm_agg(df1):
+    adapter = DataFrameEwmAggAdapter()
+    context = SPECodeContext()
+    v1 = df1.ewm(alpha=0.5, adjust=False).mean()
+    assert adapter.accepts(v1.op) == EngineAcceptance.ACCEPT
+    results = adapter.generate_code(v1.op, context)
+    expected_results = [
+        "var_1 = var_0.rolling(alpha=0.5, min_periods=1, adjust=False, axis=0, "
+        "ignore_na=False).mean()"
+    ]
+    assert results == expected_results
+
+
+def test_rolling_agg(df1):
+    adapter = DataFrameRollingAggAdapter()
+    context = SPECodeContext()
+    v1 = df1.rolling(5, min_periods=1).mean()
+    assert adapter.accepts(v1.op) == EngineAcceptance.ACCEPT
+    results = adapter.generate_code(v1.op, context)
+    expected_results = [
+        "var_1 = var_0.rolling(5, min_periods=1, center=False, axis=0).mean()"
+    ]
+    assert results == expected_results

maxframe/codegen/spe/dataframe/tseries.py

@@ -0,0 +1,46 @@
+# Copyright 1999-2025 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import List
+
+from ....dataframe.tseries.to_datetime import DataFrameToDatetime
+from ....utils import no_default
+from ..core import SPECodeContext, SPEOperatorAdapter, register_op_adapter
+
+
+@register_op_adapter(DataFrameToDatetime)
+class DataFrameToDatetimeAdapter(SPEOperatorAdapter):
+    def generate_code(
+        self, op: DataFrameToDatetime, context: SPECodeContext
+    ) -> List[str]:
+        context.register_import("pandas", "pd")
+
+        inst_var_name = context.get_input_tileable_variable(op.inputs[0])
+        res_var_name = context.get_output_tileable_variable(op.outputs[0])
+        raw_kw = dict(
+            errors=op.errors,
+            dayfirst=op.dayfirst,
+            yearfirst=op.yearfirst,
+            utc=op.utc,
+            format=op.format,
+            exact=op.exact,
+            unit=op.unit,
+            infer_datetime_format=op.infer_datetime_format,
+            origin=op.origin,
+            cache=op.cache,
+        )
+        kw = {k: v for k, v in raw_kw.items() if v is not None and v != no_default}
+        args_list = self._translate_call_args(context, **kw)
+        args = ", ".join([inst_var_name] + args_list)
+        return [f"{res_var_name} = pd.to_datetime({args})"]

maxframe/codegen/spe/dataframe/udf.py

@@ -0,0 +1,62 @@
+# Copyright 1999-2025 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import hashlib
+from typing import TYPE_CHECKING, Callable, List, Optional
+
+from odps import ODPS
+from pandas.core.common import get_callable_name
+
+from ....serialization.serializables import FieldTypes, ListField, StringField
+from ....udf import PythonPackOptions
+from ...core import AbstractUDF, UserCodeMixin
+
+if TYPE_CHECKING:
+    from odpsctx import ODPSSessionContext
+
+
+class SpeUDF(AbstractUDF, UserCodeMixin):
+    _name: str = StringField("name")
+    encoded_content: List[str] = ListField("encoded_content", FieldTypes.string)
+
+    def __init__(self, func: Optional[Callable] = None, **kwargs):
+        if func is not None:
+            kwargs["encoded_content"] = encoded_content = [
+                self.generate_pickled_codes(func)
+            ]
+            content_str = "\n".join(encoded_content)
+            kwargs["_name"] = (
+                f"user_udf_{get_callable_name(func).replace('<lambda>', 'lambda')}_"
+                f"{hashlib.md5(content_str.encode('utf-8')).hexdigest()}"
+            )
+        super().__init__(**kwargs)
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    def unregister(self, odps: ODPS):
+        # Running in SPE, do nothing
+        pass
+
+    def register(self, odps: ODPS, overwrite: bool = False):
+        # Running in SPE, do nothing
+        pass
+
+    def collect_pythonpack(self) -> List[PythonPackOptions]:
+        return []
+
+    def load_pythonpack_resources(self, odps_ctx: "ODPSSessionContext") -> None:
+        # Running in SPE, do nothing
+        pass

maxframe/codegen/spe/dataframe/value_counts.py

@@ -0,0 +1,31 @@
+# Copyright 1999-2025 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import List
+
+from ....dataframe.misc.value_counts import DataFrameValueCounts
+from ..core import SPECodeContext, SPEOperatorAdapter, register_op_adapter
+
+
+@register_op_adapter(DataFrameValueCounts)
+class DataFrameValueCountsAdapter(SPEOperatorAdapter):
+    def generate_code(
+        self, op: DataFrameValueCounts, context: SPECodeContext
+    ) -> List[str]:
+        input_var_name = context.get_input_tileable_variable(op.inputs[0])
+        res_var_name = context.get_output_tileable_variable(op.outputs[0])
+        args_str = self.generate_call_args_with_attributes(
+            op, context, kw_keys=["ascending", "bins", "dropna", "normalize", "sort"]
+        )
+        return [f"{res_var_name} = {input_var_name}.value_counts({args_str})"]

maxframe/codegen/spe/dataframe/window.py

@@ -0,0 +1,65 @@
+# Copyright 1999-2025 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import List
+
+from ....dataframe.window.ewm import DataFrameEwmAgg
+from ....dataframe.window.expanding import DataFrameExpandingAgg
+from ....dataframe.window.rolling import DataFrameRollingAgg
+from ..core import SPECodeContext, SPEOperatorAdapter, register_op_adapter
+
+
+@register_op_adapter(DataFrameExpandingAgg)
+class DataFrameExpandingAggAdapter(SPEOperatorAdapter):
+    def generate_code(
+        self, op: DataFrameExpandingAgg, context: SPECodeContext
+    ) -> List[str]:
+        input_var_name = context.get_input_tileable_variable(op.inputs[0])
+        res_var_name = context.get_output_tileable_variable(op.outputs[0])
+        window_args = self.generate_call_args_with_attributes(
+            op, context, kw_keys=["min_periods", "axis"], skip_none=True
+        )
+        return [
+            f"{res_var_name} = {input_var_name}.expanding({window_args}).{op.func}()"
+        ]
+
+
+@register_op_adapter(DataFrameEwmAgg)
+class DataFrameEwmAggAdapter(SPEOperatorAdapter):
+    def generate_code(self, op: DataFrameEwmAgg, context: SPECodeContext) -> List[str]:
+        input_var_name = context.get_input_tileable_variable(op.inputs[0])
+        res_var_name = context.get_output_tileable_variable(op.outputs[0])
+        kw_keys = ["alpha", "min_periods", "adjust", "axis"]
+        window_args = self.generate_call_args_with_attributes(
+            op, context, kw_keys=kw_keys, alpha_ignore_na="ignore_na", skip_none=True
+        )
+        return [f"{res_var_name} = {input_var_name}.rolling({window_args}).{op.func}()"]
+
+
+@register_op_adapter(DataFrameRollingAgg)
+class DataFrameRollingAggAdapter(SPEOperatorAdapter):
+    def generate_code(
+        self, op: DataFrameRollingAgg, context: SPECodeContext
+    ) -> List[str]:
+        input_var_name = context.get_input_tileable_variable(op.inputs[0])
+        res_var_name = context.get_output_tileable_variable(op.outputs[0])
+        kw_keys = ["min_periods", "center", "win_type", "on", "axis", "closed"]
+        window_args = self.generate_call_args_with_attributes(
+            op, context, "window", kw_keys=kw_keys, skip_none=True
+        )
+        args_list = self._translate_call_args(context, *op.func_args, **op.func_kwargs)
+        args = ", ".join(args_list)
+        return [
+            f"{res_var_name} = {input_var_name}.rolling({window_args}).{op.func}({args})"
+        ]

maxframe/codegen/spe/learn/__init__.py

@@ -0,0 +1,15 @@
+# Copyright 1999-2025 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from . import contrib, metrics, preprocessing, utils

maxframe/codegen/spe/learn/contrib/__init__.py

@@ -0,0 +1,15 @@
+# Copyright 1999-2025 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from . import lightgbm, models, pytorch, xgboost