maxframe 1.3.0__cp311-cp311-macosx_10_9_universal2.whl → 2.0.0b1__cp311-cp311-macosx_10_9_universal2.whl

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

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

@@ -0,0 +1,34 @@
+# 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 ......learn.utils import count_nonzero
+from ....core import SPECodeContext
+from ..sparsefuncs import LearnCountNonzeroAdapter
+
+
+def test_sparsefuncs():
+    t1 = mt.array([1, 2, 3, 4])
+    t1._shape = (np.nan,)
+    result = count_nonzero(t1)
+
+    adapter = LearnCountNonzeroAdapter()
+    context = SPECodeContext()
+    results = adapter.generate_code(result.op, context)
+    expected_results = [
+        "var_1 = sk_count_nonzero(var_0, axis=None, sample_weight=None)"
+    ]
+    assert results == expected_results

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

@@ -0,0 +1,44 @@
+# 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 ......learn.utils import check_consistent_length
+from ....core import SPECodeContext
+from ..validation import CheckConsistentLengthAdapter
+
+
+def test_check_consistent_length():
+    t1 = mt.array([1, 2, 3, 4])
+    t1._shape = (np.nan,)
+    result = check_consistent_length(t1)
+
+    adapter = CheckConsistentLengthAdapter()
+    context = SPECodeContext()
+    results = adapter.generate_code(result[0].op, context)
+    expected_results = ["var_1 = check_consistent_length(var_0)"]
+    assert results == expected_results
+
+    t2 = mt.array([1, 2, 3, 5])
+    t2._shape = (np.nan,)
+
+    result = check_consistent_length(t1, t2, ref_length=4)
+    adapter = CheckConsistentLengthAdapter()
+    context = SPECodeContext()
+    results = adapter.generate_code(result[0].op, context)
+    expected_results = [
+        "var_2, var_3 = check_consistent_length(var_0, var_1, ref_length=4)"
+    ]
+    assert results == expected_results

maxframe/codegen/spe/learn/utils/validation.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.validation import CheckConsistentLength
+from ...core import SPECodeContext, SPEOperatorAdapter, register_op_adapter
+
+
+@register_op_adapter(CheckConsistentLength)
+class CheckConsistentLengthAdapter(SPEOperatorAdapter):
+    def generate_code(
+        self, op: CheckConsistentLength, context: SPECodeContext
+    ) -> List[str]:
+        context.register_import(
+            "maxframe.learn.utils.validation", from_item="check_consistent_length"
+        )
+        inp_vars = [context.get_input_tileable_variable(inp) for inp in op.inputs]
+        inp_vars_str = ", ".join(inp_vars)
+        if op.ref_length is not None:
+            inp_vars_str += f", ref_length={op.ref_length}"
+        out_vars = [context.get_output_tileable_variable(out) for out in op.outputs]
+        out_vars_str = ", ".join(out_vars)
+        return [f"{out_vars_str} = check_consistent_length({inp_vars_str})"]

maxframe/codegen/spe/objects.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 typing import List
+
+from ...core.operator.objects import ObjectFetch
+from .core import SPECodeContext, SPEOperatorAdapter, register_op_adapter
+
+
+@register_op_adapter(ObjectFetch)
+class TensorFetchAdapter(SPEOperatorAdapter):
+    def generate_code(self, op: ObjectFetch, context: SPECodeContext) -> List[str]:
+        # Simply register Fetch as SPE-executable.
+        # Actual codegen is done inside code generator itself.
+        return []

maxframe/codegen/spe/remote.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 ...remote.core import RemoteFunction
+from .core import SPECodeContext, SPEOperatorAdapter, register_op_adapter
+
+
+@register_op_adapter(RemoteFunction)
+class RemoteFunctionAdapter(SPEOperatorAdapter):
+    def generate_code(self, op: RemoteFunction, context: SPECodeContext) -> List[str]:
+        args_str = ", ".join(
+            self._translate_call_args(context, *op.function_args, **op.function_kwargs)
+        )
+        res_var_name = context.get_output_tileable_variable(op.outputs[0])
+        func_var_name = context.register_operator_constants(op.function)
+        return [f"{res_var_name} = {func_var_name}({args_str})"]

