mindspore 2.5.0__cp39-cp39-win_amd64.whl → 2.6.0rc1__cp39-cp39-win_amd64.whl

mindspore/ops_generate/{op_api_proto.py → api/op_api_proto.py}

@@ -17,7 +17,11 @@
 import ast
 import os
 from collections import defaultdict
-import gen_constants as K
+
+import common.gen_constants as K
+from common.gen_utils import safe_load_yaml_from_dir
+from resources.resource_loader import ResourceLoader
+from resources.resource_list import ResourceType
 
 
 class OpApiProto:
@@ -50,7 +54,8 @@ def get_tensor_method_ast_dict():
         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')
+    tensor_method_file = os.path.join(
+        K.WORK_DIR, K.PY_MS_DIR, '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):
@@ -59,72 +64,91 @@ def get_tensor_method_ast_dict():
     return tensor_method_ast_dict
 
 
-def load_api_protos_from_yaml(tensor_func_yaml_data, op_protos, deprecated_op_protos):
+class OpApiProtoLoader(ResourceLoader):
     """
-    Loads tensor function prototypes from YAML data and returns them as a dictionary.
+    Loads api related proto data.
     """
-    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 __init__(self, op_protos, deprecated_op_protos, func_op_protos):
+        self.op_api_data = safe_load_yaml_from_dir(os.path.join(K.WORK_DIR, K.MS_OP_API_YAML_PATH))
+        self.op_protos = op_protos + func_op_protos
+        self.deprecated_op_protos = deprecated_op_protos
+
+    def load(self):
+        """
+        Loads tensor function prototypes from YAML data and returns them as a dictionary.
+        """
+        op_protos_dict = {}
+        for op_proto in self.op_protos:
+            op_protos_dict[op_proto.op_name] = op_proto
+        for deprecated_op_proto in self.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 self.op_api_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 {ResourceType.TENSOR_METHOD_PROTOS: tensor_method_protos,
+                ResourceType.MINT_FUNC_PROTOS: mint_func_protos,
+                ResourceType.ALIAS_API_MAPPING: alias_api_mapping}
+
+
 
 
 def check_kwonlyargs(func_data, kw_only_args, op_name, op_proto, py_method, tensor_method_def_ast_dict):
@@ -160,13 +184,15 @@ 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}')
+        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}')
+        raise TypeError(
+            f'For generating tensor functions, op name should not be empty, func name is {func_name}')
     return op_name
 
 
@@ -193,6 +219,7 @@ def categorize_func_data(func_protos_data):
     single_op_func_data = {}
     overload_op_func_data = {}
     all_op_func_data = {}
+    op_class_name_set = set()
     for func_api_name, func_protos in func_protos_data.items():
         if len(func_protos) == 1:
             func_name = func_protos[0].func_name
@@ -202,5 +229,7 @@ def categorize_func_data(func_protos_data):
         elif len(func_protos) > 1:
             overload_op_func_data[func_api_name] = func_protos
             all_op_func_data[func_api_name] = func_protos
+        for func_proto in func_protos:
+            op_class_name_set.add(func_proto.op_proto.op_class.name)
 
-    return all_op_func_data, single_op_func_data, overload_op_func_data
+    return all_op_func_data, single_op_func_data, overload_op_func_data, op_class_name_set

mindspore/ops_generate/{tensor_func_reg_cpp_generator.py → api/tensor_func_reg_cpp_generator.py}

@@ -23,15 +23,15 @@ that can be used to call the Pyboost primitive implementations.
 
 import os
 
-import template
-from template import Template
-import gen_constants as K
-import pyboost_utils
-import op_api_proto
-from gen_utils import save_file
-from base_generator import BaseGenerator
-from op_proto import OpProto
-from op_template_parser import OpTemplateParser
+import common.template as template
+import common.gen_constants as K
+from common.template import Template
+from common.gen_utils import save_file
+from common.base_generator import BaseGenerator
+from common.op_proto import OpProto
+from pyboost.op_template_parser import OpTemplateParser
+from pyboost import pyboost_utils
+import api.op_api_proto as op_api_proto
 
 
 class TensorFuncRegCppGenerator(BaseGenerator):
