maxframe 2.0.0b2__cp311-cp311-win_amd64.whl → 2.2.0__cp311-cp311-win_amd64.whl

maxframe/codegen/spe/dataframe/tests/indexing/test_iloc.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 
 from ....core import SPECodeContext
-from ...indexing import DataFrameIlocGetItemAdapter
+from ...indexing import DataFrameIlocGetItemAdapter, DataFrameIlocSetItemAdapter
 
 
 def test_series_iloc_single_row(s1):
@@ -24,6 +24,14 @@ def test_series_iloc_single_row(s1):
     assert results == expected_results
 
 
+def test_series_iloc_set_single_row(s1):
+    s1.iloc[2] = 2
+    context = SPECodeContext()
+    results = DataFrameIlocSetItemAdapter().generate_code(s1.op, context)
+    expected_results = ["var_1 = var_0.copy()", "var_1.iloc[2] = 2"]
+    assert results == expected_results
+
+
 def test_series_iloc_multi_rows(s1):
     df = s1.iloc[:2]
     context = SPECodeContext()
@@ -48,6 +56,17 @@ def test_dataframe_iloc_only_columns(df1):
     assert results == expected_results
 
 
+def test_dataframe_iloc_set_only_column(df1):
+    df1.iloc[:, 0] = 5
+    context = SPECodeContext()
+    results = DataFrameIlocSetItemAdapter().generate_code(df1.op, context)
+    expected_results = [
+        "var_1 = var_0.copy()",
+        "var_1.iloc[slice(None, None, None), 0] = 5",
+    ]
+    assert results == expected_results
+
+
 def test_dataframe_iloc_only_rows(df1):
     df = df1.iloc[1]
     context = SPECodeContext()

maxframe/codegen/spe/dataframe/tests/indexing/test_loc.py

@@ -0,0 +1,35 @@
+# 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 ....core import SPECodeContext
+from ...indexing import DataFrameLocGetItemAdapter, DataFrameLocSetItemAdapter
+
+
+def test_dataframe_iloc_only_columns(df1):
+    df = df1.iloc[:, [0, 1]]
+    context = SPECodeContext()
+    results = DataFrameLocGetItemAdapter().generate_code(df.op, context)
+    expected_results = ["var_1 = var_0.loc[slice(None, None, None), [0, 1]]"]
+    assert results == expected_results
+
+
+def test_dataframe_iloc_set_only_column(df1):
+    df1.iloc[:, 0] = 5
+    context = SPECodeContext()
+    results = DataFrameLocSetItemAdapter().generate_code(df1.op, context)
+    expected_results = [
+        "var_1 = var_0.copy()",
+        "var_1.loc[slice(None, None, None), 0] = 5",
+    ]
+    assert results == expected_results

maxframe/codegen/spe/dataframe/tests/misc/test_misc.py

@@ -30,11 +30,8 @@ from ...misc import (
     DataFrameExplodeAdapter,
     DataFrameIsinAdapter,
     DataFrameMapAdapter,
-    DataFrameMeltAdapter,
     DataFrameMemoryUsageAdapter,
-    DataFramePivotTableAdapter,
     DataFrameShiftAdapter,
-    DataFrameStackAdapter,
     DataFrameToNumericAdapter,
 )
 
@@ -181,17 +178,6 @@ def test_map(df1):
     assert results == expected_results
 
 
-def test_melt(df1):
-    context = SPECodeContext()
-
-    v1 = df1.melt(id_vars=["A"], value_vars=["B"])
-    results = DataFrameMeltAdapter().generate_code(v1.op, context)
-    assert (
-        results[0]
-        == "var_1 = var_0.melt(id_vars=['A'], value_vars=['B'], value_name='value')"
-    )
-
-
 def test_memory_usage(df1):
     context = SPECodeContext()
     v1 = df1.memory_usage(index=False)