maxframe/codegen/spe/tensor/__init__.py

@@ -0,0 +1,28 @@
+# 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 (
+    arithmetic,
+    datasource,
+    extensions,
+    fetch,
+    indexing,
+    linalg,
+    merge,
+    misc,
+    random,
+    reduction,
+    reshape,
+    special,
+)

maxframe/codegen/spe/tensor/arithmetic.py

@@ -0,0 +1,95 @@
+# 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.arithmetic.angle import TensorAngle
+from ....tensor.arithmetic.around import TensorAround
+from ....tensor.arithmetic.core import TensorBinOp, TensorUnaryOp
+from ....tensor.arithmetic.isclose import TensorIsclose
+from ....tensor.arithmetic.setimag import TensorSetImag
+from ....tensor.arithmetic.setreal import TensorSetReal
+from ..core import SPECodeContext, SPEOperatorAdapter, register_op_adapter
+from .core import TensorUnaryCommonAdapter
+
+
+@register_op_adapter(TensorUnaryOp)
+class TensorUnaryOpAdapter(TensorUnaryCommonAdapter):
+    def _get_op_kw_args(self, op: TensorUnaryOp) -> List[str]:
+        return ["casting", "order", "where"]
+
+
+@register_op_adapter(TensorAngle)
+class TensorAngleAdapter(TensorUnaryOpAdapter):
+    def _get_op_kw_args(self, op: TensorAngle) -> List[str]:
+        return ["deg"]
+
+
+@register_op_adapter(TensorAround)
+class TensorAroundAdapter(TensorUnaryOpAdapter):
+    def _get_op_kw_args(self, op: TensorAround) -> List[str]:
+        return ["decimals"]
+
+
+@register_op_adapter(TensorBinOp)
+class TensorBinOpAdapter(SPEOperatorAdapter):
+    def generate_code(self, op: TensorBinOp, context: SPECodeContext) -> List[str]:
+        context.register_import("numpy", "np")
+        call_args = self.generate_call_args_with_attributes(
+            op,
+            context,
+            "lhs",
+            "rhs",
+            skip_none=True,
+            kw_keys=self._get_op_kw_args(op),
+        )
+        res_var_name = context.get_output_tileable_variable(op.outputs[0])
+        return [f"{res_var_name} = np.{op._func_name}({call_args})"]
+
+    def _get_op_kw_args(self, op: TensorBinOp) -> List[str]:
+        return ["casting", "order", "where"]
+
+
+@register_op_adapter(TensorIsclose)
+class TensorIscloseAdapter(TensorBinOpAdapter):
+    def _get_op_kw_args(self, op: TensorIsclose) -> List[str]:
+        return ["equal_nan", "rtol", "atol"]
+
+
+@register_op_adapter(TensorSetImag)
+class TensorSetImagAdapter(SPEOperatorAdapter):
+    def generate_code(self, op: TensorSetImag, context: SPECodeContext) -> List[str]:
+        context.register_import("numpy", "np")
+
+        source_var_name = context.get_input_tileable_variable(op.inputs[0])
+        imag_var_name = context.get_input_tileable_variable(op.inputs[1])
+        res_var_name = context.get_output_tileable_variable(op.outputs[0])
+        return [
+            f"{source_var_name}.imag = {imag_var_name}",
+            f"{res_var_name} = {source_var_name}",
+        ]
+
+
+@register_op_adapter(TensorSetReal)
+class TensorSetRealAdapter(SPEOperatorAdapter):
+    def generate_code(self, op: TensorSetReal, context: SPECodeContext) -> List[str]:
+        context.register_import("numpy", "np")
+
+        source_var_name = context.get_input_tileable_variable(op.inputs[0])
+        imag_var_name = context.get_input_tileable_variable(op.inputs[1])
+        res_var_name = context.get_output_tileable_variable(op.outputs[0])
+        return [
+            f"{source_var_name}.real = {imag_var_name}",
+            f"{res_var_name} = {source_var_name}",
+        ]

