mindspore 2.4.10__cp39-cp39-manylinux1_x86_64.whl → 2.5.0__cp39-cp39-manylinux1_x86_64.whl

mindspore/ops_generate/gen_utils.py

@@ -18,43 +18,13 @@ Generate operator utils function
 import os
 import glob
 import hashlib
+import pathlib
+import re
 import stat
+import logging
 import yaml
 
 
-py_licence_str = f"""# Copyright 2023 Huawei Technologies Co., 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.
-# ============================================================================
-"""
-
-cc_license_str = f"""/**
- * Copyright 2023 Huawei Technologies Co., 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.
- */"""
-
-
 def convert_dtype_str(dtype_str):
     """
     Convert dtype str to expression in ops file
@@ -207,3 +177,119 @@ def write_file(path, data):
     fd = os.open(path, flags, mode)
     with os.fdopen(fd, "w") as f:
         f.write(data)
+
+
+def save_file(save_path, file_name, content):
+    pathlib.Path(save_path).mkdir(parents=True, exist_ok=True)
+    dst_file_path = os.path.join(save_path, file_name)
+    tmp_file_path = os.path.join(save_path, f"tmp_{file_name}")
+    write_file(tmp_file_path, content)
+    check_change_and_replace_file(dst_file_path, tmp_file_path)
+
+
+def normalize_func_description_format(description):
+    """
+    Process description.
+    """
+    if not description:
+        return description
+    lines = description.split("\n")
+    if len(lines) == 1:
+        return description
+
+    # Add line indentation to other lines after the first line
+    for i in range(1, len(lines)):
+        indent = "    " if lines[i] else ""
+        lines[i] = indent + lines[i]
+
+    # Remove trailing blank lines
+    lines = lines if lines[-1] != "" else lines[:-1]
+    description = "\n".join(lines)
+    return description
+
+
+def get_op_description(operator_name, doc_dict):
+    """
+    Generate ops api description.
+    """
+    op_description = f"    r\"\"\"\n" \
+                     f"    \n" \
+                     f"    \"\"\"\n"
+    if doc_dict is None:
+        logging.info("Description is None, op_name: %s", operator_name)
+        return op_description
+
+    description = doc_dict.get(operator_name)
+    if description is None:
+        logging.info("Description is None, op_name: %s", operator_name)
+        return op_description
+
+    description = description.get("description")
+    if description is None:
+        logging.info("Description is None, op_name: %s", operator_name)
+        return op_description
+
+    op_description = f"    r\"\"\"\n" \
+                     f"    {normalize_func_description_format(description)}\n" \
+                     f"    \"\"\"\n"
+    return op_description
+
+
+def get_same_dtype_groups(args_signature, args_name):
+    """
+    Get same dtype groups
+    """
+    same_dtype_groups = {}
+    dtype_count = 0
+
+    if not args_signature:
+        return same_dtype_groups, dtype_count
+
+    dtype_group = args_signature.dtype_group
+    if not args_signature.dtype_group:
+        return same_dtype_groups, dtype_count
+
+    args_list = []
+    match = re.findall(r'\((.*?)\)', dtype_group)
+    for item in match:
+        args_list.append(item.replace(' ', '').split(","))
+    for arg_name in args_name:
+        if arg_name in same_dtype_groups:
+            continue
+        is_match = False
+        for group in args_list:
+            if arg_name in group:
+                is_match = True
+                for item in group:
+                    same_dtype_groups[item] = dtype_count
+                break
+        if not is_match:
+            same_dtype_groups[arg_name] = dtype_count
+        dtype_count = dtype_count + 1
+    return same_dtype_groups, dtype_count
+
+
+def init_args_signature_rw(args_signature):
+    """
+    Extracts read, write, and reference argument lists from signature data.
+
+    Args:
+        args_signature (object): Contains 'rw_write', 'rw_read', 'rw_ref' attributes as comma-separated strings.
+
+    Returns:
+        tuple: Lists of read-only, reference, and write-only argument names.
+    """
+    write_list = []
+    read_list = []
+    ref_list = []
+    if args_signature:
+        if args_signature.rw_write:
+            write_list.extend(args_signature.rw_write.replace(' ', '').split(","))
+
+        if args_signature.rw_read:
+            read_list.extend(args_signature.rw_read.replace(' ', '').split(","))
+
+        if args_signature.rw_ref:
+            ref_list.extend(args_signature.rw_ref.replace(' ', '').split(","))
+
+    return read_list, ref_list, write_list

mindspore/ops_generate/lite_ops_cpp_generator.py

@@ -0,0 +1,155 @@
+# Copyright 2024 Huawei Technologies Co., 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.
+# ============================================================================
+"""
+Generates C++ header and source files for lite operations based on YAML configurations.
+"""
+
+import os
+
+import gen_constants as K
+import gen_utils
+import pyboost_utils
+
+# refactored
+import template
+
+from base_generator import BaseGenerator
+
+
+class LiteOpsHGenerator(BaseGenerator):
+    """
+    This class is responsible for generating the header file for lite operations.
+    """
+
+    def __init__(self):
+        """
+        Initializes the generator with the necessary templates for generating C++ header files.
+        """
+        self.lite_ops_h_template = template.Template(K.LITE_OPS_H)
+        self.lite_ops_class_template = template.op_cc_template
+        self.arg_prim_init_template = template.Template("\n"
+                                                        "  void set_${arg_name}(const ${dtype} &${arg_name});\n"
+                                                        "  ${dtype} get_${arg_name}() const;")
+
+    def generate(self, work_path, op_protos):
+        """
+        Generates the header file content for lite operations and saves it to the specified path.
+
+        Args:
+            work_path (str): The directory where the generated files will be saved.
+            op_protos (list): A list of operator prototypes containing information about the operators.
+
+        Returns:
+            None
+
+        """
+        lite_ops_h_code_list = []
+        for op_proto in op_protos:
+            op_name = pyboost_utils.get_op_name(op_proto.op_name, op_proto.op_class.name)
+            op_args = op_proto.op_args
+            arg_prim_init_str = ""
+            for op_arg in op_args:
+                if not op_arg.is_prim_init:
+                    continue
+
+                arg_name = op_arg.arg_name
+                dtype = trans_dtype_for_lite(op_arg.arg_dtype)
+                arg_prim_init_str += self.arg_prim_init_template.replace(arg_name=arg_name, dtype=dtype)
+
+            temp = self.lite_ops_class_template.replace(op_name=op_name, arg_prim_init_list=arg_prim_init_str)
+            lite_ops_h_code_list.append(temp)
+
+        lite_ops_h = self.lite_ops_h_template.replace(auto_gen_path=K.OP_DEF_AUTO_GENERATE_PATH,
+                                                      ops_namespace_body=lite_ops_h_code_list)
+
+        res_str = template.CC_LICENSE_STR + lite_ops_h
+        save_path = os.path.join(work_path, K.MS_OP_DEF_AUTO_GENERATE_PATH)
+        file_name = "gen_lite_ops.h"
+        gen_utils.save_file(save_path, file_name, res_str)
+
+
+class LiteOpsCcGenerator(BaseGenerator):
+    """
+    This class is responsible for generating the source file for lite operations.
+    """
+
+    def __init__(self):
+        """
+        Initializes the generator with the necessary templates for generating C++ source files.
+        """
+        self.lite_ops_cc_template = template.Template(K.LITE_OPS_CC)
+        self.op_template = template.op_template
+        self.register_primitive_c_template = template.Template("REGISTER_PRIMITIVE_C(kName${op_name}, ${op_name});\n"
+                                                               "MIND_API_OPERATOR_IMPL(${op_name}, BaseOperator);\n\n")
+
+    def generate(self, work_path, op_protos):
+        """
+        Generates the source file content for lite operations and saves it to the specified path.
+
+        Args:
+            work_path (str): The directory where the generated files will be saved.
+            op_protos (list): A list of operation prototypes to generate content for.
+
+        Returns:
+            None
+        """
+        lite_ops_cc_gen_list = []
+        for op_proto in op_protos:
+            arg_prim_init_str = ""
+            op_name = pyboost_utils.get_op_name(op_proto.op_name, op_proto.op_class.name)
+            op_args = op_proto.op_args
+            for op_arg in op_args:
+                if not op_arg.is_prim_init:
+                    continue
+
+                arg_name = op_arg.arg_name
+                dtype = trans_dtype_for_lite(op_arg.arg_dtype)
+                arg_prim_init_str += self.op_template.replace(op_name=op_name, arg_name=arg_name, dtype=dtype)
+
+            self.register_primitive_c_template.replace(op_name=op_name)
+            lite_ops_cc_gen_list.append(arg_prim_init_str + self.register_primitive_c_template.replace(op_name=op_name))
+
+        lite_ops_cc = self.lite_ops_cc_template.replace(auto_gen_path=K.OP_DEF_AUTO_GENERATE_PATH,
+                                                        ops_namespace_body=lite_ops_cc_gen_list)
+
+        res_str = template.CC_LICENSE_STR + lite_ops_cc
+        save_path = os.path.join(work_path, K.MS_OP_DEF_AUTO_GENERATE_PATH)
+        file_name = "gen_lite_ops.cc"
+        gen_utils.save_file(save_path, file_name, res_str)
+
+
+def trans_dtype_for_lite(dtype):
+    """
+    Translate the data type for lite usage based on the argument information.
+
+    Args:
+        dtype (str): The original data type as a string.
+
+    Returns:
+        str: The translated data type suitable for lite usage.
+    """
+    type_mappings = {
+        "str": "std::string",
+        "tuple[str]": "std::vector<std::string>",
+        "list[str]": "std::vector<std::string>",
+        "tuple[int]": "std::vector<int64_t>",
+        "list[int]": "std::vector<int64_t>",
+        "tuple[float]": "std::vector<float>",
+        "list[float]": "std::vector<float>",
+        "tuple[bool]": "std::vector<bool>",
+        "list[bool]": "std::vector<bool>",
+        "int": "int64_t"
+    }
+    return type_mappings.get(dtype, dtype)

mindspore/ops_generate/op_api_proto.py

@@ -0,0 +1,206 @@
+# Copyright 2024 Huawei Technologies Co., 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.
+# ============================================================================
+
+"""Tensor Func Proto module for defining tensor_py function prototypes and their arguments."""
+import ast
+import os
+from collections import defaultdict
+import gen_constants as K
+
+
+class OpApiProto:
+    """
+    Represents a tensor function prototype with associated function name, operation prototype, and target devices.
+    """
+
+    def __init__(self,
+                 func_name,
+                 op_proto,
+                 py_method,
+                 kw_only_args,
+                 varargs,
+                 ascend,
+                 gpu,
+                 cpu):
+        self.func_name = func_name
+        self.op_proto = op_proto
+        self.py_method = py_method
+        self.kw_only_args = kw_only_args
+        self.varargs = varargs
+        self.ascend = ascend
+        self.gpu = gpu
+        self.cpu = cpu
+
+
+def get_tensor_method_ast_dict():
+    """
+        Generates a dictionary mapping function names to their Abstract Syntax Tree (AST) nodes
+        for all functions defined in the 'tensor_method.py' file.
+    """
+    tensor_method_ast_dict = dict()
+    tensor_method_file = os.path.join(os.path.dirname(os.path.realpath(__file__)), '../ops/tensor_method.py')
+    with open(tensor_method_file, "r", encoding="utf-8") as file:
+        tree = ast.parse(file.read(), filename=tensor_method_file)
+    for node in ast.walk(tree):
+        if isinstance(node, ast.FunctionDef):
+            tensor_method_ast_dict[node.name] = node
+    return tensor_method_ast_dict
+
+
+def load_api_protos_from_yaml(tensor_func_yaml_data, op_protos, deprecated_op_protos):
+    """
+    Loads tensor function prototypes from YAML data and returns them as a dictionary.
+    """
+    op_protos_dict = {}
+    for op_proto in op_protos:
+        op_protos_dict[op_proto.op_name] = op_proto
+    for deprecated_op_proto in deprecated_op_protos:
+        op_protos_dict[deprecated_op_proto.op_name] = deprecated_op_proto
+    tensor_method_protos = defaultdict(list)
+    mint_func_protos = defaultdict(list)
+    alias_api_mapping = defaultdict(list)
+    tensor_method_def_ast_dict = get_tensor_method_ast_dict()
+    for func_name, tensor_func_data in tensor_func_yaml_data.items():
+        func_data_list = [tensor_func_data] if isinstance(tensor_func_data, dict) else tensor_func_data
+        for func_data in func_data_list:
+            func_keys = func_data.keys()
+            check_op_api_yaml_keys(func_name, set(func_keys), K.TENSOR_FUNC_KEYS)
+            if 'alias' in func_data:
+                alias_api_mapping[func_data['alias']].append(func_name)
+                continue
+            op_name = _get_op_name_from_op_yaml(func_name, func_data)
+            op_proto = op_protos_dict.get(op_name, None)
+            if op_proto is None:
+                raise TypeError(
+                    f"For generating tensor functions, op_proto should not be empty. Func name is {func_name}")
+            py_method = func_data.get('py_method', '')
+            if py_method == '':
+                raise TypeError(
+                    f'For generating tensor functions, py method should not be empty. Func name is {func_name}')
+            if py_method not in tensor_method_def_ast_dict:
+                raise TypeError(f"{py_method} is not defined in tensor_method.py.")
+            kw_only_args = func_data.get('kwonlyargs', None)
+            if kw_only_args:
+                kw_only_args = [item.strip() for item in kw_only_args.split(',')]
+                check_kwonlyargs(func_data, kw_only_args, op_name, op_proto, py_method, tensor_method_def_ast_dict)
+            varargs = func_data.get('varargs', None)
+            if varargs:
+                varargs = [item.strip() for item in varargs.split(',')]
+                check_varargs(varargs, op_name)
+            ascend = func_data.get('Ascend', 'aclnn')
+            gpu = func_data.get('GPU', 'aclnn')
+            cpu = func_data.get('CPU', 'aclnn')
+            interface = func_data.get('interface')
+            if interface is None:
+                raise ValueError(
+                    f"For generating tensor or functional interfaces, field interface must exist. "
+                    f"Op name is {func_name}")
+
+            interface = ', '.join(part.strip() for part in interface.split(','))
+
+            if interface not in {'tensor', 'function', 'tensor, function', 'function, tensor'}:
+                raise ValueError(
+                    f"The value of field 'interface' must be one of 'tensor', 'function', "
+                    f"'tensor, function', or 'function, tensor'. File name is {func_name}.yaml"
+                )
+
+            proto = OpApiProto(func_name=func_name, op_proto=op_proto, py_method=py_method,
+                               kw_only_args=kw_only_args, varargs=varargs, ascend=ascend, gpu=gpu, cpu=cpu)
+
+            if 'tensor' in interface:
+                tensor_method_protos[func_name].append(proto)
+            if 'function' in interface:
+                mint_func_protos[func_name].append(proto)
+
+    return tensor_method_protos, mint_func_protos, alias_api_mapping
+
+
+def check_kwonlyargs(func_data, kw_only_args, op_name, op_proto, py_method, tensor_method_def_ast_dict):
+    """
+    Verifies that the keyword-only arguments (kwonlyargs) specified in the YAML definition
+    match the order and names of the keyword-only arguments in the Python method definition.
+    """
+    op_args = op_proto.op_args
+    kw_args_start_idx = len(op_args) - len(kw_only_args)
+    node = tensor_method_def_ast_dict[py_method]
+    tensor_method_kwonlyargs = [arg.arg for arg in node.args.kwonlyargs]
+    for idx, kw_arg in enumerate(kw_only_args):
+        kw_args_idx = kw_args_start_idx + idx
+        if kw_args_idx > len(op_args) or kw_arg != op_args[kw_args_idx].arg_name:
+            op_kw_args = [op_arg.arg_name for op_arg in op_args]
+            op_yaml = func_data.get('op_yaml')
+            raise TypeError(
+                f"For generating tensor functions from {op_name}.yaml, "
+                f"the order of kwonlyargs should be consistent with the definition in the {op_yaml}. "
+                f"Expect kwonlyarg: {op_kw_args[kw_args_start_idx:]}, current kwonlyarg: {kw_only_args}.")
+    if tensor_method_kwonlyargs != kw_only_args:
+        raise TypeError(f"The order of kwonlyargs in {py_method} should be consistent with the definition. "
+                        f"Expect kwonlyarg: {kw_only_args}, current kwonlyarg: {tensor_method_kwonlyargs}.")
+
+
+def check_varargs(varargs, op_name):
+    if len(varargs) != 1:
+        raise ValueError(
+            f'There must be only one variable argument. But got {len(varargs)} in {op_name}')
+
+
+def _get_op_name_from_op_yaml(func_name: str, func_data: dict) -> str:
+    """Extracts the operation name from the given YAML function data."""
+    op_yaml = func_data.get('op_yaml', '')
+    if op_yaml == '':
+        raise TypeError(f'For generating tensor functions, op yaml should not be empty, func name is {func_name}')
+    if 'deprecated' in op_yaml:
+        op_name = op_yaml.replace('/', '_').replace('_method.yaml', '')
+    else:
+        op_name = op_yaml.replace('_op.yaml', '')
+    if op_name == '':
+        raise TypeError(f'For generating tensor functions, op name should not be empty, func name is {func_name}')
+    return op_name
+
+
+def check_op_api_yaml_keys(func_name: str, input_keys: set, compare_keys: set):
+    diff_keys = input_keys - compare_keys
+    if diff_keys:
+        raise TypeError(
+            f'The definition of keys in yaml has faults, func name is {func_name}, wrong keys are {diff_keys}.')
+
+
+def categorize_func_data(func_protos_data):
+    """
+    Categorizes function prototypes into single, overloaded function prototypes.
+
+    Args:
+        func_protos_data (dict): Dictionary where keys are function API names and values are lists of
+                                 function prototypes associated with each API.
+
+    Returns:
+        tuple:
+            - single_op_func_data (dict): Function prototypes for operations with a single definition.
+            - overload_op_func_data (dict): Function prototypes for operations with overloaded definitions.
+    """
+    single_op_func_data = {}
+    overload_op_func_data = {}
+    all_op_func_data = {}
+    for func_api_name, func_protos in func_protos_data.items():
+        if len(func_protos) == 1:
+            func_name = func_protos[0].func_name
+            if func_name not in single_op_func_data:
+                single_op_func_data[func_name] = func_protos[0]
+                all_op_func_data[func_name] = func_protos
+        elif len(func_protos) > 1:
+            overload_op_func_data[func_api_name] = func_protos
+            all_op_func_data[func_api_name] = func_protos
+
+    return all_op_func_data, single_op_func_data, overload_op_func_data

mindspore/ops_generate/op_def_py_generator.py

@@ -0,0 +1,131 @@
+# Copyright 2024 Huawei Technologies Co., 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.
+# ============================================================================
+"""
+Generate Python operator definitions.
+"""
+
+import os
+
+import gen_constants as K
+import gen_utils
+
+# refactored
+import template
+
+from base_generator import BaseGenerator
+
+
+class OpDefPyGenerator(BaseGenerator):
+    """
+    This class is responsible for generating Python operator definitions based on provided
+    operation prototypes and documentation strings. It generates the code for the operator
+    functions that can be used in Python scripts to interact with the underlying operations.
+    """
+
+    def __init__(self):
+        """
+        Initializes the generator with the template for primitive class definitions.
+        """
+        self.op_prim_class_define_template = template.OP_PRIM_CLASS_DEFINE_TEMPLATE
+
+    def generate(self, work_path, op_protos, doc_dict, file_pre):
+        """
+        Generates Python code for operator definitions and saves it to a file.
+
+        Args:
+            work_path (str): The base directory where the generated files will be saved.
+            op_protos (list): A list of operation prototypes to generate Python code for.
+            doc_dict (dict): A dictionary containing documentation strings for the operators.
+            file_pre (str): The prefix for the generated Python files.
+
+        Returns:
+            None
+
+        The generated Python code includes function definitions for each operator, using
+        the provided operation prototypes and documentation. It saves the code in a file
+        with the given prefix in the specified work path.
+        """
+        gen_py = "\n"
+        for op_proto in op_protos:
+            if op_proto.op_function.disable:
+                continue
+
+            class_name = op_proto.op_class.name
+            func_name = op_proto.op_function.name
+            op_args = op_proto.op_args
+            func_args, prim_call_args, prim_init_args = self.get_op_args(op_args)
+
+            func_code = "\n"
+            description = gen_utils.get_op_description(op_proto.op_name, doc_dict)
+            func_formal_param = ", ".join(arg_name for arg_name in func_args)
+            op_prim_input_args = ", ".join(arg_name for arg_name in prim_call_args)
+            if prim_init_args:
+                if op_proto.op_dispatch and op_proto.op_dispatch.enable:
+                    func_impl_input_args = ", ".join(op_args.arg_name for op_args in op_args)
+                    func_code += f"def {func_name}({func_formal_param}):\n"
+                    func_code += f"{description}"
+                    func_code += f"    return {op_proto.op_name}_impl({func_impl_input_args})\n"
+                else:
+                    cache_prim_input_args = ", ".join(arg_name for arg_name in prim_init_args)
+                    func_code += f"def {func_name}({func_formal_param}):\n"
+                    func_code += f"{description}"
+                    func_code += f"    {op_proto.op_name}_op = _get_cache_prim({class_name})({cache_prim_input_args})\n"
+                    func_code += f"    return {op_proto.op_name}_op({op_prim_input_args})\n"
+            else:
+                if op_proto.op_class and op_proto.op_class.disable:
+                    gen_py += f"{op_proto.op_name}_op={class_name}()\n"
+                func_code += f"def {func_name}({func_formal_param}):\n"
+                func_code += f"{description}"
+                func_code += f"    return {op_proto.op_name}_op({op_prim_input_args})\n"
+
+            gen_py += func_code
+            gen_py += "\n"
+
+        res_str = template.PY_LICENCE_STR + template.OPS_PY_DEF_HEADER + gen_py[:-len(template.NEW_LINE)]
+        save_path = os.path.join(work_path, K.PY_AUTO_GEN_PATH)
+        file_name = f"{file_pre}_ops_def.py"
+        gen_utils.save_file(save_path, file_name, res_str)
+
+    def get_op_args(self, op_args):
+        """
+        Processes the list of OpArg objects to categorize them into function arguments,
+        primitive initialization arguments, and primitive call arguments.
+
+        Args:
+            op_args (list): A list of OpArg objects representing the arguments of an operator.
+
+        Returns:
+            tuple: A tuple containing three lists:
+                - func_args (list): Names of the function arguments.
+                - prim_call_args (list): Names of the primitive call arguments.
+                - prim_init_args (list): Names of the primitive initialization arguments.
+        """
+        func_args = []
+        prim_init_args = []
+        prim_call_args = []
+        for op_arg in op_args:
+            # step1: Process function args.
+            if op_arg.default is None:
+                func_args.append(f"""{op_arg.arg_name}""")
+            else:
+                func_args.append(f"""{op_arg.arg_name}={op_arg.default}""")
+
+            # step2: Process primitive object init args.
+            if op_arg.is_prim_init:
+                prim_init_args.append(op_arg.arg_name)
+            # step3: Process primitive object call args.
+            else:
+                prim_call_args.append(op_arg.arg_name)
+        return func_args, prim_call_args, prim_init_args