maxframe 2.4.0rc1__cp312-cp312-win32.whl

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,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 (
+    arithmetic,
+    datasource,
+    extensions,
+    fetch,
+    fft,
+    indexing,
+    linalg,
+    merge,
+    misc,
+    random,
+    reduction,
+    reshape,
+    spatial,
+    special,
+    statistics,
+)

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,166 @@
+# 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})"
+        ]
+
+
+@register_op_adapter(Scalar)
+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})"]

maxframe/codegen/spe/tensor/extensions.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.extensions.apply_chunk import TensorApplyChunk
+from ..core import SPECodeContext, SPEOperatorAdapter, register_op_adapter
+
+
+@register_op_adapter(TensorApplyChunk)
+class TensorApplyChunkAdapter(SPEOperatorAdapter):
+    def generate_code(self, op: TensorApplyChunk, context: SPECodeContext) -> List[str]:
+        input_var = context.get_input_tileable_variable(op.inputs[0])
+        output_var = context.get_output_tileable_variable(op.outputs[0])
+        func_var = self.translate_var(context, op.func)
+        kwargs = op.kwargs.copy()
+        if op.with_chunk_index:
+            kwargs["chunk_index"] = (0,) * op.inputs[0].ndim
+        args = self._translate_call_args(context, *op.args, **kwargs)
+        if args:
+            args_str = ", " + ", ".join(args)
+        else:
+            args_str = ""
+        return [f"{output_var} = {func_var}({input_var}{args_str})"]

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

maxframe/codegen/spe/tensor/fft.py

@@ -0,0 +1,74 @@
+# 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.fft import TensorFFTFreq, TensorRFFTFreq
+from ....tensor.fft.core import TensorFFTMixin, TensorFFTNMixin, TensorFFTShiftMixin
+from ..core import SPECodeContext, SPEOperatorAdapter, register_op_adapter
+
+
+@register_op_adapter(TensorFFTMixin)
+class TensorFFTAdapter(SPEOperatorAdapter):
+    def generate_code(self, op: TensorFFTMixin, context: SPECodeContext) -> List[str]:
+        context.register_import("numpy", "np")
+        func_name = type(op).__name__.lower()[6:]
+        input_var_name = context.get_input_tileable_variable(op.inputs[0])
+        res_var_name = context.get_output_tileable_variable(op.outputs[0])
+        kw_str = self.generate_call_args_with_attributes(
+            op, context, kw_keys=["n", "axis", "norm"], skip_none=True
+        )
+        return [f"{res_var_name} = np.fft.{func_name}({input_var_name}, {kw_str})"]
+
+
+@register_op_adapter(TensorFFTNMixin)
+class TensorFFTNAdapter(SPEOperatorAdapter):
+    def generate_code(self, op: TensorFFTNMixin, context: SPECodeContext) -> List[str]:
+        context.register_import("numpy", "np")
+        func_name = type(op).__name__.lower()[6:]
+        input_var_name = context.get_input_tileable_variable(op.inputs[0])
+        res_var_name = context.get_output_tileable_variable(op.outputs[0])
+        kw_str = self.generate_call_args_with_attributes(
+            op, context, "shape", kw_keys=["axes", "norm"], skip_none=True
+        )
+        return [f"{res_var_name} = np.fft.{func_name}({input_var_name}, {kw_str})"]
+
+
+@register_op_adapter(TensorFFTShiftMixin)
+class TensorFFTShiftAdapter(SPEOperatorAdapter):
+    def generate_code(
+        self, op: TensorFFTShiftMixin, context: SPECodeContext
+    ) -> List[str]:
+        context.register_import("numpy", "np")
+        func_name = type(op).__name__.lower()[6:]
+        input_var_name = context.get_input_tileable_variable(op.inputs[0])
+        res_var_name = context.get_output_tileable_variable(op.outputs[0])
+        kw_str = self.generate_call_args_with_attributes(
+            op, context, kw_keys=["axes"], skip_none=True
+        )
+        return [f"{res_var_name} = np.fft.{func_name}({input_var_name}, {kw_str})"]
+
+
+@register_op_adapter([TensorFFTFreq, TensorRFFTFreq])
+class TensorFFTFreqAdapter(SPEOperatorAdapter):
+    def generate_code(
+        self, op: Union[TensorFFTFreq, TensorRFFTFreq], context: SPECodeContext
+    ) -> List[str]:
+        context.register_import("numpy", "np")
+        func_name = type(op).__name__.lower()[6:]
+        res_var_name = context.get_output_tileable_variable(op.outputs[0])
+        kw_str = self.generate_call_args_with_attributes(
+            op, context, "n", kw_keys=["d"]
+        )
+        return [f"{res_var_name} = np.fft.{func_name}({kw_str})"]