maxframe 2.4.0rc1__cp312-cp312-win32.whl

maxframe/codegen/spe/learn/model_selection/tests/test_split.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 numpy as np
+
+from ...... import tensor as mt
+from ......core.graph.builder.utils import build_graph
+from ......learn.model_selection import train_test_split
+from ....core import SPECodeGenerator
+
+
+def test_train_test_split_without_shuffling():
+    X, y = mt.arange(10).reshape((5, 2)), range(5)
+    X_train, X_test, y_train, y_test = train_test_split(X, y, shuffle=False)
+    graph = build_graph([X_train, X_test, y_train, y_test])
+    codegen = SPECodeGenerator("test_1")
+    code = codegen.generate_code(graph)
+
+    local_vars = codegen._context.constants.copy()
+    exec("\n".join(code), local_vars, local_vars)
+
+    def _get_result(tileable):
+        return local_vars[
+            codegen._context.get_output_tileable_variable(tileable.op.outputs[0])
+        ]
+
+    assert np.array_equal(np.array([[0, 1], [2, 3], [4, 5]]), _get_result(X_train))
+    assert np.array_equal(np.array([[6, 7], [8, 9]]), _get_result(X_test))
+    assert np.array_equal(np.array([0, 1, 2]), _get_result(y_train))
+    assert np.array_equal(np.array([3, 4]), _get_result(y_test))

maxframe/codegen/spe/learn/preprocessing/__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 _data

maxframe/codegen/spe/learn/preprocessing/_data.py

@@ -0,0 +1,37 @@
+# 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.preprocessing._data.normalize import TensorNormalize
+from .....typing_ import OperatorType
+from ...core import SPECodeContext, SPEOperatorAdapter, register_op_adapter
+
+
+@register_op_adapter(TensorNormalize)
+class TensorNormalizeAdapter(SPEOperatorAdapter):
+    def generate_code(self, op: OperatorType, context: SPECodeContext) -> List[str]:
+        context.register_import(
+            "sklearn.preprocessing", from_item="normalize", alias="sk_normalize"
+        )
+
+        call_args = self.generate_call_args_with_attributes(
+            op,
+            context,
+            "input",
+            skip_none=True,
+            kw_keys=["norm", "axis", "return_norm"],
+        )
+        res_var_name = context.get_output_tileable_variable(op.outputs[0])
+        return [f"{res_var_name} = sk_normalize({call_args})"]

maxframe/codegen/spe/learn/preprocessing/_label.py

@@ -0,0 +1,47 @@
+# 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.preprocessing._label._label_binarizer import LabelBinarizeOp
+from ...core import SPECodeContext, SPEOperatorAdapter, register_op_adapter
+
+
+@register_op_adapter(LabelBinarizeOp)
+class LabelBinarizeOpAdapter(SPEOperatorAdapter):
+    def generate_code(self, op: LabelBinarizeOp, context: SPECodeContext) -> List[str]:
+        context.register_import("numpy", "np")
+        context.register_import(
+            "sklearn.preprocessing",
+            from_item="label_binarize",
+            alias="sk_label_binarize",
+        )
+        if op.n_classes is not None:
+            classes_arg = f"np.arange({op.n_classes})"
+        else:
+            classes_arg = self.translate_var(context, op.classes)
+        call_args = self.generate_call_args_with_attributes(
+            op,
+            context,
+            skip_none=True,
+            kw_keys=["neg_label", "pos_label", "sparse_output"],
+        )
+        if call_args:
+            call_args = ", " + call_args
+        inp_var_name = context.get_input_tileable_variable(op.inputs[0])
+        res_var_name = context.get_output_tileable_variable(op.outputs[0])
+        return [
+            f"{res_var_name} = sk_label_binarize({inp_var_name}, "
+            f"classes={classes_arg}{call_args})"
+        ]

maxframe/codegen/spe/learn/preprocessing/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/preprocessing/tests/test_data.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 ...... import tensor as mt
+from ......learn.preprocessing import normalize
+from ....core import SPECodeContext
+from .._data import TensorNormalizeAdapter
+
+
+def test_normalize():
+    t1 = mt.array([[1, 2, 3], [4, 5, 6]])
+    result = normalize(t1, norm="l1")
+
+    adapter = TensorNormalizeAdapter()
+    context = SPECodeContext()
+    results = adapter.generate_code(result.op, context)
+    expected_results = [
+        "var_1 = sk_normalize(var_0, norm='l1', axis=1, return_norm=False)"
+    ]
+    assert results == expected_results

maxframe/codegen/spe/learn/preprocessing/tests/test_label.py

