maxframe 1.3.0__cp38-cp38-win_amd64.whl → 2.0.0b1__cp38-cp38-win_amd64.whl

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

@@ -0,0 +1,49 @@
+# 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 sys
+from typing import List, Union
+
+from .....learn.contrib.pytorch.run_script import RunPyTorch
+from ...core import SPECodeContext, SPEOperatorAdapter, register_op_adapter
+
+
+@register_op_adapter(RunPyTorch)
+class RunPyTorchAdapter(SPEOperatorAdapter):
+    @staticmethod
+    def _run_script(code: Union[bytes, str], data: dict, cmd_args: List[str]):
+        old_argv = sys.argv.copy()
+        try:
+            sys.argv = ["script"] + cmd_args
+            locals_dict = {"__name__": "__main__"}
+            locals_dict.update(data)
+
+            exec(code, locals_dict)
+
+            return {"status": "ok"}
+        finally:
+            sys.argv = old_argv
+
+    def generate_code(self, op: RunPyTorch, context: SPECodeContext) -> List[str]:
+        data_args = ", ".join(self._translate_call_args(context, **(op.data or {})))
+        cmd_args_str = ", ".join(f'"{v}"' for v in (op.command_args or []))
+        code_var = context.register_operator_constants(op.code)
+        output_var = context.get_output_tileable_variable(op.outputs[0])
+
+        cls_name = type(self).__name__
+        context.register_import(__name__, from_item=type(self).__name__)
+        return [
+            f"{output_var} = {cls_name}._run_script("
+            f"{code_var}, dict({data_args}), [{cmd_args_str}])"
+        ]

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

@@ -0,0 +1,13 @@
+# 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.

maxframe/codegen/spe/learn/contrib/tests/test_lightgbm.py

@@ -0,0 +1,123 @@
+# 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 mock
+import pytest
+
+try:
+    import lightgbm
+    from sklearn.datasets import make_classification
+except ImportError:
+    lightgbm = make_classification = None
+
+from ...... import tensor as mt
+from ......learn.contrib.lightgbm import Dataset, train
+from ....core import SPECodeContext
+from ..lightgbm import LGBMPredictAdapter, LGBMTrainAdapter, ToLGBMDatasetAdapter
+
+pytestmark = pytest.mark.skipif(
+    lightgbm is None, reason="requires lightgbm to run the test"
+)
+
+
+def test_spe_lgbm_dataset():
+    X = mt.random.rand(100, 10)
+    y = mt.random.rand(100)
+    ds = Dataset(X, y)
+    adapter = ToLGBMDatasetAdapter()
+    context = SPECodeContext()
+    results = adapter.generate_code(ds.op, context)
+    assert results == [
+        "var_0 = lightgbm.Dataset(data=var_1, label=var_2, free_raw_data=True)"
+    ]
+
+
+def test_spe_lgbm_train_script():
+    X = mt.random.rand(100, 10)
+    y = mt.random.rand(100)
+    ds = Dataset(X, y)
+    model = train({}, ds, num_boost_round=10)
+    adapter = LGBMTrainAdapter()
+    context = SPECodeContext()
+    results = adapter.generate_code(model.op, context)
+    assert results == [
+        "start_time = time.time()",
+        "logger.info('Trained data size: (%s, %s)', var_1.num_data(), var_1.num_feature())",
+        "var_0 = LGBMTrainAdapter._run_lgbm_train(params={}, train_set=var_1, "
+        "num_boost_round=10, valid_sets=[], keep_training_booster=False, timeout=120)",
+        "logger.info('Train cost: %.2f s', time.time() - start_time)",
+    ]
+
+    with mock.patch(
+        "maxframe.core.entity.executable._ExecutableMixin.execute",
+        new=lambda *_, **__: None,
+    ), mock.patch(
+        "maxframe.core.entity.executable._ExecutableMixin.fetch",
+        new=lambda *_, **__: {},
+    ):
+        X_valid = mt.random.rand(50, 10)
+        y_valid = mt.random.rand(50)
+        ds_valid = Dataset(X_valid, y_valid)
+        model = train({}, ds, num_boost_round=10, valid_sets=[ds_valid])
+        adapter = LGBMTrainAdapter()
+        context = SPECodeContext()
+        results = adapter.generate_code(model.op, context)
+        assert results == [
+            "start_time = time.time()",
+            "var_3 = dict()",
+            "logger.info('Trained data size: (%s, %s)', var_1.num_data(), var_1.num_feature())",
+            "var_0 = LGBMTrainAdapter._run_lgbm_train(params={}, train_set=var_1, "
+            "num_boost_round=10, valid_sets=[var_2], keep_training_booster=False, "
+            "timeout=120, evals_result=var_3)",
+            "logger.info('Train cost: %.2f s', time.time() - start_time)",
+        ]
+
+
+def test_spe_lgbm_train_run():
+    X, y = make_classification(n_features=5, n_informative=3)
+    ds = lightgbm.Dataset(X, y)
+    model = LGBMTrainAdapter._run_lgbm_train(
+        params={}, train_set=ds, num_boost_round=10
+    )
+    assert isinstance(model, lightgbm.Booster)
+
+    X_valid, y_valid = make_classification(n_samples=50, n_features=5, n_informative=3)
+    ds_valid = lightgbm.Dataset(X_valid, y_valid)
+    eval_results = {}
+    model = LGBMTrainAdapter._run_lgbm_train(
+        params={},
+        train_set=ds,
+        valid_sets=[ds_valid],
+        num_boost_round=10,
+        evals_result=eval_results,
+    )
+    assert isinstance(model, lightgbm.Booster)
+    assert len(eval_results) > 0
+
+
+def test_spe_lgbm_predict():
+    X = mt.random.rand(100, 10)
+    y = mt.random.rand(100)
+    ds = Dataset(X, y)
+    model = train({}, ds, num_boost_round=10)
+    predicted = model.predict(ds)
+    adapter = LGBMPredictAdapter()
+    context = SPECodeContext()
+    results = adapter.generate_code(predicted.op, context)
+    assert results == [
+        "start_time = time.time()",
+        "var_0 = var_2.predict(var_1, start_iteration=0, raw_score=False, "
+        "pred_leaf=False, pred_contrib=False)",
+        "logger.info('Predict cost: %.2f s', time.time() - start_time)",
+    ]

