maxframe 2.4.0rc1__cp312-cp312-win32.whl

maxframe/codegen/spe/tensor/indexing.py

@@ -0,0 +1,63 @@
+# 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 ....tensor.indexing import (
+    TensorIndex,
+    TensorIndexSetValue,
+    TensorNonzero,
+    TensorUnravelIndex,
+)
+from ..core import SPECodeContext, SPEOperatorAdapter, register_op_adapter
+from ..utils import build_method_call_adapter
+
+
+@register_op_adapter(TensorIndex)
+class TensorIndexAdapter(SPEOperatorAdapter):
+    def generate_code(self, op: TensorIndex, context: SPECodeContext) -> List[str]:
+        context.register_import("numpy", "np")
+        indexes_var_name = self.translate_var(context, op.indexes)
+        res_var_name = context.get_output_tileable_variable(op.outputs[0])
+        input_var_name = context.get_input_tileable_variable(op.inputs[0])
+        return [f"{res_var_name} = {input_var_name}[tuple({indexes_var_name})]"]
+
+
+@register_op_adapter(TensorIndexSetValue)
+class TensorIndexSetValueAdapter(SPEOperatorAdapter):
+    def generate_code(
+        self, op: TensorIndexSetValue, context: SPECodeContext
+    ) -> List[str]:
+        context.register_import("numpy", "np")
+        indexes_var_name = self.translate_var(context, op.indexes)
+        res_var_name = context.get_output_tileable_variable(op.outputs[0])
+        input_var_name = context.get_input_tileable_variable(op.inputs[0])
+        value_expr = self.translate_var(context, op.value)
+        return [
+            f"{res_var_name} = {input_var_name}.copy()",
+            f"{res_var_name}[tuple({indexes_var_name})] = {value_expr}",
+        ]
+
+
+TensorNonzeroAdapter = build_method_call_adapter(
+    TensorNonzero, "nonzero", 0, source_module="np"
+)
+TensorUnravelIndexAdapter = build_method_call_adapter(
+    TensorUnravelIndex,
+    "unravel_index",
+    0,
+    skip_none=True,
+    kw_keys=["dims", "order"],
+    source_module="np",
+)

maxframe/codegen/spe/tensor/linalg.py

@@ -0,0 +1,90 @@
+# 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 ....tensor.linalg import (
+    TensorCholesky,
+    TensorEinsum,
+    TensorInv,
+    TensorLU,
+    TensorMatmul,
+    TensorNorm,
+    TensorQR,
+    TensorSolveTriangular,
+    TensorSVD,
+    TensorTensorDot,
+)
+from ..core import SPECodeContext, SPEOperatorAdapter, register_op_adapter
+from ..utils import build_method_call_adapter
+
+TensorCholeskyAdapter = build_method_call_adapter(
+    TensorCholesky, "cholesky", 0, kw_keys=["lower"], source_module="npl"
+)
+TensorInvAdapter = build_method_call_adapter(
+    TensorInv, "inv", "input", source_module="npl"
+)
+TensorLUAdapter = build_method_call_adapter(
+    TensorLU, "lu", "input", source_module="spl"
+)
+TensorMatmulAdapter = build_method_call_adapter(
+    TensorMatmul, "matmul", "a", "b", source_module="np", kw_keys=["casting", "order"]
+)
+TensorNormAdapter = build_method_call_adapter(
+    TensorNorm, "norm", 0, kw_keys=["ord", "axis", "keepdims"], source_module="npl"
+)
+TensorQRAdapter = build_method_call_adapter(TensorQR, "qr", 0, source_module="spl")
+TensorSolveTriangularAdapter = build_method_call_adapter(
+    TensorSolveTriangular,
+    "solve_triangular",
+    "a",
+    "b",
+    source_module="spl",
+    kw_keys=["lower", "strict"],
+)
+TensorSVDAdapter = build_method_call_adapter(TensorSVD, "svd", 0, source_module="spl")
+
+
+@register_op_adapter(TensorEinsum)
+class TensorEinsumAdapter(SPEOperatorAdapter):
+    def generate_code(self, op: TensorEinsum, context: SPECodeContext) -> List[str]:
+        context.register_import("numpy", "np")
+
+        inp_var_names_str = ", ".join(
+            [context.get_input_tileable_variable(inp) for inp in op.inputs]
+        )
+        res_var_name = context.get_output_tileable_variable(op.outputs[0])
+        subscripts_str = self.translate_var(context, op.subscripts)
+        kw_str = self.generate_call_args_with_attributes(
+            op, context, kw_keys=["dtype", "order", "casting"]
+        )
+        return [
+            f"{res_var_name} = np.einsum({subscripts_str}, {inp_var_names_str}, {kw_str})"
+        ]
+
+
+@register_op_adapter(TensorTensorDot)
+class TensorTensorDotAdapter(SPEOperatorAdapter):
+    def generate_code(self, op: TensorTensorDot, context: SPECodeContext) -> List[str]:
+        context.register_import("numpy.linalg", "npl")
+
+        lhs_var_name = context.get_input_tileable_variable(op.inputs[0])
+        rhs_var_name = context.get_input_tileable_variable(op.inputs[1])
+        res_var_name = context.get_output_tileable_variable(op.outputs[0])
+        axes_str = self.generate_call_args_with_attributes(
+            op, context, "a_axes", "b_axes"
+        )
+        return [
+            f"{res_var_name} = npl.tensordot({lhs_var_name}, {rhs_var_name}, ({axes_str}))"
+        ]