@@ -199,17 +185,6 @@ def test_memory_usage(df1):
     assert results[0] == "var_1 = var_0.memory_usage(index=False, deep=False)"
 
 
-def test_pivot_table(midx_df1):
-    df = midx_df1.pivot_table(columns="B", values="C")
-    context = SPECodeContext()
-    results = DataFramePivotTableAdapter().generate_code(df.op, context)
-    assert results[0] == (
-        "var_1 = var_0.pivot_table(values='C', columns='B', "
-        "aggfunc='mean', margins=False, dropna=True, margins_name='All', "
-        "sort=True)"
-    )
-
-
 def test_shift(df1):
     df = df1.shift(periods=1)
     context = SPECodeContext()
@@ -217,13 +192,6 @@ def test_shift(df1):
     assert results[0] == "var_1 = var_0.shift(periods=1, axis=0)"
 
 
-def test_stack(midx_df1):
-    df = midx_df1.stack([0])
-    context = SPECodeContext()
-    results = DataFrameStackAdapter().generate_code(df.op, context)
-    assert results[0] == "var_1 = var_0.stack(level=[0], dropna=True)"
-
-
 def test_to_numeric():
     v0 = md.Series([1, 2, 3, 4, 5, 6])
     v1 = md.to_numeric(v0, downcast="float")

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