maxframe/codegen/spe/learn/contrib/tests/test_models.py

@@ -0,0 +1,41 @@
+# 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
+
+try:
+    import lightgbm
+except ImportError:
+    lightgbm = None
+
+from ...... import tensor as mt
+from ......learn.contrib.lightgbm import Dataset, train
+from ....core import SPECodeContext
+from ..models import ModelApplyChunkAdapter
+
+
+@pytest.mark.skipif(lightgbm is None, reason="requires lightgbm to run the test")
+def test_spe_lgbm_feature_importance():
+    X = mt.random.rand(100, 10)
+    y = mt.random.rand(100)
+    ds = Dataset(X, y)
+    model = train({}, ds, num_boost_round=10)
+    fe = model.feature_importance()
+
+    adapter = ModelApplyChunkAdapter()
+    context = SPECodeContext()
+    results = adapter.generate_code(fe.op, context)
+    assert results == [
+        "var_1 = const_0(var_0, importance_type='split', iteration=None)"
+    ]

maxframe/codegen/spe/learn/contrib/tests/test_pytorch.py

@@ -0,0 +1,53 @@
+# 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 io import StringIO
+
+import pytest
+
+from ...... import dataframe as md
+from ......learn.contrib.pytorch import run_pytorch_script
+from ....core import SPECodeContext
+from ..pytorch import RunPyTorchAdapter
+
+
+@pytest.fixture
+def df1():
+    return md.DataFrame(
+        [
+            [1, 10, 100, 1000],
+            [2, 20, 200, 2000],
+            [3, 30, 300, 3000],
+            [7, 70, 700, 7000],
+        ],
+        index=md.Index([1, 2, 3, 7], name="test_idx"),
+        columns=list("ABCD"),
+    )
+
+
+def test_run_pytorch_script(df1):
+    res_t = run_pytorch_script(
+        StringIO("print(var)"),
+        n_workers=1,
+        data={"var": df1},
+        command_argv=["--run"],
+        execute=False,
+    )
+    context = SPECodeContext()
+    adapter = RunPyTorchAdapter()
+    results = adapter.generate_code(res_t.op, context)
+    assert results == [
+        "var_1 = RunPyTorchAdapter._run_script("
+        "b'print(var)', dict(var=var_0), [\"--run\"])"
+    ]

