maxframe 2.0.0b2__cp37-cp37m-win32.whl → 2.3.0rc1__cp37-cp37m-win32.whl

maxframe/codegen/spe/dataframe/tests/accessors/test_struct.py

@@ -0,0 +1,75 @@
+# 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 pandas as pd
+import pyarrow as pa
+import pytest
+
+from ...... import dataframe as md
+from ......utils import ARROW_DTYPE_NOT_SUPPORTED
+from ....core import SPECodeContext
+from ...accessors.struct_ import SeriesStructMethodAdapter
+
+pytestmark = pytest.mark.skipif(
+    ARROW_DTYPE_NOT_SUPPORTED, reason="Arrow Dtype is not supported"
+)
+
+
+def _run_generated_code(
+    code: str, ctx: SPECodeContext, input_val: pd.DataFrame
+) -> dict:
+    local_vars = ctx.constants.copy()
+    local_vars["var_0"] = input_val
+    import_code = "import pandas as pd\nimport numpy as np\n"
+    exec(import_code + code, local_vars, local_vars)
+    return local_vars
+
+
+@pytest.fixture
+def series():
+    version_type = pa.struct(
+        [
+            ("major", pa.int64()),
+            ("minor", pa.int64()),
+        ]
+    )
+    return md.Series(
+        [
+            {"version": {"major": 1, "minor": 5}, "project": "pandas"},
+            {"version": {"major": 2, "minor": 1}, "project": "pandas"},
+            {"version": {"major": 1, "minor": 26}, "project": "numpy"},
+        ],
+        dtype=pd.ArrowDtype(
+            pa.struct([("version", version_type), ("project", pa.string())])
+        ),
+    )
+
+
+def test_field(series):
+    s1 = series.struct.field(["version", "minor"])
+    context = SPECodeContext()
+    adapter = SeriesStructMethodAdapter()
+    results = adapter.generate_code(s1.op, context)
+
+    expected_results = [
+        """
+var_1 = var_0.struct.field(['version', 'minor'])
+"""
+    ]
+    assert results == expected_results
+    local_vars = _run_generated_code(results[0], context, series.op.data)
+    expected_series = pd.Series(
+        [5, 1, 26], dtype=pd.ArrowDtype(pa.int64()), name="minor"
+    )
+    pd.testing.assert_series_equal(expected_series, local_vars["var_1"])

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_reduction.py

@@ -19,6 +19,7 @@ from ...core import SPECodeContext
 from ..reduction import (
     DataFrameAggregateAdapter,
     DataFrameKurtosisAdapter,
+    DataFrameModeAdapter,
     DataFrameNuniqueAdapter,
     DataFrameReductionAdapter,
     DataFrameUniqueAdapter,
@@ -96,6 +97,18 @@ def test_median(df1):
     assert results == expected_results
 
 
+def test_mode(df1, s1):
+    df = df1.mode(dropna=False, numeric_only=True)
+    results = DataFrameModeAdapter().generate_code(df.op, SPECodeContext())
+    expected_results = ["var_1 = var_0.mode(axis=0, numeric_only=True, dropna=False)"]
+    assert results == expected_results
+
+    s = s1.mode()
+    results = DataFrameModeAdapter().generate_code(s.op, SPECodeContext())
+    expected_results = ["var_1 = var_0.mode(dropna=True)"]
+    assert results == expected_results
+
+
 def test_aggregate(df1):
     df = df1.agg(["sum", "mean"])
     context = SPECodeContext()

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/dataframe/tseries.py

@@ -14,9 +14,18 @@
 
 from typing import List
 
+from ....dataframe.tseries.between_time import DataFrameBetweenTime
 from ....dataframe.tseries.to_datetime import DataFrameToDatetime
 from ....utils import no_default
 from ..core import SPECodeContext, SPEOperatorAdapter, register_op_adapter
+from ..utils import build_method_call_adapter
+
+DataFrameBetweenTimeAdapter = build_method_call_adapter(
+    DataFrameBetweenTime,
+    "between_time",
+    kw_keys=["start_time", "end_time", "inclusive", "axis"],
+    skip_none=True,
+)
 
 
 @register_op_adapter(DataFrameToDatetime)

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

@@ -13,7 +13,7 @@
 # limitations under the License.
 
 import inspect
-from typing import List
+from typing import List, Optional
 
 from .....learn.contrib.lightgbm._predict import LGBMPredict
 from .....learn.contrib.lightgbm._train import LGBMTrain
@@ -23,11 +23,12 @@ from ...core import SPECodeContext, SPEOperatorAdapter, register_op_adapter
 
 
 class _LightGBMAdapter(SPEOperatorAdapter):
-    def generate_code(self, op: OperatorType, context: SPECodeContext) -> List[str]:
+    def generate_code(
+        self, op: OperatorType, context: SPECodeContext
+    ) -> Optional[List[str]]:
         context.register_import("lightgbm")
         context.register_import("pandas", "pd")
         context.register_import("numpy", "np")
-        return []
 
 
 @register_op_adapter(ToLGBMDataset)

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})"]