@@ -0,0 +1,43 @@
+# 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.preprocessing._label import _label_binarize, label_binarize
+from ....core import SPECodeContext
+from .._label import LabelBinarizeOpAdapter
+
+
+def test_label_binarize():
+    arr = mt.array([0, 1, 2])
+    result = label_binarize(arr, classes=[0, 1, 2])
+
+    adapter = LabelBinarizeOpAdapter()
+    context = SPECodeContext()
+    results = adapter.generate_code(result.op, context)
+    expected_results = [
+        "var_1 = sk_label_binarize(var_0, classes=[0, 1, 2], neg_label=0, "
+        "pos_label=1, sparse_output=False)"
+    ]
+    assert results == expected_results
+
+    result = _label_binarize(arr, n_classes=3)
+
+    adapter = LabelBinarizeOpAdapter()
+    context = SPECodeContext()
+    results = adapter.generate_code(result.op, context)
+    expected_results = [
+        "var_1 = sk_label_binarize(var_0, classes=np.arange(3), neg_label=0, "
+        "pos_label=1, sparse_output=False)"
+    ]
+    assert results == expected_results

maxframe/codegen/spe/learn/utils/__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 checks, multiclass, sparsefuncs, validation

maxframe/codegen/spe/learn/utils/checks.py

@@ -0,0 +1,55 @@
+# 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.utils.checks import AssertAllFinite, CheckNonNegative
+from ...core import SPECodeContext, SPEOperatorAdapter, register_op_adapter
+
+
+@register_op_adapter(AssertAllFinite)
+class AssertAllFiniteAdapter(SPEOperatorAdapter):
+    def generate_code(self, op: AssertAllFinite, context: SPECodeContext) -> List[str]:
+        context.register_import(
+            "sklearn.utils", from_item="assert_all_finite", alias="sk_assert_all_finite"
+        )
+
+        call_args = self.generate_call_args_with_attributes(
+            op,
+            context,
+            "x",
+            skip_none=True,
+            kw_keys=["allow_nan", "msg_dtype", "check_only"],
+        )
+        res_var_name = context.get_output_tileable_variable(op.outputs[0])
+        return [f"{res_var_name} = sk_assert_all_finite({call_args})"]
+
+
+@register_op_adapter(CheckNonNegative)
+class CheckNonNegativeAdapter(SPEOperatorAdapter):
+    def generate_code(self, op: CheckNonNegative, context: SPECodeContext) -> List[str]:
+        context.register_import(
+            "sklearn.utils.validation",
+            from_item="check_non_negative",
+            alias="sk_check_non_negative",
+        )
+        call_args = self.generate_call_args_with_attributes(
+            op, context, "input", skip_none=True, kw_keys=["whom"]
+        )
+        val_var_name = context.get_input_tileable_variable(op.value)
+        res_var_name = context.get_output_tileable_variable(op.outputs[0])
+        return [
+            f"sk_check_non_negative({call_args})",
+            f"{res_var_name} = {val_var_name}",
+        ]

maxframe/codegen/spe/learn/utils/multiclass.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.
+
+from typing import List
+
+from .....learn.utils.multiclass import IsMultilabel, TypeOfTarget, UniqueLabels
+from ...core import SPECodeContext, SPEOperatorAdapter, register_op_adapter
+
+
+@register_op_adapter(UniqueLabels)
+class UniqueLabelsAdapter(SPEOperatorAdapter):
+    def generate_code(self, op: UniqueLabels, context: SPECodeContext) -> List[str]:
+        context.register_import(
+            "sklearn.utils.multiclass",
+            from_item="unique_labels",
+            alias="sk_unique_labels",
+        )
+
+        call_args = [self.translate_var(context, v) for v in op.ys]
+        res_var_name = context.get_output_tileable_variable(op.outputs[0])
+        return [f"{res_var_name} = sk_unique_labels({', '.join(call_args)})"]
+
+
+@register_op_adapter(IsMultilabel)
+class IsMultilabelAdapter(SPEOperatorAdapter):
+    def generate_code(self, op: IsMultilabel, context: SPECodeContext) -> List[str]:
+        context.register_import(
+            "sklearn.utils.multiclass",
+            from_item="is_multilabel",
+            alias="sk_is_multilabel",
+        )
+
+        call_args = self.generate_call_args_with_attributes(op, context, "y")
+        res_var_name = context.get_output_tileable_variable(op.outputs[0])
+        return [f"{res_var_name} = sk_is_multilabel({call_args})"]
+
+
+@register_op_adapter(TypeOfTarget)
+class TypeOfTargetAdapter(SPEOperatorAdapter):
+    def generate_code(self, op: TypeOfTarget, context: SPECodeContext) -> List[str]:
+        context.register_import(
+            "sklearn.utils.multiclass",
+            from_item="type_of_target",
+            alias="sk_type_of_target",
+        )
+
+        call_args = self.generate_call_args_with_attributes(op, context, "y")
+        res_var_name = context.get_output_tileable_variable(op.outputs[0])
+        return [f"{res_var_name} = sk_type_of_target({call_args})"]