maxframe/codegen/spe/learn/contrib/tests/test_xgboost.py

@@ -0,0 +1,98 @@
+# 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 mock
+import pytest
+
+try:
+    import xgboost
+except ImportError:
+    xgboost = None
+
+from ...... import tensor as mt
+from ......learn.contrib.xgboost import DMatrix, train
+from ....core import SPECodeContext
+from ..xgboost import ToDMatrixAdapter, XGBPredictAdapter, XGBTrainAdapter
+
+pytestmark = pytest.mark.skipif(
+    xgboost is None, reason="requires xgboost to run the test"
+)
+
+
+def test_spe_xgb_dmatrix():
+    X = mt.random.rand(100, 10)
+    y = mt.random.rand(100)
+    ds = DMatrix(X, y)
+    adapter = ToDMatrixAdapter()
+    context = SPECodeContext()
+    results = adapter.generate_code(ds.op, context)
+    assert results == ["var_0 = xgboost.DMatrix(data=var_1, label=var_2)"]
+
+
+def test_spe_xgb_train_script():
+    X = mt.random.rand(100, 10)
+    y = mt.random.rand(100)
+    ds = DMatrix(X, y)
+    model = train({}, ds, num_boost_round=10)
+    adapter = XGBTrainAdapter()
+    context = SPECodeContext()
+    results = adapter.generate_code(model.op, context)
+    assert results == [
+        "start_time = time.time()",
+        "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)",
+        "logger.info('Train cost: %.2f s', time.time() - start_time)",
+    ]
+
+    with mock.patch(
+        "maxframe.core.entity.executable._ExecutableMixin.execute",
+        new=lambda *_, **__: None,
+    ), mock.patch(
+        "maxframe.core.entity.executable._ExecutableMixin.fetch",
+        new=lambda *_, **__: {},
+    ):
+        X_valid = mt.random.rand(50, 10)
+        y_valid = mt.random.rand(50)
+        ds_valid = DMatrix(X_valid, y_valid)
+        model = train({}, ds, evals=[(ds_valid, "vset")])
+        adapter = XGBTrainAdapter()
+        context = SPECodeContext()
+        results = adapter.generate_code(model.op, context)
+        assert results == [
+            "start_time = time.time()",
+            "var_3 = 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=[(var_2, 'vset')], "
+            "num_boost_round=10, evals_result=var_3)",
+            "logger.info('Train cost: %.2f s', time.time() - start_time)",
+        ]
+
+
+def test_spe_xgb_predict():
+    X = mt.random.rand(100, 10)
+    y = mt.random.rand(100)
+    ds = DMatrix(X, y)
+    model = train({}, ds)
+    predicted = model.predict(ds)
+    adapter = XGBPredictAdapter()
+    context = SPECodeContext()
+    results = adapter.generate_code(predicted.op, context)
+    assert results == [
+        "start_time = time.time()",
+        "logger.info('Predicted data size: (%s, %s)', var_1.num_row(), var_1.num_col())",
+        "var_0 = var_2.predict(var_1, pred_leaf=False, pred_contribs=False, "
+        "approx_contribs=False, pred_interactions=False, validate_features=True, "
+        "training=False, iteration_range=(0, 0), strict_shape=False)",
+        "logger.info('Predict cost: %.2f s', time.time() - start_time)",
+    ]

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