maxframe/codegen/spe/tensor/merge.py

@@ -0,0 +1,31 @@
+# Copyright 1999-2025 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import List
+
+from ....tensor.core import Tensor
+from ....tensor.merge.concatenate import TensorConcatenate
+from ..core import SPECodeContext, SPEOperatorAdapter, register_op_adapter
+
+
+@register_op_adapter(TensorConcatenate)
+class TensorConcatenateAdapter(SPEOperatorAdapter):
+    def generate_code(self, op: Tensor, context: SPECodeContext) -> List[str]:
+        context.register_import("numpy", "np")
+        ndarr_str = ", ".join(context.get_input_tileable_variable(k) for k in op.inputs)
+        if len(op.inputs) == 1:
+            ndarr_str += ","
+        res_var_name = context.get_output_tileable_variable(op.outputs[0])
+        axis_var = context.register_operator_constants(op.axis)
+        return [f"{res_var_name} = np.concatenate(({ndarr_str}), axis={axis_var})"]

maxframe/codegen/spe/tensor/misc.py

@@ -0,0 +1,175 @@
+# 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
+
+import numpy as np
+
+from ....tensor.indexing import TensorFillDiagonal
+from ....tensor.misc import (
+    TensorArgwhere,
+    TensorCopyTo,
+    TensorDelete,
+    TensorDiff,
+    TensorGetShape,
+    TensorIsIn,
+    TensorRepeat,
+    TensorSearchsorted,
+    TensorSplit,
+    TensorSqueeze,
+    TensorSwapAxes,
+    TensorTranspose,
+    TensorTrapezoid,
+    TensorUnique,
+    TensorWhere,
+)
+from ....tensor.misc.insert import TensorInsert
+from ..core import SPECodeContext, SPEOperatorAdapter, register_op_adapter
+from ..utils import build_method_call_adapter
+
+_trapz_func = "trapezoid" if hasattr(np, "trapezoid") else "trapz"
+
+
+TensorArgwhereAdapter = build_method_call_adapter(
+    TensorArgwhere, "argwhere", 0, source_module="np"
+)
+TensorDeleteAdapter = build_method_call_adapter(
+    TensorDelete, "delete", 0, "index_obj", kw_keys=["axis"], source_module="np"
+)
+TensorDiffAdapter = build_method_call_adapter(
+    TensorDiff, "diff", 0, skip_none=True, kw_keys=["n", "axis"], source_module="np"
+)
+TensorFillDiagonalAdapter = build_method_call_adapter(
+    TensorFillDiagonal,
+    "fill_diagonal",
+    0,
+    "val",
+    skip_none=True,
+    kw_keys=["wrap"],
+    source_module="np",
+)
+TensorInsertAdapter = build_method_call_adapter(
+    TensorInsert,
+    "insert",
+    0,
+    "index_obj",
+    kw_keys=["values", "axis"],
+    source_module="np",
+)
+TensorIsInAdapter = build_method_call_adapter(
+    TensorIsIn,
+    "isin",
+    0,
+    1,
+    skip_none=True,
+    kw_keys=["assume_unique", "invert"],
+    source_module="np",
+)
+TensorRepeatAdapter = build_method_call_adapter(
+    TensorRepeat,
+    "repeat",
+    0,
+    skip_none=True,
+    kw_keys=["repeats", "axis"],
+    source_module="np",
+)
+TensorSearchsortedAdapter = build_method_call_adapter(
+    TensorSearchsorted,
+    "searchsorted",
+    "a",
+    "v",
+    kw_keys=["side", "sorter"],
+    source_module="np",
+)
+TensorTrapezoidAdapter = build_method_call_adapter(
+    TensorTrapezoid,
+    _trapz_func,
+    skip_none=True,
+    kw_keys=["y", "x", "dx", "axis"],
+    source_module="np",
+)
+TensorSqueezeAdapter = build_method_call_adapter(
+    TensorSqueeze, "squeeze", 0, kw_keys=["axis"], source_module="np"
+)
+TensorSwapAxesAdapter = build_method_call_adapter(
+    TensorSwapAxes, "swapaxes", "axis1", "axis2", source_module="np"
+)
+TensorTransposeAdapter = build_method_call_adapter(
+    TensorTranspose, "transpose", 0, kw_keys=["axes"], source_module="np"
+)
+TensorWhereAdapter = build_method_call_adapter(
+    TensorWhere, "where", "condition", "x", "y", source_module="np"
+)
+
+
+@register_op_adapter(TensorCopyTo)
+class TensorCopyToAdapter(SPEOperatorAdapter):
+    def generate_code(self, op: TensorCopyTo, context: SPECodeContext) -> List[str]:
+        context.register_import("numpy", "np")
+        dst_var_name = context.get_input_tileable_variable(op.inputs[1])
+        src_var_name = context.get_input_tileable_variable(op.inputs[0])
+        res_var_name = context.get_output_tileable_variable(op.outputs[0])
+        args_str = self.generate_call_args_with_attributes(
+            op, context, kw_keys=["casting", "where"], skip_none=True
+        )
+        return [
+            f"{res_var_name} = {dst_var_name}.copy()",
+            f"np.copyto({res_var_name}, {src_var_name}, {args_str})",
+        ]
+
+
+@register_op_adapter(TensorGetShape)
+class TensorGetShapeAdapter(SPEOperatorAdapter):
+    def generate_code(self, op: TensorGetShape, context: SPECodeContext) -> List[str]:
+        context.register_import("numpy", "np")
+        input_var_name = context.get_input_tileable_variable(op.inputs[0])
+        res_var_names = ", ".join(
+            context.get_output_tileable_variable(out) for out in op.outputs
+        )
+        return [f"{res_var_names} = np.shape({input_var_name})"]
+
+
+@register_op_adapter(TensorSplit)
+class TensorSplitAdapter(SPEOperatorAdapter):
+    def generate_code(self, op: TensorSplit, context: SPECodeContext) -> List[str]:
+        context.register_import("numpy", "np")
+        input_var_name = context.get_input_tileable_variable(op.inputs[0])
+        res_var_names = ", ".join(
+            context.get_output_tileable_variable(out) for out in op.outputs
+        )
+        idx_var = self.translate_var(context, op.indices_or_sections)
+        axis_var = self.translate_var(context, op.axis)
+        return [
+            f"{res_var_names} = np.split({input_var_name}, {idx_var} axis={axis_var})"
+        ]
+
+
+@register_op_adapter(TensorUnique)
+class TensorUniqueAdapter(SPEOperatorAdapter):
+    def generate_code(self, op, context):
+        context.register_import("numpy", "np")
+        input_var_name = context.get_input_tileable_variable(op.inputs[0])
+        output_var_names = [
+            context.get_output_tileable_variable(out) for out in op.outputs
+        ]
+        return_index_var = self.translate_var(context, op.return_index)
+        return_inverse_var = self.translate_var(context, op.return_inverse)
+        return_counts_var = self.translate_var(context, op.return_counts)
+        axis_var = self.translate_var(context, op.axis)
+        return [
+            f"{', '.join(output_var_names)} = "
+            f"np.unique({input_var_name}, return_index={return_index_var}, "
+            f"return_inverse={return_inverse_var}, return_counts={return_counts_var}, "
+            f"axis={axis_var})"
+        ]