@@ -21,10 +21,11 @@ from ..groupby import (
     DataFrameGroupByOpAdapter,
     GroupByApplyAdapter,
     GroupByApplyChunkAdapter,
-    GroupByCumReductionAdapter,
+    GroupByExpandingAggAdapter,
     GroupByFillOperatorAdapter,
     GroupByHeadAdapter,
     GroupByIndexAdapter,
+    GroupByRollingAggAdapter,
     GroupBySampleAdapter,
     GroupByTransformAdapter,
     _need_enforce_group_keys,
@@ -73,30 +74,92 @@ def test_dataframe_groupby_agg(df1):
 @pytest.mark.parametrize(
     "func, func_kwargs, expected_results",
     [
-        ("cumcount", {}, ["var_1 = var_0.cumcount(ascending=True)"]),
-        ("cumcount", {"ascending": True}, ["var_1 = var_0.cumcount(ascending=True)"]),
-        ("cumcount", {"ascending": False}, ["var_1 = var_0.cumcount(ascending=False)"]),
-        ("cumsum", {}, ["var_1 = var_0.cumsum(axis=0)"]),
-        ("cumsum", {"axis": 0}, ["var_1 = var_0.cumsum(axis=0)"]),
-        ("cumsum", {"axis": 1}, ["var_1 = var_0.cumsum(axis=1)"]),
-        ("cumprod", {}, ["var_1 = var_0.cumprod(axis=0)"]),
-        ("cumprod", {"axis": 0}, ["var_1 = var_0.cumprod(axis=0)"]),
-        ("cumprod", {"axis": 1}, ["var_1 = var_0.cumprod(axis=1)"]),
-        ("cummax", {}, ["var_1 = var_0.cummax(axis=0)"]),
-        ("cummax", {"axis": 0}, ["var_1 = var_0.cummax(axis=0)"]),
-        ("cummax", {"axis": 1}, ["var_1 = var_0.cummax(axis=1)"]),
-        ("cummin", {}, ["var_1 = var_0.cummin(axis=0)"]),
-        ("cummin", {"axis": 0}, ["var_1 = var_0.cummin(axis=0)"]),
-        ("cummin", {"axis": 1}, ["var_1 = var_0.cummin(axis=1)"]),
+        ("cumcount", {}, ["var_1 = {G}.cumcount(ascending=True)"]),
+        ("cumcount", {"ascending": True}, ["var_1 = {G}.cumcount(ascending=True)"]),
+        ("cumcount", {"ascending": False}, ["var_1 = {G}.cumcount(ascending=False)"]),
+        ("cumsum", {}, ["var_1 = {G}.cumsum()"]),
+        ("cumprod", {}, ["var_1 = {G}.cumprod()"]),
+        ("cummax", {}, ["var_1 = {G}.cummax()"]),
+        ("cummin", {}, ["var_1 = {G}.cummin()"]),
     ],
 )
 def test_dataframe_groupby_cum(df1, func, func_kwargs, expected_results):
     context = SPECodeContext()
-    adapter = GroupByCumReductionAdapter()
+    adapter = GroupByExpandingAggAdapter()
 
+    groupby_code = "var_0.groupby(by=['A'], as_index=True, sort=True, group_keys=True)"
     res = getattr(df1.groupby("A"), func)(**func_kwargs)
     results = adapter.generate_code(res.op, context)
-    assert results == expected_results
+    assert results == [s.replace("{G}", groupby_code) for s in expected_results]
+
+
+def test_dataframe_groupby_expanding(df1):
+    context = SPECodeContext()
+    adapter = GroupByExpandingAggAdapter()
+    res = df1.groupby("A").expanding(2).sum()
+    results = adapter.generate_code(res.op, context)
+    assert results == [
+        "def _exp_fun_var_1(frame, **_):",
+        "    func = 'sum' if func != \"prod\" else lambda x: x.prod()",
+        "    out_frame = frame.expanding(min_periods=2).agg(func)",
+        "    return out_frame",
+        "var_1 = var_0.groupby(by=['A'], as_index=True, sort=True, group_keys=True"
+        ").apply(_exp_fun_var_1, include_groups=False)",
+    ]
+
+    res = df1.groupby("A").expanding(2, shift=1).sum()
+    results = adapter.generate_code(res.op, context)
+    assert results == [
+        "def _exp_fun_var_2(frame, **_):",
+        "    func = 'sum' if func != \"prod\" else lambda x: x.prod()",
+        "    frame = frame.shift(-1)",
+        "    out_frame = frame.expanding(min_periods=2).agg(func)",
+        "    return out_frame",
+        "var_2 = var_0.groupby(by=['A'], as_index=True, sort=True, "
+        "group_keys=True).apply(_exp_fun_var_2, include_groups=False)",
+    ]
+
+    res = df1.groupby("A").expanding(2, shift=1, reverse_range=True).sum()
+    results = adapter.generate_code(res.op, context)
+    assert results == [
+        "def _exp_fun_var_3(frame, **_):",
+        "    func = 'sum' if func != \"prod\" else lambda x: x.prod()",
+        "    frame = frame.shift(-1)",
+        "    frame = frame.iloc[::-1]",
+        "    out_frame = frame.expanding(min_periods=2).agg(func)",
+        "    out_frame = out_frame.iloc[::-1]",
+        "    return out_frame",
+        "var_3 = var_0.groupby(by=['A'], as_index=True, sort=True, "
+        "group_keys=True).apply(_exp_fun_var_3, include_groups=False)",
+    ]
+
+
+def test_dataframe_groupby_rolling(df1):
+    context = SPECodeContext()
+    adapter = GroupByRollingAggAdapter()
+    res = df1.groupby("A").rolling(3).sum()
+    results = adapter.generate_code(res.op, context)
+    assert results == [
+        "def _roll_fun_var_1(frame, **_):",
+        "    func = 'sum' if func != \"prod\" else lambda x: x.prod()",
+        "    frame = frame.shift(0)",
+        "    return frame.rolling(window=3, min_periods=None, center=False, "
+        "win_type=None, axis=0, on=None, closed=None).agg(func)",
+        "var_1 = var_0.groupby(by=['A'], as_index=True, sort=True, "
+        "group_keys=True).apply(_roll_fun_var_1, include_groups=False)",
+    ]
+
+    res = df1.groupby("A").rolling(3, shift=1).sum()
+    results = adapter.generate_code(res.op, context)
+    assert results == [
+        "def _roll_fun_var_2(frame, **_):",
+        "    func = 'sum' if func != \"prod\" else lambda x: x.prod()",
+        "    frame = frame.shift(-1)",
+        "    return frame.rolling(window=3, min_periods=None, center=False, "
+        "win_type=None, axis=0, on=None, closed=None).agg(func)",
+        "var_2 = var_0.groupby(by=['A'], as_index=True, sort=True, "
+        "group_keys=True).apply(_roll_fun_var_2, include_groups=False)",
+    ]
 
 
 def test_dataframe_groupby_fill(df1):

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

@@ -17,7 +17,11 @@ import pytest
 
 from ..... import dataframe as md
 from ...core import SPECodeContext
-from ..merge import DataFrameConcatAdapter, DataFrameMergeAdapter
+from ..merge import (
+    DataFrameConcatAdapter,
+    DataFrameMergeAdapter,
+    DataFrameUpdateAdapter,
+)
 
 
 @pytest.fixture
@@ -398,3 +402,25 @@ def test_concat_columns_from_dataframes(df2, df6):
         " objs=[var_1, var_2], copy=True)"
     ]
     assert results == expected_results