@@ -0,0 +1,152 @@
+# 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.contrib.xgboost.dmatrix import ToDMatrix
+from .....learn.contrib.xgboost.predict import XGBPredict
+from .....learn.contrib.xgboost.train import XGBTrain
+from .....typing_ import OperatorType
+from ...core import SPECodeContext, SPEOperatorAdapter, register_op_adapter
+
+
+class _XGBoostAdapter(SPEOperatorAdapter):
+    def generate_code(self, op: OperatorType, context: SPECodeContext) -> List[str]:
+        context.register_import("xgboost")
+        context.register_import("pandas", "pd")
+        context.register_import("numpy", "np")
+
+
+@register_op_adapter(ToDMatrix)
+class ToDMatrixAdapter(_XGBoostAdapter):
+    def generate_code(self, op: ToDMatrix, context: SPECodeContext) -> List[str]:
+        super().generate_code(op, context)
+        res_var_name = context.get_output_tileable_variable(op.outputs[0])
+        call_args = (
+            "data",
+            "label",
+            "missing",
+            "weight",
+            "base_margin",
+            "feature_names",
+            "feature_types",
+            "feature_weights",
+            "nthread",
+            "group",
+            "qid",
+            "label_lower_bound",
+            "label_upper_bound",
+            "enable_categorical",
+        )
+        args_str = self.generate_call_args_with_attributes(
+            op,
+            context,
+            skip_none=True,
+            kw_keys=call_args,
+        )
+        return [f"{res_var_name} = xgboost.DMatrix({args_str})"]
+
+
+@register_op_adapter(XGBTrain)
+class XGBTrainAdapter(_XGBoostAdapter):
+    def generate_code(self, op: XGBTrain, context: SPECodeContext) -> List[str]:
+        super().generate_code(op, context)
+        context.register_import("pickle")
+        res_var_name = context.get_output_tileable_variable(op.outputs[0])
+        data_var_name = self.translate_var(context, op.dtrain)
+        call_args = (
+            "params",
+            "dtrain",
+            "evals",
+            "num_boost_round",
+            "early_stopping_rounds",
+            "obj",
+            "feval",
+            "callbacks",
+            "maximize",
+            "verbose_eval",
+            "xgb_model",
+            "callbacks",
+            "custom_metric",
+        )
+        codes = list()
+        args_str = self.generate_call_args_with_attributes(
+            op,
+            context,
+            skip_none=True,
+            kw_keys=call_args,
+        )
+        if op.has_evals_result:
+            evals_result_var = context.get_output_tileable_variable(op.outputs[1])
+            codes.append(f"{evals_result_var} = dict()")
+            args_str = f"{args_str}, evals_result={evals_result_var}"
+
+        expressions = [
+            f"{data_var_name}.num_row()",
+            f"{data_var_name}.num_col()",
+        ]
+        codes.extend(
+            [
+                self.gen_logging_code(
+                    context, "Trained data size: (%s, %s)", expressions
+                ),
+                f"{res_var_name} = xgboost.train({args_str})",
+            ]
+        )
+        return self.gen_timecost_code(context, "Train", codes)
+
+
+@register_op_adapter(XGBPredict)
+class XGBPredictAdapter(_XGBoostAdapter):
+    def generate_code(self, op: XGBPredict, context: SPECodeContext) -> List[str]:
+        super().generate_code(op, context)
+        res_var_name = context.get_output_tileable_variable(op.outputs[0])
+        input_var_name = context.get_input_tileable_variable(op.inputs[0])
+        model_var_name = context.get_input_tileable_variable(op.inputs[1])
+        codes = []
+
+        if isinstance(op.inputs[0].op, ToDMatrix):
+            data_var = input_var_name
+        else:
+            data_var = f"{input_var_name}_data"
+            codes.append(f"{data_var} = xgboost.DMatrix({input_var_name})")
+        # Predict codes
+        call_args = (
+            "output_margin",
+            "pred_leaf",
+            "pred_contribs",
+            "approx_contribs",
+            "pred_interactions",
+            "validate_features",
+            "training",
+            "iteration_range",
+            "strict_shape",
+        )
+        args_str = self.generate_call_args_with_attributes(
+            op, context, skip_none=True, kw_keys=call_args
+        )
+        expressions = [
+            f"{data_var}.num_row()",
+            f"{data_var}.num_col()",
+        ]
+        codes.append(
+            self.gen_logging_code(
+                context, f"Predicted data size: (%s, %s)", expressions
+            ),
+        )
+        codes.append(
+            f"{res_var_name} = {model_var_name}.predict({data_var}, {args_str})"
+        )
+
+        return self.gen_timecost_code(context, "Predict", codes)