maxframe/codegen/spe/learn/utils/shuffle.py

@@ -0,0 +1,85 @@
+# 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.core import DATAFRAME_TYPE, SERIES_TYPE
+from .....learn.utils.shuffle import LearnShuffle
+from ...core import SPECodeContext, SPEOperatorAdapter, register_op_adapter
+
+
+@register_op_adapter(LearnShuffle)
+class LearnShuffleAdapter(SPEOperatorAdapter):
+    def generate_code(self, op: LearnShuffle, context: SPECodeContext) -> List[str]:
+        if op.axes == (0,):
+            context.register_import(
+                "sklearn.utils",
+                from_item="shuffle",
+                alias="sk_shuffle",
+            )
+            call_args = [self.translate_var(context, v) for v in op.inputs]
+            if op.n_samples:
+                call_args.append(
+                    "n_samples=" + self.translate_var(context, op.n_samples)
+                )
+            rs_arg = self.translate_var(context, op.seeds[0])
+            res_var_names = [
+                context.get_output_tileable_variable(out) for out in op.outputs
+            ]
+            res_var_names_str = ", ".join(res_var_names)
+            return [
+                f"{res_var_names[0]}_rs = np.random.RandomState({rs_arg})",
+                f"{res_var_names_str} = sk_shuffle({', '.join(call_args)}, "
+                f"random_state={res_var_names[0]}_rs)",
+            ]
+        else:
+            lines = []
+            out0_var_name = context.get_output_tileable_variable(op.outputs[0])
+            if op.n_samples:
+                n_samples_str = self.translate_var(context, op.n_samples)
+            else:
+                n_samples_str = None
+
+            axis_generated = set()
+            for axis, seed in zip(op.axes, op.seeds):
+                seed_arg = self.translate_var(context, seed)
+                lines.append(
+                    f"{out0_var_name}_rs{axis} = np.random.RandomState({seed_arg})",
+                )
+            for idx, inp in enumerate(op.inputs):
+                inp_var_name = self.translate_var(context, inp)
+                out_var_name = context.get_output_tileable_variable(op.outputs[idx])
+                idx_parts = []
+                for axis in range(inp.ndim):
+                    if axis not in op.axes:
+                        idx_parts.append(":")
+                    else:
+                        if axis not in axis_generated:
+                            shape_str = f"{inp_var_name}.shape[{axis}]"
+                            if n_samples_str:
+                                samples_str = f"min({n_samples_str}, {shape_str})"
+                            else:
+                                samples_str = shape_str
+                            lines.append(
+                                f"{out0_var_name}_axis{axis} ="
+                                f" {out0_var_name}_rs{axis}.randint("
+                                f"0, {shape_str}, {samples_str})"
+                            )
+                        idx_parts.append(f"{out0_var_name}_axis{axis}")
+                idx_str = ", ".join(idx_parts)
+                if isinstance(inp, (DATAFRAME_TYPE, SERIES_TYPE)):
+                    lines.append(f"{out_var_name} = {inp_var_name}.iloc[{idx_str}]")
+                else:
+                    lines.append(f"{out_var_name} = {inp_var_name}[{idx_str}]")
+            return lines

maxframe/codegen/spe/learn/utils/sparsefuncs.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 typing import List
+
+from .....learn.utils.sparsefuncs import LearnCountNonzero
+from ...core import SPECodeContext, SPEOperatorAdapter, register_op_adapter
+
+
+@register_op_adapter(LearnCountNonzero)
+class LearnCountNonzeroAdapter(SPEOperatorAdapter):
+    def generate_code(
+        self, op: LearnCountNonzero, context: SPECodeContext
+    ) -> List[str]:
+        context.register_import(
+            "sklearn.utils.sparsefuncs",
+            from_item="count_nonzero",
+            alias="sk_count_nonzero",
+        )
+        call_args = self.generate_call_args_with_attributes(
+            op, context, 0, kw_keys=["axis", "sample_weight"]
+        )
+        res_var_name = context.get_output_tileable_variable(op.outputs[0])
+        return [f"{res_var_name} = sk_count_nonzero({call_args})"]

maxframe/codegen/spe/learn/utils/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/utils/tests/test_checks.py