maxframe/codegen/spe/tensor/core.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.
+
+from abc import ABC, abstractmethod
+from typing import List
+
+from ....tensor.operators import TensorOperator
+from ..core import SPECodeContext, SPEOperatorAdapter
+
+
+class TensorUnaryCommonAdapter(SPEOperatorAdapter, ABC):
+    @classmethod
+    def _gen_func_name(cls, op: TensorOperator):
+        return f"np.{op._func_name}"
+
+    def generate_code(self, op: TensorOperator, context: SPECodeContext) -> List[str]:
+        context.register_import("numpy", "np")
+        call_args = self.generate_call_args_with_attributes(
+            op,
+            context,
+            "_input",
+            skip_none=True,
+            kw_keys=self._get_op_kw_args(op),
+        )
+        res_var_name = context.get_output_tileable_variable(op.outputs[0])
+        return [f"{res_var_name} = {self._gen_func_name(op)}({call_args})"]
+
+    @abstractmethod
+    def _get_op_kw_args(self, op: TensorOperator) -> List[str]:
+        raise NotImplementedError

maxframe/codegen/spe/tensor/datasource.py

@@ -0,0 +1,165 @@
+# 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, Union
+
+from ....tensor.datasource import (
+    Scalar,
+    TensorArange,
+    TensorDiag,
+    TensorEmpty,
+    TensorEye,
+    TensorLinspace,
+    TensorOnesLike,
+    TensorTril,
+    TensorZeros,
+    TensorZerosLike,
+)
+from ....tensor.datasource.array import ArrayDataSource
+from ....tensor.datasource.from_dataframe import TensorFromDataFrame
+from ....tensor.datasource.full import TensorFull
+from ....tensor.datasource.ones import TensorOnes
+from ....tensor.datasource.tri_array import TensorTriArray
+from ... import EngineAcceptance
+from ..core import SPECodeContext, SPEOperatorAdapter, register_op_adapter
+from ..utils import build_method_call_adapter
+
+TensorArangeAdapter = build_method_call_adapter(
+    TensorArange,
+    "arange",
+    "start",
+    "stop",
+    "step",
+    source_module="np",
+    kw_keys=["dtype"],
+)
+
+
+@register_op_adapter(ArrayDataSource)
+class ArrayDataSourceAdapter(SPEOperatorAdapter):
+    def generate_code(self, op: ArrayDataSource, context: SPECodeContext) -> List[str]:
+        context.register_import("numpy", "np")
+        res_var_name = context.get_output_tileable_variable(op.outputs[0])
+        data_var = context.register_operator_constants(op.data)
+        dtype_var = context.register_operator_constants(op.outputs[0].dtype)
+        return [
+            f"{res_var_name} = np.asarray(({data_var}), "
+            f"dtype={dtype_var}, order={op.order!r})"
+        ]
+
+
+TensorDiagAdapter = build_method_call_adapter(
+    TensorDiag, "diag", "v", "k", source_module="np"
+)
+
+
+@register_op_adapter(TensorEmpty)
+class TensorEmptyAdapter(SPEOperatorAdapter):
+    def generate_code(self, op: TensorEmpty, context: SPECodeContext) -> List[str]:
+        context.register_import("numpy", "np")
+
+        shape_str = self.translate_var(context, op.outputs[0].shape)
+        res_var_name = context.get_output_tileable_variable(op.outputs[0])
+        dtype_var = context.register_operator_constants(op.outputs[0].dtype)
+        return [
+            f"{res_var_name} = np.empty({shape_str}, "
+            f"dtype={dtype_var}, order={op.order!r})"
+        ]
+
+
+TensorEyeAdapter = build_method_call_adapter(
+    TensorEye, "eye", "N", "M", kw_keys=["k", "dtype", "order"], source_module="np"
+)
+
+
+@register_op_adapter(TensorFull)
+class TensorFullAdapter(SPEOperatorAdapter):
+    def generate_code(self, op: TensorFull, context: SPECodeContext) -> List[str]:
+        context.register_import("numpy", "np")
+
+        shape_str = self.translate_var(context, op.outputs[0].shape)
+        res_var_name = context.get_output_tileable_variable(op.outputs[0])
+        kws = self.generate_call_args_with_attributes(
+            op, context, "fill_value", kw_keys=["dtype", "order"]
+        )
+        return [f"{res_var_name} = np.full({shape_str}, {kws})"]
+
+
+TensorFromDataFrameAdapter = build_method_call_adapter(TensorFromDataFrame, "to_numpy")
+TensorLinspaceAdapter = build_method_call_adapter(
+    TensorLinspace,
+    "linspace",
+    "start",
+    "stop",
+    kw_keys=["num", "endpoint", "order"],
+    source_module="np",
+)
+
+
+@register_op_adapter([TensorOnes, TensorZeros])
+class TensorOnesZerosAdapter(SPEOperatorAdapter):
+    def generate_code(
+        self, op: Union[TensorOnes, TensorZeros], context: SPECodeContext
+    ) -> List[str]:
+        context.register_import("numpy", "np")
+
+        shape_str = self.translate_var(context, op.shape)
+        res_var_name = context.get_output_tileable_variable(op.outputs[0])
+        dtype_var = context.register_operator_constants(op.outputs[0].dtype)
+        func_name = "ones" if isinstance(op, TensorOnes) else "zeros"
+        return [
+            f"{res_var_name} = np.{func_name}({shape_str}, "
+            f"dtype={dtype_var}, order={op.order!r})"
+        ]
+
+
+@register_op_adapter([TensorOnesLike, TensorZerosLike])
+class TensorOnesZerosLikeAdapter(SPEOperatorAdapter):
+    def generate_code(
+        self, op: Union[TensorOnesLike, TensorZerosLike], context: SPECodeContext
+    ) -> List[str]:
+        context.register_import("numpy", "np")
+
+        input_var_name = context.get_input_tileable_variable(op.inputs[0])
+        shape_str = self.translate_var(context, op.outputs[0].shape)
+        res_var_name = context.get_output_tileable_variable(op.outputs[0])
+        dtype_var = context.register_operator_constants(op.outputs[0].dtype)
+        func_name = "ones_like" if isinstance(op, TensorOnesLike) else "zeros_like"
+        return [
+            f"{res_var_name} = np.{func_name}({input_var_name}, "
+            f"dtype={dtype_var}, order={op.order!r}, shape={shape_str})"
+        ]
+
+
+class TensorScalarAdapter(SPEOperatorAdapter):
+    def accepts(self, op: Scalar) -> EngineAcceptance:
+        return EngineAcceptance.SUCCESSOR
+
+    def generate_code(self, op: Scalar, context: SPECodeContext) -> List[str]:
+        context.register_import("numpy", "np")
+        res_var_name = context.get_output_tileable_variable(op.outputs[0])
+        vals = self.generate_call_args_with_attributes(op, context, "data")
+        return [f"{res_var_name} = np.asarray({vals})"]
+
+
+@register_op_adapter(TensorTriArray)
+class TensorTriArrayAdapter(SPEOperatorAdapter):
+    def generate_code(self, op: TensorTriArray, context: SPECodeContext) -> List[str]:
+        context.register_import("numpy", "np")
+
+        inp_var_name = context.get_input_tileable_variable(op.inputs[0])
+        res_var_name = context.get_output_tileable_variable(op.outputs[0])
+        kws = self.generate_call_args_with_attributes(op, context, kw_keys=["k"])
+        func_name = "tril" if isinstance(op, TensorTril) else "triu"
+        return [f"{res_var_name} = np.{func_name}({inp_var_name}, {kws})"]