maxframe/codegen/spe/learn/metrics/__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 _classification

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

@@ -0,0 +1,120 @@
+# 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._check_targets import CheckTargets
+from .....learn.metrics._classification import (
+    AccuracyScore,
+    MultiLabelConfusionMatrix,
+    PrecisionRecallFScoreSupport,
+)
+from ...core import SPECodeContext, SPEOperatorAdapter, register_op_adapter
+
+
+@register_op_adapter(CheckTargets)
+class CheckTargetsAdapter(SPEOperatorAdapter):
+    def generate_code(self, op: CheckTargets, context: SPECodeContext) -> List[str]:
+        context.register_import(
+            "sklearn.metrics._classification",
+            from_item="_check_targets",
+            alias="sk_check_targets",
+        )
+        call_args = self.generate_call_args_with_attributes(
+            op,
+            context,
+            "y_true",
+            "y_pred",
+            skip_none=True,
+            kw_keys=["normalize", "sample_weight"],
+        )
+        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_check_targets({call_args})"]
+
+
+@register_op_adapter(AccuracyScore)
+class AccuracyScoreAdapter(SPEOperatorAdapter):
+    def generate_code(self, op: AccuracyScore, context: SPECodeContext) -> List[str]:
+        context.register_import(
+            "sklearn.metrics", from_item="accuracy_score", alias="sk_accuracy_score"
+        )
+
+        call_args = self.generate_call_args_with_attributes(
+            op,
+            context,
+            "y_true",
+            "y_pred",
+            skip_none=True,
+            kw_keys=["normalize", "sample_weight"],
+        )
+        res_var_name = context.get_output_tileable_variable(op.outputs[0])
+        return [f"{res_var_name} = sk_accuracy_score({call_args})"]
+
+
+@register_op_adapter(MultiLabelConfusionMatrix)
+class MultiLabelConfusionMatrixAdapter(SPEOperatorAdapter):
+    def generate_code(
+        self, op: MultiLabelConfusionMatrix, context: SPECodeContext
+    ) -> List[str]:
+        context.register_import(
+            "sklearn.metrics",
+            from_item="multilabel_confusion_matrix",
+            alias="sk_multilabel_confusion_matrix",
+        )
+
+        call_args = self.generate_call_args_with_attributes(
+            op,
+            context,
+            "y_true",
+            "y_pred",
+            skip_none=True,
+            kw_keys=["sample_weight", "labels", "samplewise"],
+        )
+        res_var_name = context.get_output_tileable_variable(op.outputs[0])
+        return [f"{res_var_name} = sk_multilabel_confusion_matrix({call_args})"]
+
+
+@register_op_adapter(PrecisionRecallFScoreSupport)
+class PrecisionRecallFScoreSupportAdapter(SPEOperatorAdapter):
+    def generate_code(
+        self, op: PrecisionRecallFScoreSupport, context: SPECodeContext
+    ) -> List[str]:
+        context.register_import(
+            "sklearn.metrics",
+            from_item="precision_recall_fscore_support",
+            alias="sk_precision_recall_fscore_support",
+        )
+
+        call_args = self.generate_call_args_with_attributes(
+            op,
+            context,
+            "y_true",
+            "y_pred",
+            skip_none=True,
+            kw_keys=[
+                "beta",
+                "labels",
+                "pos_label",
+                "average",
+                "warn_for",
+                "sample_weight",
+                "zero_division",
+            ],
+        )
+        out_vars = [context.get_output_tileable_variable(out) for out in op.outputs]
+        if op.output_limit < 4:
+            out_vars.append("_na")
+        out_vars_str = ", ".join(out_vars)
+        return [f"{out_vars_str} = sk_precision_recall_fscore_support({call_args})"]

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

@@ -0,0 +1,13 @@
+# 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.