@@ -0,0 +1,48 @@
+# 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.utils.checks import (
+    assert_all_finite,
+    check_non_negative_then_return_value,
+)
+from ....core import SPECodeContext
+from ..checks import AssertAllFiniteAdapter, CheckNonNegativeAdapter
+
+
+def test_assert_all_finite():
+    t1 = mt.array([[2, mt.nan, mt.inf], [mt.inf, mt.nan, 2]])
+    result = assert_all_finite(t1)
+
+    adapter = AssertAllFiniteAdapter()
+    context = SPECodeContext()
+    results = adapter.generate_code(result.op, context)
+    expected_results = [
+        "var_1 = sk_assert_all_finite(var_0, allow_nan=False, check_only=True)"
+    ]
+    assert results == expected_results
+
+
+def test_check_non_negative():
+    t1 = mt.array([2, -1, 2])
+    result = check_non_negative_then_return_value(t1, t1, "check")
+
+    adapter = CheckNonNegativeAdapter()
+    context = SPECodeContext()
+    results = adapter.generate_code(result.op, context)
+    expected_results = [
+        "sk_check_non_negative(var_0, whom='check')",
+        "var_1 = var_0",
+    ]
+    assert results == expected_results

maxframe/codegen/spe/learn/utils/tests/test_multiclass.py

@@ -0,0 +1,52 @@
+# 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.utils.multiclass import is_multilabel, type_of_target, unique_labels
+from ....core import SPECodeContext
+from ..multiclass import IsMultilabelAdapter, TypeOfTargetAdapter, UniqueLabelsAdapter
+
+
+def test_is_multilabel():
+    t1 = mt.array([1, 2, 3, 4])
+    result = is_multilabel(t1)
+
+    adapter = IsMultilabelAdapter()
+    context = SPECodeContext()
+    results = adapter.generate_code(result.op, context)
+    expected_results = ["var_1 = sk_is_multilabel(var_0)"]
+    assert results == expected_results
+
+
+def test_type_of_target():
+    t1 = mt.array(["a", "b", "a"])
+    result = type_of_target(t1)
+
+    adapter = TypeOfTargetAdapter()
+    context = SPECodeContext()
+    results = adapter.generate_code(result.op, context)
+    expected_results = ["var_1 = sk_type_of_target(var_0)"]
+    assert results == expected_results
+
+
+def test_unique_labels():
+    t1 = mt.array([1, 2, 3, 4])
+    t2 = mt.array([2, 2, 3, 4])
+    result = unique_labels(t1, t2)
+
+    adapter = UniqueLabelsAdapter()
+    context = SPECodeContext()
+    results = adapter.generate_code(result.op, context)
+    expected_results = ["var_2 = sk_unique_labels(var_0, var_1)"]
+    assert results == expected_results

maxframe/codegen/spe/learn/utils/tests/test_shuffle.py

@@ -0,0 +1,50 @@
+# 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 ...... import tensor as mt
+from ......learn.utils import shuffle
+from ....core import SPECodeContext
+from ..shuffle import LearnShuffleAdapter
+
+
+def test_shuffle():
+    X = mt.array([[1.0, 0.0], [2.0, 1.0], [0.0, 0.0]])
+    y = mt.array([0, 1, 2])
+    df = md.DataFrame([["a", 1], ["b", 2], ["c", 3]], columns=["a", "b"])
+
+    rx, ry, rdf = shuffle(X, y, df, random_state=0)
+    adapter = LearnShuffleAdapter()
+    context = SPECodeContext()
+    results = adapter.generate_code(rx.op, context)
+    expected_results = [
+        "var_3_rs = np.random.RandomState(2357136044)",
+        "var_3, var_4, var_5 = sk_shuffle("
+        "var_0, var_1, var_2, random_state=var_3_rs)",
+    ]
+    assert results == expected_results
+
+    rx, ry, rdf = shuffle(X, y, df, random_state=0, axes=(1,))
+    adapter = LearnShuffleAdapter()
+    context = SPECodeContext()
+    results = adapter.generate_code(rx.op, context)
+    expected_results = [
+        "var_0_rs1 = np.random.RandomState(2357136044)",
+        "var_0_axis1 = var_0_rs1.randint(0, var_1.shape[1], var_1.shape[1])",
+        "var_0 = var_1[:, var_0_axis1]",
+        "var_3 = var_2[:]",
+        "var_0_axis1 = var_0_rs1.randint(0, var_4.shape[1], var_4.shape[1])",
+        "var_5 = var_4.iloc[:, var_0_axis1]",
+    ]
+    assert results == expected_results