+
+
+def test_update_dataframe(df5, df6):
+    adapter = DataFrameUpdateAdapter()
+    df5.update(df6)
+    context = SPECodeContext()
+    results = adapter.generate_code(df5.op, context)
+    expected_results = [
+        "var_1 = var_0.copy()",
+        "var_1.update(var_2, join='left', overwrite=True, filter_func=None,"
+        " errors='ignore')",
+    ]
+    assert results == expected_results
+
+
+def test_combine_first_dataframe(df5, df6):
+    adapter = DataFrameUpdateAdapter()
+    df = df5.combine_first(df6)
+    context = SPECodeContext()
+    results = adapter.generate_code(df.op, context)
+    expected_results = ["var_1 = var_0.combine_first(var_2)"]
+    assert results == expected_results

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

@@ -0,0 +1,79 @@
+# 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 SPECodeContext
+from ..reshape import (
+    DataFrameMeltAdapter,
+    DataFramePivotTableAdapter,
+    DataFrameStackAdapter,
+)
+
+
+@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 midx_df1():
+    return md.DataFrame(
+        [
+            [1, 10, 101],
+            [9, 90, 909],
+            [2, 20, 202],
+        ],
+        index=pd.MultiIndex.from_arrays(
+            [[1, 9, 2], [11, 99, 22], [111, 999, 222]],
+            names=("idx_0", "idx_1", "idx_2"),
+        ),
+        columns=list("ABC"),
+    )
+
+
+def test_melt(df1):
+    context = SPECodeContext()
+
+    v1 = df1.melt(id_vars=["A"], value_vars=["B"])
+    results = DataFrameMeltAdapter().generate_code(v1.op, context)
+    assert (
+        results[0]
+        == "var_1 = var_0.melt(id_vars=['A'], value_vars=['B'], value_name='value')"
+    )
+
+
+def test_pivot_table(midx_df1):
+    df = midx_df1.pivot_table(columns="B", values="C")
+    context = SPECodeContext()
+    results = DataFramePivotTableAdapter().generate_code(df.op, context)
+    assert results[0] == (
+        "var_1 = var_0.pivot_table(values='C', columns='B', "
+        "aggfunc='mean', margins=False, dropna=True, margins_name='All', "
+        "sort=True)"
+    )
+
+
+def test_stack(midx_df1):
+    df = midx_df1.stack([0])
+    context = SPECodeContext()
+    results = DataFrameStackAdapter().generate_code(df.op, context)
+    assert results[0] == "var_1 = var_0.stack(level=[0], dropna=True)"

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

@@ -157,3 +157,23 @@ def test_dataframe_sort_index_by_all(df2):
         " 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/learn/contrib/tests/test_xgboost.py