maxframe/codegen/spe/tensor/random.py

@@ -0,0 +1,29 @@
+# Copyright 1999-2025 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import List
+
+from ....tensor.random.rand import TensorRand
+from ..core import SPECodeContext, SPEOperatorAdapter, register_op_adapter
+
+
+@register_op_adapter(TensorRand)
+class TensorRandAdapter(SPEOperatorAdapter):
+    def generate_code(self, op: TensorRand, context: SPECodeContext) -> List[str]:
+        context.register_import("numpy", "np")
+        # Use shape to achieve backward compatibility for 1.0 SDK
+        shape = op.size or op.outputs[0].shape
+        shape_str = ", ".join(str(x) for x in shape) if shape else ""
+        res_var_name = context.get_output_tileable_variable(op.outputs[0])
+        return [f"{res_var_name} = np.random.rand({shape_str})"]

maxframe/codegen/spe/tensor/reduction.py

@@ -0,0 +1,39 @@
+# 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 ....tensor.reduction.core import TensorCumReduction, TensorReduction
+from ....tensor.reduction.nanvar import TensorNanVar
+from ....tensor.reduction.var import TensorVar
+from ..core import register_op_adapter
+from .core import TensorUnaryCommonAdapter
+
+
+@register_op_adapter(TensorReduction)
+class TensorReductionAdapter(TensorUnaryCommonAdapter):
+    def _get_op_kw_args(self, op: TensorReduction) -> List[str]:
+        return ["axis", "keepdims"]
+
+
+@register_op_adapter([TensorVar, TensorNanVar])
+class TensorVarAdapter(TensorReductionAdapter):
+    def _get_op_kw_args(self, op: TensorReduction) -> List[str]:
+        return super()._get_op_kw_args(op) + ["ddof"]
+
+
+@register_op_adapter(TensorCumReduction)
+class TensorCumReductionAdapter(TensorUnaryCommonAdapter):
+    def _get_op_kw_args(self, op: TensorCumReduction) -> List[str]:
+        return ["axis"]