@@ -53,7 +53,8 @@ class TensorFuncRegCppGenerator(BaseGenerator):
         self.TENSOR_FUNC_UT_OVERLOAD_BODY = template.TENSOR_FUNC_UT_OVERLOAD_BODY
         self.TENSOR_CPP_METHOD = template.TENSOR_CPP_METHOD
 
-        self.func_def_reg = Template("tensor_class->def(\"${func_name}\", TensorMethod${cpp_func_name});\n")
+        self.func_def_reg = Template(
+            "tensor_class->def(\"${func_name}\", TensorMethod${cpp_func_name});\n")
         self.single_case_template = Template(
             'case ${case_id}:\n'
             '  ${device_dispatcher}\n'
@@ -78,8 +79,10 @@ class TensorFuncRegCppGenerator(BaseGenerator):
         self.pyboost_return_template = Template(
             '${arg_handler_processor}\n'
             'MS_LOG(INFO) << "Call Tensor${class_name}";\n'
-            'return ToPython(TensorPyboostMethodRegister::'
-            'GetOp(tensor::TensorPyboostMethod::k${class_name}Reg)(arg_list));\n'
+            'auto res = mindspore::pynative::'
+            '${pyboost_function}(mindspore::prim::kPrim${class_name}, parse_args.src_types_, ${convert_args});\n'
+            'trace::Capture(parse_args.arg_list_, "${class_name}", &res);\n'
+            'return res;\n'
         )
         self.callback_python_template = Template(
             'MS_LOG(INFO) << "Callback python method: ${py_method}";\n'
@@ -109,31 +112,44 @@ class TensorFuncRegCppGenerator(BaseGenerator):
             alias_func_mapping (dict): A dictionary mapping function name to its alias function names.
         """
 
-        all_op_func_data, single_op_func_data, overload_op_func_data = op_api_proto.categorize_func_data(
-            func_protos_data)
+        all_op_func_data, single_op_func_data, overload_op_func_data, op_class_name_set = \
+            op_api_proto.categorize_func_data(func_protos_data)
 
         tensor_method_list = self._get_op_enum_name_list(op_protos)
         func_call_body_list = []
-        self._create_single_op_source_files(single_op_func_data, func_call_body_list)
-        self._create_overload_op_source_files(overload_op_func_data, func_call_body_list)
-        merge_func_call_body = pyboost_utils.merge_strings_by_chunk_size(func_call_body_list)
-
+        self._create_single_op_source_files(
+            single_op_func_data, func_call_body_list)
+        self._create_overload_op_source_files(
+            overload_op_func_data, func_call_body_list)
+        merge_func_call_body = pyboost_utils.merge_strings_by_chunk_size(
+            func_call_body_list)
+        ops_inc_head_set = set()
+        for op_class_name in op_class_name_set:
+            ops_inc_head_set.add(template.OP_DEF_INC_HEAD_TEMPLATE.replace(prefix_char=op_class_name[0].lower()))
         for i, func_body_chunk_str in enumerate(merge_func_call_body):
-            tensor_api_source = self.TENSOR_API_SOURCE.replace(tenosr_func_call_body=func_body_chunk_str)
+            tensor_api_source = self.TENSOR_API_SOURCE.replace(
+                ops_inc=list(sorted(ops_inc_head_set)),
+                tenosr_func_call_body=func_body_chunk_str)
             save_file(os.path.join(work_path, K.TENSOR_API_PATH), f"tensor_api_{i}.cc",
                       tensor_api_source)
 
         func_def_body_list, tensor_cpp_methods_list, tensor_api_declaration_list = self._get_sorted_func_def_body(
             all_op_func_data, alias_func_mapping)
-        tensor_api_header = self.TENSOR_API_HEADER.replace(tensor_api_declaration_list=tensor_api_declaration_list)
+        tensor_api_header = self.TENSOR_API_HEADER.replace(
+            tensor_api_declaration_list=tensor_api_declaration_list)
         save_file(os.path.join(work_path, K.TENSOR_API_PATH), f"tensor_api.h",
                   tensor_api_header)
-        self._generate_func_name_for_stub_tensor(work_path, tensor_cpp_methods_list)
-        func_cc_reg = self.TENSOR_FUNC_CC_REG.replace(func_def_body=func_def_body_list)
-        tensor_methods = self.TENSOR_FUNC_UTILS.replace(tensor_methods=tensor_method_list)
-
-        save_file(os.path.join(work_path, K.TENSOR_FUNC_REGISTER_PATH), "tensor_func_utils.h", tensor_methods)
-        save_file(os.path.join(work_path, K.TENSOR_FUNC_REGISTER_PATH), "tensor_func_reg.cc", func_cc_reg)
+        self._generate_func_name_for_stub_tensor(
+            work_path, tensor_cpp_methods_list)
+        func_cc_reg = self.TENSOR_FUNC_CC_REG.replace(
+            func_def_body=func_def_body_list)
+        tensor_methods = self.TENSOR_FUNC_UTILS.replace(
+            tensor_methods=tensor_method_list)
+
+        save_file(os.path.join(work_path, K.TENSOR_FUNC_REGISTER_PATH),
+                  "tensor_func_utils.h", tensor_methods)
+        save_file(os.path.join(work_path, K.TENSOR_API_PATH),
+                  "tensor_func_reg.cc", func_cc_reg)
 
     def _get_op_enum_name_list(self, op_protos):
         """
@@ -169,7 +185,8 @@ class TensorFuncRegCppGenerator(BaseGenerator):
         """
         tensor_cpp_methods_str = self.TENSOR_CPP_METHOD.replace(
             tensor_cpp_methods_list_str=str(tensor_cpp_methods_list))
-        save_file(os.path.join(work_path, K.ADD_TENSOR_DOCS_PY_PATH), "_tensor_cpp_method.py", tensor_cpp_methods_str)
+        save_file(os.path.join(work_path, K.ADD_TENSOR_DOCS_PY_PATH),
+                  "_tensor_cpp_method.py", tensor_cpp_methods_str)
 
     def _get_sorted_func_def_body(self, all_op_func_data, alias_func_mapping):
         """
@@ -197,9 +214,11 @@ class TensorFuncRegCppGenerator(BaseGenerator):
             if len(func_protos) == 1:
                 func_proto = func_protos[0]
                 func_name = func_proto.func_name
-                func_def_body_list.append(self.func_def_reg.replace(func_name=func_name, cpp_func_name=cpp_func_name))
+                func_def_body_list.append(self.func_def_reg.replace(
+                    func_name=func_name, cpp_func_name=cpp_func_name))
                 tensor_cpp_methods_list.append(func_name)
-                tensor_api_declaration_list += self.header_func_header_template.replace(cpp_func_name=cpp_func_name)
+                tensor_api_declaration_list += self.header_func_header_template.replace(
+                    cpp_func_name=cpp_func_name)
                 if func_name in alias_func_mapping:
                     for alias_func_name in alias_func_mapping[func_name]:
                         func_def_body_list.append(
@@ -209,7 +228,8 @@ class TensorFuncRegCppGenerator(BaseGenerator):
                 func_def_body_list.append(
                     self.func_def_reg.replace(func_name=func_api_name, cpp_func_name=cpp_func_name))
                 tensor_cpp_methods_list.append(func_api_name)
-                tensor_api_declaration_list += self.header_func_header_template.replace(cpp_func_name=cpp_func_name)
+                tensor_api_declaration_list += self.header_func_header_template.replace(
+                    cpp_func_name=cpp_func_name)
                 if func_api_name in alias_func_mapping:
                     for alias_func_name in alias_func_mapping[func_api_name]:
                         func_def_body_list.append(self.func_def_reg.replace(func_name=alias_func_name,
@@ -230,14 +250,16 @@ class TensorFuncRegCppGenerator(BaseGenerator):
         for func_api_name, func_proto in single_op_func_data.items():
             func_name = func_proto.func_name
             cpp_func_name = pyboost_utils.format_func_api_name(func_api_name)
-            device_dispatcher_str = self._get_device_dispatchers_str(func_proto)
+            device_dispatcher_str = self._get_device_dispatchers_str(
+                func_proto)
             signature_str = self._generate_single_signature_str(
                 func_proto.op_proto, func_proto.kw_only_args, func_proto.varargs
             )
             op_args = func_proto.op_proto.op_args
             max_size = len(op_args)
             self_index = self._get_input_tensor_index(func_proto)
-            ut_body = self.TENSOR_FUNC_UT_BODY.replace(py_method=func_proto.py_method)
+            ut_body = self.TENSOR_FUNC_UT_BODY.replace(
+                py_method=func_proto.py_method)
             tensor_func_single_call_body = self.TENSOR_FUNC_CALL_BODY.replace(cpp_func_name=cpp_func_name,
                                                                               func_name=func_name,
                                                                               device_dispatcher=device_dispatcher_str,
@@ -258,7 +280,8 @@ class TensorFuncRegCppGenerator(BaseGenerator):
             list: Updated str list for generating C++ function call bodies.
         """
         for func_api_name, func_protos in overload_op_func_data.items():
-            tensor_func_overload_call_body = self._get_overload_func_call_str(func_api_name, func_protos)
+            tensor_func_overload_call_body = self._get_overload_func_call_str(
+                func_api_name, func_protos)
             func_call_body_list.append(tensor_func_overload_call_body)
 
     def _get_overload_func_call_str(self, func_api_name, func_protos):
@@ -275,7 +298,8 @@ class TensorFuncRegCppGenerator(BaseGenerator):
         signatures_str = self._generate_func_signatures_list_str(func_protos)
         dispatch_cases = self._get_dispatch_cases(func_protos)
         ut_dispatch_cases = self._get_ut_dispatch_cases(func_protos)
-        ut_overload_body = self.TENSOR_FUNC_UT_OVERLOAD_BODY.replace(ut_dispatch_cases=ut_dispatch_cases)
+        ut_overload_body = self.TENSOR_FUNC_UT_OVERLOAD_BODY.replace(
+            ut_dispatch_cases=ut_dispatch_cases)
 
         max_size = 0
         self_index = 0
@@ -311,7 +335,8 @@ class TensorFuncRegCppGenerator(BaseGenerator):
             if not first_sig:
                 sig_str += ',\n'
             first_sig = False
-            sig_str += self._generate_single_signature_str(op_proto, tensor_proto.kw_only_args, tensor_proto.varargs)
+            sig_str += self._generate_single_signature_str(
+                op_proto, tensor_proto.kw_only_args, tensor_proto.varargs)
         return sig_str
 
     def _generate_single_signature_str(self, op_proto: OpProto, kw_only_args, varargs) -> str:
@@ -331,9 +356,11 @@ class TensorFuncRegCppGenerator(BaseGenerator):
         op_name = func_proto.op_proto.op_class.name
         op_args = func_proto.op_proto.op_args
         if op_name in K.INPUT_NAME_MAP:
-            self_index = [i for i in range(len(op_args)) if op_args[i].arg_name == K.INPUT_NAME_MAP[op_name]]
+            self_index = [i for i in range(
+                len(op_args)) if op_args[i].arg_name == K.INPUT_NAME_MAP[op_name]]
         else:
-            self_index = [i for i in range(len(op_args)) if op_args[i].arg_name in K.INPUT_ARGS_NAME]
+            self_index = [i for i in range(
+                len(op_args)) if op_args[i].arg_name in K.INPUT_ARGS_NAME]
         if len(self_index) != 1:
             raise ValueError(
                 f'There must be only one field named \'input\'. But got {len(self_index)} in {op_name}')
@@ -351,7 +378,8 @@ class TensorFuncRegCppGenerator(BaseGenerator):
         """
         dispatch_cases_str = ''
         for idx, func_proto in enumerate(func_protos):
-            device_dispatcher_str = self._get_device_dispatchers_str(func_proto)
+            device_dispatcher_str = self._get_device_dispatchers_str(
+                func_proto)
             dispatch_cases_str += self.single_case_template.replace(case_id=idx,
                                                                     device_dispatcher=device_dispatcher_str)
         dispatch_cases_str += 'default:\n'
@@ -370,7 +398,8 @@ class TensorFuncRegCppGenerator(BaseGenerator):
         """
         dispatch_cases_str = ''
         for idx, func_proto in enumerate(func_protos):
-            device_dispatcher_str = self.callback_python_in_ut_template.replace(py_method=func_proto.py_method)
+            device_dispatcher_str = self.callback_python_in_ut_template.replace(
+                py_method=func_proto.py_method)
             dispatch_cases_str += self.single_case_in_ut_template.replace(case_id=idx,
                                                                           device_dispatcher=device_dispatcher_str)
         dispatch_cases_str += 'default:\n'
@@ -387,9 +416,12 @@ class TensorFuncRegCppGenerator(BaseGenerator):
         Returns:
             str: Generated device-specific dispatch string.
         """
-        ascend_dispatcher_str = self._get_single_device_dispatcher_str(func_proto, 'ascend')
-        cpu_dispatcher_str = self._get_single_device_dispatcher_str(func_proto, 'cpu')
-        gpu_dispatcher_str = self._get_single_device_dispatcher_str(func_proto, 'gpu')
+        ascend_dispatcher_str = self._get_single_device_dispatcher_str(
+            func_proto, 'ascend')
+        cpu_dispatcher_str = self._get_single_device_dispatcher_str(
+            func_proto, 'cpu')
+        gpu_dispatcher_str = self._get_single_device_dispatcher_str(
+            func_proto, 'gpu')
         device_dispatcher_str = self.device_dispatcher_template.replace(ascend_dispatcher=ascend_dispatcher_str,
                                                                         cpu_dispatcher=cpu_dispatcher_str,
                                                                         gpu_dispatcher=gpu_dispatcher_str)
@@ -409,8 +441,15 @@ class TensorFuncRegCppGenerator(BaseGenerator):
         func_proto_device = getattr(func_proto, device)
         if func_proto_device == 'pyboost':
             arg_handler_processor_str = self._get_arg_handler_processor(func_proto.func_name, func_proto.op_proto)
+            op_parser = OpTemplateParser(func_proto.op_proto)
+            op_pyboost_func_name = op_parser.get_pyboost_func_name() + "_OP"
+            convert_args_str = op_parser.get_convert_args_str(func_proto.op_proto, is_tensor_api=True)
+            self_index = op_parser.get_input_tensor_index(func_proto.op_proto)
             return self.pyboost_return_template.replace(arg_handler_processor=arg_handler_processor_str,
-                                                        class_name=func_proto.op_proto.op_class.name)
+                                                        class_name=func_proto.op_proto.op_class.name,
+                                                        pyboost_function=op_pyboost_func_name,
+                                                        self_index=self_index,
+                                                        convert_args=convert_args_str)
 
         if func_proto_device == 'py_method':
             return self.callback_python_template.replace(py_method=func_proto.py_method)

mindspore/ops_generate/common/gen_constants.py

@@ -0,0 +1,91 @@
+# 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.
+# ============================================================================
+"""
+This module contains the constant strings used in generating ops files.
+
+Constants:
+    PY_LICENSE: License strings used for .py files
+    CC_LICENSE: License strings used for .h/.cc files
+    ......
+    Other constant strings in the module are used for generation paths
+"""
+
+import os
+
+
+WORK_DIR = os.path.normpath(os.path.join(
+    os.path.dirname(os.path.realpath(__file__)), '../../../../../'))
+
+PY_MS_DIR = "mindspore/python/mindspore"
+PY_OPS_GEN_PATH = "mindspore/python/mindspore/ops_generate"
+PY_AUTO_GEN_PATH = "mindspore/python/mindspore/ops/auto_generate"
+
+# op_def
+OP_DEF_AUTO_GENERATE_PATH = "op_def/auto_generate"
+MS_OP_DEF_AUTO_GENERATE_PATH = "mindspore/ops/op_def/auto_generate"
+MS_OP_DEF_YAML_PATH = "mindspore/ops/op_def/yaml"
+MS_OP_DEF_FUNC_OP_YAML_PATH = "mindspore/ops/op_def/func_op"
+MS_OP_DEPRECATED_DEF_YAML_PATH = "mindspore/ops/op_def/deprecated"
+MS_OP_API_YAML_PATH = "mindspore/ops/api_def"
+MS_TENSOR_METHOD_DOC_YAML_PATH = "mindspore/ops/api_def/method_doc"
+MS_MINT_FUNC_DOC_YAML_PATH = "mindspore/ops/api_def/function_doc"
+MS_MINT_FUNC_OVERLOAD_PATH = "mindspore/python/mindspore/ops"
+PYBOOST_NATIVE_GRAD_FUNC_GEN_PATH = "mindspore/ccsrc/pynative/grad/function/auto_generate"
+PYBOOST_AUTO_GRAD_FUNC_GEN_PATH = "mindspore/ccsrc/pynative/op_function/auto_generate"
+PIPELINE_PYBOOST_FUNC_GEN_PATH = "mindspore/ccsrc/pynative/op_function/auto_generate"
+FUNCTIONAL_OVERLOAD_GEN_PATH = "mindspore/ccsrc/frontend/operator/composite/auto_generate"
+PYBOOST_GRAD_FUNC_GEN_PATH = "mindspore/ccsrc/pyboost/grad_functions/auto_generate"
+TENSOR_FUNC_REGISTER_PATH = "mindspore/ccsrc/pynative/op_function/auto_generate"
+TENSOR_API_PATH = "mindspore/ccsrc/pybind_api/ir/tensor_api/auto_generate"
+ADD_TENSOR_DOCS_PY_PATH = "mindspore/python/mindspore/common"
+ADD_MINT_DOCS_PY_PATH = "mindspore/python/mindspore/mint"
+TENSOR_PY_CC_PATH = "mindspore/ccsrc/pybind_api/ir/tensor_register/auto_generate"
+
+# yaml keys def
+OP_KEYS = {'args', 'args_signature', 'returns', 'function',
+           'class', 'view', 'dispatch', 'labels', 'bprop_expander'}
+ARG_KEYS = {'dtype', 'default', 'prim_init', 'type_cast', 'arg_handler'}
+RETURN_KEYS = {'dtype', 'inplace', 'type_cast'}
+ARG_SIGNATURE_KEYS = {'rw_write', 'rw_read', 'rw_ref', 'dtype_group'}
+CLASS_KEYS = {'name', 'disable'}
+FUNCTION_KEYS = {'name', 'disable'}
+DISPATCH_KEYS = {'enable', 'is_comm_op', 'Ascend', 'GPU', 'CPU'}
+TENSOR_FUNC_KEYS = {'op_yaml', 'py_method', 'kwonlyargs',
+                    'varargs', 'alias', 'Ascend', 'GPU', 'CPU', 'interface'}
+
+# func signature parsing
+ARG_HANDLER_MAP = {"to_2d_paddings": "int|tuple[int]|list[int]",
+                   "dtype_to_type_id": "type",
+                   "to_kernel_size": "int|tuple[int]|list[int]",
+                   "to_strides": "int|tuple[int]|list[int]",
+                   "str_to_enum": "str",
+                   "to_pair": "int|tuple[int]|list[int]|float",
+                   "to_dilations": "tuple[int]|list[int]|int",
+                   "to_output_padding": "int|tuple[int]|list[int]",
+                   "to_rates": "int|tuple[int]|list[int]"}
+INPUT_ARGS_NAME = {"input", "x", "input_x"}
+INPUT_NAME_MAP = {"DeprecatedExpandAs": "input"}
+
+# infer
+MS_OPS_FUNC_IMPL_PATH = "mindspore/ops/infer/ops_func_impl"
+
+# view
+MS_OPS_VIEW_PATH = "mindspore/ops/view"
+
+# kernel
+MS_OPS_KERNEL_PATH = "mindspore/ops/kernel"
+MS_PYBOOST_FUNCTIONS_AUTO_GEN_PATH = "mindspore/ccsrc/pyboost/functions/auto_generate"
+MS_COMMON_PYBOOST_KERNEL_PATH = os.path.join(MS_OPS_KERNEL_PATH, "common/pyboost")
+MS_PYBOOST_BASE_PATH = "mindspore/ccsrc/pyboost"