@@ -50,8 +50,9 @@ def test_spe_xgb_train_script():
     results = adapter.generate_code(model.op, context)
     assert results == [
         "start_time = time.time()",
+        "var_2 = dict()",
         "logger.info('Trained data size: (%s, %s)', var_1.num_row(), var_1.num_col())",
-        "var_0 = xgboost.train(params={}, dtrain=var_1, evals=[], num_boost_round=10)",
+        "var_0 = xgboost.train(params={}, dtrain=var_1, evals=[], num_boost_round=10, evals_result=var_2)",
         "logger.info('Train cost: %.2f s', time.time() - start_time)",
     ]
 

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

@@ -12,4 +12,4 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from . import _classification
+from . import _classification, _ranking, pairwise

maxframe/codegen/spe/learn/metrics/_ranking.py

@@ -0,0 +1,76 @@
+# 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 .....learn.metrics._ranking import AucOp, RocAucScore, RocCurve
+from ...core import SPECodeContext, SPEOperatorAdapter, register_op_adapter
+
+
+@register_op_adapter(AucOp)
+class AucOpAdapter(SPEOperatorAdapter):
+    def generate_code(self, op: AucOp, context: SPECodeContext) -> List[str]:
+        context.register_import(
+            "sklearn.metrics",
+            from_item="auc",
+            alias="sk_auc",
+        )
+        call_args = self.generate_call_args_with_attributes(
+            op, context, "x", "y", skip_none=True
+        )
+        out_vars = [context.get_output_tileable_variable(out) for out in op.outputs]
+        out_vars_str = ", ".join(out_vars)
+        return [f"{out_vars_str} = sk_auc({call_args})"]
+
+
+@register_op_adapter(RocAucScore)
+class RocAucScoreAdapter(SPEOperatorAdapter):
+    def generate_code(self, op: RocAucScore, context: SPECodeContext) -> List[str]:
+        context.register_import(
+            "sklearn.metrics",
+            from_item="roc_auc_score",
+            alias="sk_roc_auc_score",
+        )
+        call_args = self.generate_call_args_with_attributes(
+            op,
+            context,
+            "y_true",
+            "y_score",
+            skip_none=True,
+            kw_keys=["average", "sample_weight", "max_fpr", "multi_class", "labels"],
+        )
+        out_vars = [context.get_output_tileable_variable(out) for out in op.outputs]
+        out_vars_str = ", ".join(out_vars)
+        return [f"{out_vars_str} = sk_roc_auc_score({call_args})"]
+
+
+@register_op_adapter(RocCurve)
+class RocCurveAdapter(SPEOperatorAdapter):
+    def generate_code(self, op: RocCurve, context: SPECodeContext) -> List[str]:
+        context.register_import(
+            "sklearn.metrics",
+            from_item="roc_curve",
+            alias="sk_roc_curve",
+        )
+        call_args = self.generate_call_args_with_attributes(
+            op,
+            context,
+            "y_true",
+            "y_score",
+            skip_none=True,
+            kw_keys=["sample_weight", "drop_intermediate", "pos_label"],
+        )
+        out_vars = [context.get_output_tileable_variable(out) for out in op.outputs]
+        out_vars_str = ", ".join(out_vars)
+        return [f"{out_vars_str} = sk_roc_curve({call_args})"]

maxframe/codegen/spe/learn/metrics/pairwise.py