maxframe/codegen/spe/tensor/reshape.py

@@ -0,0 +1,26 @@
+# 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 ....tensor.reshape.reshape import TensorReshape
+from ..utils import build_method_call_adapter
+
+TensorReshapeAdapter = build_method_call_adapter(
+    TensorReshape,
+    "reshape",
+    "input",
+    "newshape",
+    "order",
+    skip_none=True,
+    source_module="np",
+)

maxframe/codegen/spe/tensor/sort.py

@@ -0,0 +1,42 @@
+# 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 ....tensor.sort.sort import TensorSort
+from ..core import SPECodeContext, SPEOperatorAdapter, register_op_adapter
+
+
+@register_op_adapter(TensorSort)
+class TensorSortAdapter(SPEOperatorAdapter):
+    def generate_code(self, op: TensorSort, context: SPECodeContext) -> List[str]:
+        input_var_name = context.get_input_tileable_variable(op.inputs[0])
+        res_var_names = [
+            context.get_output_tileable_variable(out) for out in op.outputs
+        ]
+        res_name_iter = iter(res_var_names)
+
+        axes_str = self.generate_call_args_with_attributes(
+            op, context, kw_keys=["axis", "kind", "order"]
+        )
+        lines = []
+        if op.return_value:
+            lines.append(
+                f"{next(res_name_iter)} = np.sort({input_var_name}, {axes_str})"
+            )
+        if op.return_indices:
+            lines.append(
+                f"{next(res_name_iter)} = np.argsort({input_var_name}, {axes_str})"
+            )
+        return lines