@@ -0,0 +1,51 @@
+# 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 .....learn.metrics.pairwise.cosine import CosineDistances
+from .....learn.metrics.pairwise.euclidean import EuclideanDistances
+from .....learn.metrics.pairwise.haversine import HaversineDistances
+from .....learn.metrics.pairwise.manhattan import ManhattanDistances
+from ...utils import build_method_call_adapter
+
+CosineDistancesAdapter = build_method_call_adapter(
+    CosineDistances,
+    "cosine_distances",
+    "x",
+    "y",
+    source_module="sklearn.metrics.pairwise",
+)
+EuclideanDistancesAdapter = build_method_call_adapter(
+    EuclideanDistances,
+    "euclidean_distances",
+    "x",
+    "y",
+    y_norm_squared="Y_norm_squared",
+    squared="squared",
+    x_norm_squared="X_norm_squared",
+    source_module="sklearn.metrics.pairwise",
+)
+HaversineDistancesAdapter = build_method_call_adapter(
+    HaversineDistances,
+    "haversine_distances",
+    "x",
+    "y",
+    source_module="sklearn.metrics.pairwise",
+)
+ManhattanDistancesAdapter = build_method_call_adapter(
+    ManhattanDistances,
+    "manhattan_distances",
+    "x",
+    "y",
+    source_module="sklearn.metrics.pairwise",
+)

maxframe/codegen/spe/learn/metrics/tests/test_pairwise.py

@@ -0,0 +1,36 @@
+# 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 tensor as mt
+from ......learn.metrics.pairwise import euclidean_distances
+from ....core import SPECodeContext
+from ..pairwise import EuclideanDistancesAdapter
+
+
+def test_euclidean_distances():
+    x = mt.random.rand(10, 3)
+
+    d = euclidean_distances(
+        x,
+        X_norm_squared=mt.random.rand(10, 1),
+    )
+
+    adapter = EuclideanDistancesAdapter()
+    context = SPECodeContext()
+    results = adapter.generate_code(d.op, context)
+    expected_results = [
+        "var_0 = sklearn.metrics.pairwise.euclidean_distances("
+        "var_1, var_1, squared=False, X_norm_squared=var_2)"
+    ]
+    assert results == expected_results

maxframe/codegen/spe/learn/metrics/tests/test_ranking.py

@@ -0,0 +1,59 @@
+# 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 tensor as mt
+from ......learn.metrics import auc, roc_auc_score, roc_curve
+from ....core import SPECodeContext
+from .._ranking import AucOpAdapter, RocAucScoreAdapter, RocCurveAdapter
+
+
+def test_auc():
+    t1 = mt.array([1, 1, 2, 2])
+    t2 = mt.array([0.1, 0.4, 0.35, 0.8])
+    result = auc(t1, t2)
+
+    adapter = AucOpAdapter()
+    context = SPECodeContext()
+    results = adapter.generate_code(result.op, context)
+    expected_results = ["var_2 = sk_auc(var_0, var_1)"]
+    assert results == expected_results
+
+
+def test_roc_auc_score():
+    t1 = mt.array([0, 0, 1, 1])
+    t2 = mt.array([0.1, 0.4, 0.35, 0.8])
+    result = roc_auc_score(t1, t2)
+
+    adapter = RocAucScoreAdapter()
+    context = SPECodeContext()
+    results = adapter.generate_code(result.op, context)
+    expected_results = [
+        "var_2 = sk_roc_auc_score("
+        "var_0, var_1, average='macro', multi_class='raise')"
+    ]
+    assert results == expected_results
+
+
+def test_roc_curve():
+    t1 = mt.array([0, 0, 1, 1])
+    t2 = mt.array([0.1, 0.4, 0.35, 0.8])
+    result = roc_curve(t1, t2)
+
+    adapter = RocCurveAdapter()
+    context = SPECodeContext()
+    results = adapter.generate_code(result[0].op, context)
+    expected_results = [
+        "var_2, var_3, var_4 = sk_roc_curve(" "var_0, var_1, drop_intermediate=True)"
+    ]
+    assert results == expected_results

maxframe/codegen/spe/tensor/__init__.py

@@ -17,6 +17,7 @@ from . import (
     datasource,
     extensions,
     fetch,
+    fft,
     indexing,
     linalg,
     merge,
@@ -24,5 +25,7 @@ from . import (
     random,
     reduction,
     reshape,
+    spatial,
     special,
+    statistics,
 )