maxframe/codegen/spe/tensor/spatial.py

@@ -0,0 +1,45 @@
+# 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 ....tensor.spatial.distance.cdist import TensorCDist
+from ....tensor.spatial.distance.pdist import TensorPDist
+from ....tensor.spatial.distance.squareform import TensorSquareForm
+from ..utils import build_method_call_adapter
+
+TensorCDistAdapter = build_method_call_adapter(
+    TensorCDist,
+    "cdist",
+    "xa",
+    "xb",
+    kw_keys=["metric", "p", "w"],
+    v="V",
+    vi="VI",
+    source_module="scipy.spatial.distance",
+)
+TensorPDistAdapter = build_method_call_adapter(
+    TensorPDist,
+    "pdist",
+    0,
+    kw_keys=["metric", "p", "w"],
+    v="V",
+    vi="VI",
+    source_module="scipy.spatial.distance",
+)
+TensorSquareFormAdapter = build_method_call_adapter(
+    TensorSquareForm,
+    "squareform",
+    0,
+    kw_keys=["checks"],
+    source_module="scipy.spatial.distance",
+)

maxframe/codegen/spe/tensor/special.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 ....tensor.special.core import TensorSpecialUnaryOp
+from ..core import SPECodeContext
+from .core import TensorUnaryCommonAdapter
+
+
+class TensorSpecialUnaryOpAdapter(TensorUnaryCommonAdapter):
+    @classmethod
+    def _gen_func_name(cls, op: TensorSpecialUnaryOp):
+        return f"spspecial.{op._func_name}"
+
+    @classmethod
+    def _get_op_kw_args(self, op: TensorSpecialUnaryOp) -> List[str]:
+        return []
+
+    def generate_code(
+        self, op: TensorSpecialUnaryOp, context: SPECodeContext
+    ) -> List[str]:
+        context.register_import("scipy.special", "spspecial")
+        return super().generate_code(op, context)

maxframe/codegen/spe/tensor/statistics.py

@@ -0,0 +1,68 @@
+# 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 ....tensor.statistics.bincount import TensorBinCount
+from ....tensor.statistics.digitize import TensorDigitize
+from ....tensor.statistics.histogram import TensorHistogram, TensorHistogramBinEdges
+from ....tensor.statistics.quantile import TensorQuantile
+from ..core import SPECodeContext, SPEOperatorAdapter, register_op_adapter
+from ..utils import build_method_call_adapter
+
+TensorBinCountAdapter = build_method_call_adapter(
+    TensorBinCount,
+    "bincount",
+    0,
+    kw_keys=["weights", "minlength"],
+    source_module="np",
+)
+TensorDigitizeAdapter = build_method_call_adapter(
+    TensorDigitize,
+    "digitize",
+    0,
+    kw_keys=["bins", "right"],
+    source_module="np",
+)
+TensorHistogramBinEdgesAdapter = build_method_call_adapter(
+    TensorHistogramBinEdges,
+    "histogram_bin_edges",
+    0,
+    kw_keys=["bins", "range", "weights"],
+    source_module="np",
+)
+TensorQuantileAdapter = build_method_call_adapter(
+    TensorQuantile,
+    "quantile",
+    0,
+    kw_keys=["q", "axis", "overwrite_input", "interpolation", "keepdims"],
+    source_module="np",
+)
+
+
+@register_op_adapter(TensorHistogram)
+class TensorHistogramAdapter(SPEOperatorAdapter):
+    def generate_code(self, op: TensorHistogram, context: SPECodeContext) -> List[str]:
+        context.register_import("numpy", "np")
+
+        inp_var_name = context.get_input_tileable_variable(op.inputs[0])
+        res_var_names = ", ".join(
+            context.get_output_tileable_variable(out) for out in op.outputs
+        )
+        if not op.ret_bins:
+            res_var_names += ", _"
+        kw_str = self.generate_call_args_with_attributes(
+            op, context, kw_keys=["bins", "range", "density", "weights"]
+        )
+        return [f"{res_var_names} = np.histogram({inp_var_name}, {kw_str})"]

maxframe/codegen/spe/tensor/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.