mindspore 2.4.10__cp310-cp310-win_amd64.whl → 2.5.0__cp310-cp310-win_amd64.whl

mindspore/ops_generate/template.py

@@ -1,4 +1,4 @@
-# Copyright 2023 Huawei Technologies Co., Ltd
+# 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.
@@ -12,15 +12,15 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ============================================================================
-"""Template."""
+"""Templates for code auto generation."""
 import re
 import os
 import gen_constants as K
 
 
-class CppTemplate:
+class Template:
     """
-    template for generate c++ code
+    template for generate c++/python code
     """
     regular_str = r"(^[^\n\S]*)?\$([^\d\W]\w*|\{,?[^\d\W]\w*\,?})"
     regular_match = re.compile(regular_str, re.MULTILINE)
@@ -31,7 +31,7 @@ class CppTemplate:
     @staticmethod
     def load_from_file(file_path):
         with open(file_path, "r") as f:
-            return CppTemplate(f.read())
+            return Template(f.read())
 
     def replace(self, **kwargs):
         """
@@ -82,12 +82,12 @@ class CppTemplate:
 NEW_LINE = "\n"
 WORK_PATH = os.path.join(os.path.dirname(os.path.realpath(__file__)), "../../../../")
 
-PYTHON_PRIM_TEMPLATE = CppTemplate("""
+PYTHON_PRIM_TEMPLATE = Template("""
 
 class _Pyboost${class_name}Prim(${class_name}Prim_):
     def __call__(self, ${input_args}):
         ${process_func}
-        return _convert_stub(super().__call__(${processed_args}))
+        return _convert_stub(super().__call__([${processed_args}]))
 
 
 ${func_impl_name}_impl = _Pyboost${class_name}Prim()
@@ -104,134 +104,214 @@ from mindspore.ops.auto_generate.pyboost_inner_prim import *
 
 """
 
-REGISTER_DEFINE_TEMPLATE = CppTemplate(
+REGISTER_DEFINE_TEMPLATE = Template(
     """
     (void)py::class_<${class_name}PrimAdapter, PrimitiveFunctionAdapter, std::shared_ptr<${class_name}PrimAdapter>>(
       *m, "${class_name}Prim_")
       .def(py::init<>())
       .def("__call__", &${class_name}PrimAdapter::Call, "Call ${class_name} op.");
     m->def(\"${pyboost_op_name}\", &mindspore::pynative::${pyboost_cfunc_name}, \"Encrypt the data.\");""")
-REGISTER_TEMPLATE = CppTemplate("void RegisterPyBoostFunction(py::module *m) {${register_func}\n}")
+REGISTER_TEMPLATE = Template("void RegisterPyBoostFunction(py::module *m) {${register_func}\n}")
 
-REGISTER_PYBOOST_GRAD_DEFINE_TEMPLATE = CppTemplate(
+REGISTER_PYBOOST_GRAD_DEFINE_TEMPLATE = Template(
     "MS_REG_PYBOOST_GRAD_OP(${pyboost_op_name}, mindspore::runtime::${pyboost_cfunc_name});\n")
-REGISTER_PYBOOST_GRAD_TEMPLATE = CppTemplate("${register_func}")
+REGISTER_PYBOOST_GRAD_TEMPLATE = Template("${register_func}")
 
-PYBOOST_FUNCTION_TEMPLATE = CppTemplate.load_from_file(
+PYBOOST_FUNCTION_HEADER_TEMPLATE = Template.load_from_file(
+    os.path.join(WORK_PATH, './mindspore/ccsrc/pipeline/pynative/op_function/template/pyboost_functions_h.tpl'))
+
+PYBOOST_FUNCTION_TEMPLATE = Template.load_from_file(
     os.path.join(WORK_PATH, './mindspore/ccsrc/pipeline/pynative/op_function/template/pyboost_function.tpl'))
 
-PYBOOS_COMM_FUNCTION_TEMPLATE = CppTemplate.load_from_file(
+PYBOOST_COMM_FUNCTION_TEMPLATE = Template.load_from_file(
     os.path.join(WORK_PATH, './mindspore/ccsrc/pipeline/pynative/op_function/template/pyboost_comm_function.tpl'))
 
-PYBOOST_HEADER_TEMPLATE = CppTemplate.load_from_file(
-    os.path.join(WORK_PATH, './mindspore/ccsrc/pipeline/pynative/op_function/template/pyboost_function_header.tpl'))
+PYBOOST_FUNCTIONS_CC_TEMPLATE = Template.load_from_file(
+    os.path.join(WORK_PATH, './mindspore/ccsrc/pipeline/pynative/op_function/template/pyboost_functions_cc.tpl'))
+
+PYBOOST_OVERLOAD_FUNCTIONS_CC_TEMPLATE = Template.load_from_file(
+    os.path.join(
+        WORK_PATH, './mindspore/ccsrc/pipeline/pynative/op_function/template/pyboost_overload_functions_cc.tpl'))
+
+PYBOOST_MINT_CLASS_DEF = Template.load_from_file(
+    os.path.join(WORK_PATH, './mindspore/ccsrc/pipeline/pynative/op_function/template/pyboost_mint_class_def.tpl'))
+
+PYBOOST_OVERLOAD_MINT_CLASS_DEF = Template.load_from_file(
+    os.path.join(
+        WORK_PATH, './mindspore/ccsrc/pipeline/pynative/op_function/template/pyboost_overload_mint_class_def.tpl'))
+
+# template path need to be moved
+FUNCTIONAL_OVERLOAD_PY_TEMPLATE = Template.load_from_file(
+    os.path.join(
+        WORK_PATH, './mindspore/ccsrc/pipeline/pynative/op_function/template/functional_overload_py.tpl')
+)
+
+TENSOR_FUNC_CC_REG = Template.load_from_file(
+    os.path.join(WORK_PATH, './mindspore/ccsrc/pipeline/pynative/op_function/template/tensor_func_cc_reg.tpl'))
+
+TENSOR_API_HEADER = Template.load_from_file(
+    os.path.join(WORK_PATH, './mindspore/ccsrc/pipeline/pynative/op_function/template/tensor_api_header.tpl'))
+
+TENSOR_API_SOURCE = Template.load_from_file(
+    os.path.join(WORK_PATH, './mindspore/ccsrc/pipeline/pynative/op_function/template/tensor_api_source.tpl'))
+
+TENSOR_FUNC_UTILS = Template.load_from_file(
+    os.path.join(WORK_PATH, './mindspore/ccsrc/pipeline/pynative/op_function/template/tensor_func_utils_header.tpl'))
+
+
+TENSOR_FUNC_CALL_BODY = Template.load_from_file(
+    os.path.join(WORK_PATH, './mindspore/ccsrc/pipeline/pynative/op_function/template/tensor_func_call_body.tpl'))
+
+TENSOR_FUNC_OVERLOAD_CALL_BODY = Template.load_from_file(
+    os.path.join(WORK_PATH,
+                 './mindspore/ccsrc/pipeline/pynative/op_function/template/tensor_func_overload_call_body.tpl'))
 
-PYBOOST_GRAD_FUNCTION_TEMPLATE = CppTemplate.load_from_file(
+TENSOR_FUNC_UT_BODY = Template.load_from_file(
+    os.path.join(WORK_PATH,
+                 './mindspore/ccsrc/pipeline/pynative/op_function/template/tensor_func_ut_body.tpl'))
+
+TENSOR_FUNC_UT_OVERLOAD_BODY = Template.load_from_file(
+    os.path.join(WORK_PATH,
+                 './mindspore/ccsrc/pipeline/pynative/op_function/template/tensor_func_ut_overload_body.tpl'))
+
+TENSOR_CPP_METHOD = Template.load_from_file(
+    os.path.join(WORK_PATH,
+                 './mindspore/ccsrc/pipeline/pynative/op_function/template/tensor_cpp_method.tpl'))
+
+TENSOR_FUNC_CLASS_REG = Template.load_from_file(
+    os.path.join(WORK_PATH, './mindspore/ccsrc/pipeline/pynative/op_function/template/tensor_func_class_reg.tpl'))
+
+
+PYBOOST_GRAD_FUNCTION_TEMPLATE = Template.load_from_file(
     os.path.join(WORK_PATH, './mindspore/ccsrc/runtime/pynative/op_function/template/pyboost_grad_function.tpl'))
 
-PYBOOST_GRAD_HEADER_TEMPLATE = CppTemplate.load_from_file(
+PYBOOST_GRAD_HEADER_TEMPLATE = Template.load_from_file(
     os.path.join(WORK_PATH, './mindspore/ccsrc/runtime/pynative/op_function/template/pyboost_grad_function_header.tpl'))
 
-PYBOOST_NATIVE_GRAD_FUNCTION_TEMPLATE = CppTemplate.load_from_file(
+PYBOOST_NATIVE_GRAD_FUNCTION_TEMPLATE = Template.load_from_file(
     os.path.join(WORK_PATH, './mindspore/ccsrc/pipeline/pynative/grad/function/template/native_grad_function.tpl'))
 
-PYBOOST_NATIVE_GRAD_FUNCTIONS_TEMPLATE = CppTemplate.load_from_file(
+PYBOOST_NATIVE_GRAD_FUNCTIONS_TEMPLATE = Template.load_from_file(
     os.path.join(WORK_PATH,
                  './mindspore/ccsrc/pipeline/pynative/grad/function/template/pyboost_native_grad_functions.tpl'))
 
-PYBOOST_NATIVE_GRAD_FUNCTIONS_HEADER_TEMPLATE = CppTemplate.load_from_file(
+PYBOOST_NATIVE_GRAD_FUNCTIONS_HEADER_TEMPLATE = Template.load_from_file(
     os.path.join(WORK_PATH,
                  './mindspore/ccsrc/pipeline/pynative/grad/function/template/pyboost_native_grad_functions_header.tpl'))
 
-GEN_OPS_DEF_HEADER_TEMPLATE = CppTemplate.load_from_file(
+GEN_OPS_DEF_HEADER_TEMPLATE = Template.load_from_file(
     os.path.join(WORK_PATH, './mindspore/python/mindspore/ops_generate/gen_ops_def_header.tpl'))
 
-PYBOOST_BASE_OP_DEFINE_TEMPLATE = CppTemplate.load_from_file(
+PYBOOST_BASE_OP_DEFINE_TEMPLATE = Template.load_from_file(
     os.path.join(WORK_PATH, f'./{K.MS_COMMON_PYBOOST_KERNEL_PATH}/template/pyboost_op_header.tpl'))
 
-PYBOOST_OP_REGISTER_TEMPLATE = CppTemplate.load_from_file(
+PYBOOST_OP_REGISTER_TEMPLATE = Template.load_from_file(
     os.path.join(WORK_PATH, f'./{K.MS_COMMON_PYBOOST_KERNEL_PATH}/template/pyboost_op_register.tpl'))
 
 # Ascend op generate
-PYBOOST_ASCEND_OP_HEADER_TEMPLATE = CppTemplate.load_from_file(
+PYBOOST_ASCEND_OP_HEADER_TEMPLATE = Template.load_from_file(
     os.path.join(WORK_PATH,
                  f'./{K.MS_OPS_KERNEL_PATH}/ascend/pyboost/template/pyboost_aclnn_header_template.tpl'))
 
-PYBOOST_ASCEND_OP_SOURCE_TEMPLATE = CppTemplate.load_from_file(
+PYBOOST_ASCEND_OP_SOURCE_TEMPLATE = Template.load_from_file(
     os.path.join(WORK_PATH,
                  f'./{K.MS_OPS_KERNEL_PATH}/ascend/pyboost/template/pyboost_aclnn_source_template.tpl'))
 
-PYBOOST_ASCEND_CALL_TEMPLATE = CppTemplate.load_from_file(
+PYBOOST_ASCEND_SINGLE_OP_HEADER_TEMPLATE = Template.load_from_file(
+    os.path.join(WORK_PATH,
+                 f'./{K.MS_OPS_KERNEL_PATH}/ascend/pyboost/template/pyboost_aclnn_single_op_header_template.tpl'))
+
+PYBOOST_ASCEND_SINGLE_OP_SOURCE_TEMPLATE = Template.load_from_file(
+    os.path.join(WORK_PATH,
+                 f'./{K.MS_OPS_KERNEL_PATH}/ascend/pyboost/template/pyboost_aclnn_single_op_source_template.tpl'))
+
+PYBOOST_ASCEND_CALL_TEMPLATE = Template.load_from_file(
     os.path.join(WORK_PATH,
                  f'./{K.MS_OPS_KERNEL_PATH}/ascend/pyboost/template/pyboost_ascend_call_template.tpl'))
 
-PYBOOST_ASCEND_VIEW_CALL_TEMPLATE = CppTemplate.load_from_file(
+PYBOOST_ASCEND_VIEW_CALL_TEMPLATE = Template.load_from_file(
     os.path.join(WORK_PATH,
                  f'./{K.MS_COMMON_PYBOOST_KERNEL_PATH}/template/'
                  'pyboost_view_template.tpl'))
 
-PYBOOST_ASCEND_CUSTOMIZE_CALL_TEMPLATE = CppTemplate.load_from_file(
+PYBOOST_ASCEND_CUSTOMIZE_CALL_TEMPLATE = Template.load_from_file(
     os.path.join(WORK_PATH,
                  f'./{K.MS_OPS_KERNEL_PATH}/ascend/pyboost/template'
                  '/pyboost_ascend_customize_call_template.tpl'))
 
 # GPU op generate
-PYBOOST_GPU_OP_HEADER_TEMPLATE = CppTemplate.load_from_file(
+PYBOOST_GPU_OP_HEADER_TEMPLATE = Template.load_from_file(
     os.path.join(WORK_PATH,
                  './mindspore/ops/kernel/gpu/pyboost/template/pyboost_gpu_header_template.tpl'))
 
-PYBOOST_GPU_OP_SOURCE_TEMPLATE = CppTemplate.load_from_file(
+PYBOOST_GPU_OP_SOURCE_TEMPLATE = Template.load_from_file(
     os.path.join(WORK_PATH,
                  './mindspore/ops/kernel/gpu/pyboost/template/pyboost_gpu_source_template.tpl'))
 
-PYBOOST_GPU_CALL_TEMPLATE = CppTemplate.load_from_file(
+PYBOOST_GPU_SINGLE_OP_HEADER_TEMPLATE = Template.load_from_file(
+    os.path.join(WORK_PATH,
+                 './mindspore/ops/kernel/gpu/pyboost/template/pyboost_gpu_single_op_header_template.tpl'))
+
+PYBOOST_GPU_SINGLE_OP_SOURCE_TEMPLATE = Template.load_from_file(
+    os.path.join(WORK_PATH,
+                 './mindspore/ops/kernel/gpu/pyboost/template/pyboost_gpu_single_op_source_template.tpl'))
+
+PYBOOST_GPU_CALL_TEMPLATE = Template.load_from_file(
     os.path.join(WORK_PATH,
                  './mindspore/ops/kernel/gpu/pyboost/template/pyboost_gpu_call_template.tpl'))
 
-PYBOOST_GPU_VIEW_CALL_TEMPLATE = CppTemplate.load_from_file(
+PYBOOST_GPU_VIEW_CALL_TEMPLATE = Template.load_from_file(
     os.path.join(WORK_PATH,
                  f'./{K.MS_COMMON_PYBOOST_KERNEL_PATH}/template/pyboost_view_template.tpl'))
 
-PYBOOST_GPU_CUSTOMIZE_CALL_TEMPLATE = CppTemplate.load_from_file(
+PYBOOST_GPU_CUSTOMIZE_CALL_TEMPLATE = Template.load_from_file(
     os.path.join(WORK_PATH,
                  './mindspore/ops/kernel/gpu/pyboost/template'
                  '/pyboost_gpu_customize_call_template.tpl'))
 
 # CPU op generate
-PYBOOST_CPU_OP_HEADER_TEMPLATE = CppTemplate.load_from_file(
+PYBOOST_CPU_OP_HEADER_TEMPLATE = Template.load_from_file(
     os.path.join(WORK_PATH,
                  f'./{K.MS_OPS_KERNEL_PATH}/cpu/pyboost/template/pyboost_cpu_header_template.tpl'))
 
-PYBOOST_CPU_OP_SOURCE_TEMPLATE = CppTemplate.load_from_file(
+PYBOOST_CPU_OP_SOURCE_TEMPLATE = Template.load_from_file(
     os.path.join(WORK_PATH,
                  f'./{K.MS_OPS_KERNEL_PATH}/cpu/pyboost/template/pyboost_cpu_source_template.tpl'))
 
-PYBOOST_CPU_CALL_TEMPLATE = CppTemplate.load_from_file(
+PYBOOST_CPU_SINGLE_OP_HEADER_TEMPLATE = Template.load_from_file(
+    os.path.join(WORK_PATH,
+                 f'./{K.MS_OPS_KERNEL_PATH}/cpu/pyboost/template/pyboost_cpu_single_op_header_template.tpl'))
+
+PYBOOST_CPU_SINGLE_OP_SOURCE_TEMPLATE = Template.load_from_file(
+    os.path.join(WORK_PATH,
+                 f'./{K.MS_OPS_KERNEL_PATH}/cpu/pyboost/template/pyboost_cpu_single_op_source_template.tpl'))
+
+PYBOOST_CPU_CALL_TEMPLATE = Template.load_from_file(
     os.path.join(WORK_PATH,
                  f'./{K.MS_OPS_KERNEL_PATH}/cpu/pyboost/template/pyboost_cpu_call_template.tpl'))
 
-PYBOOST_CPU_VIEW_CALL_TEMPLATE = CppTemplate.load_from_file(
+PYBOOST_CPU_VIEW_CALL_TEMPLATE = Template.load_from_file(
     os.path.join(WORK_PATH,
                  f'./{K.MS_COMMON_PYBOOST_KERNEL_PATH}/template/pyboost_view_template.tpl'))
 
-PYBOOST_CPU_CUSTOMIZE_CALL_TEMPLATE = CppTemplate.load_from_file(
+PYBOOST_CPU_CUSTOMIZE_CALL_TEMPLATE = Template.load_from_file(
     os.path.join(WORK_PATH,
                  f'./{K.MS_OPS_KERNEL_PATH}/cpu/pyboost/template'
                  '/pyboost_cpu_customize_call_template.tpl'))
 
-PYBOOST_PY_FUNC_IMPORT_HEADEAR = CppTemplate(
+PYBOOST_PY_FUNC_IMPORT_HEADEAR = Template(
     """from mindspore._c_expression import ${class_name}Prim_\n"""
 )
 
-PYBOOST_PY_FUNC_TEMPLATE = CppTemplate("""
+PYBOOST_PY_FUNC_TEMPLATE = Template("""
 def ${func_name}(${func_args}):
     r\"\"\"
     ${description}
     \"\"\"
     return ${func_impl_name}_impl(${input_args})\n\n""")
 
-OP_PROTO_TEMPLATE = CppTemplate("""
-${class_name}FuncImpl g${class_name}FuncImpl;
+OP_PROTO_TEMPLATE = Template("""
+${func_impl_declaration}
 OpDef g${class_name} = {
   /*.name_=*/"${class_name}",
   /*.args_=*/ {
@@ -246,9 +326,10 @@ OpDef g${class_name} = {
   /*.indexes_ =*/ {
     ${indexes}
   },
-  /*.func_impl_=*/g${class_name}FuncImpl,
+  /*.func_impl_=*/${func_impl_define},
   /*.enable_dispatch_ =*/${enable_dispatch},
   /*.is_view_ =*/${is_view},
+  /*.is_graph_view_ =*/${is_graph_view},
 };
 REGISTER_PRIMITIVE_OP_DEF(${class_name}, &g${class_name});
 """)
@@ -258,4 +339,173 @@ ValuePtrList values;
 (void)std::transform(op->outputs().begin(), op->outputs().end(), std::back_inserter(values),
                    [](const auto &value){ return value;});
 auto output_value = std::make_shared<ValueTuple>(values);
-"""
+"""
+
+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.
+# ============================================================================
+"""
+
+OPS_PY_PRIM_HEADER = f"""
+\"\"\"Operators definition generated by gen_ops.py, includes primitive classes.\"\"\"
+
+from mindspore.ops.primitive import Primitive, prim_arg_register
+from mindspore.ops import signature as sig
+from mindspore.common import dtype as mstype
+from mindspore.common._decorator import deprecated
+from mindspore.ops._primitive_cache import _get_cache_prim
+from mindspore.ops.auto_generate.gen_arg_dtype_cast import type_it
+from mindspore.ops.auto_generate.gen_arg_handler import *
+from mindspore._c_expression import OpDtype
+from mindspore.common._stub_tensor import _convert_stub
+"""
+
+OP_PRIM_CLASS_DEFINE_TEMPLATE = Template("""
+
+class ${class_name}(Primitive):
+${class_desc}${signature_code}${deprecated_code}
+${init_method}
+
+${call_method}""")
+
+OPS_PY_DEF_HEADER = f"""
+\"\"\"Operators definition generated by gen_ops.py, includes functions.\"\"\"
+
+from .gen_ops_prim import *
+from .pyboost_inner_prim import *
+from mindspore.ops.operations.manually_defined.ops_def import *
+from mindspore.ops._primitive_cache import _get_cache_prim
+"""
+
+PRIMITIVE_CLASS_DESC = """    r\"\"\"
+    .. code-block::
+
+        prim = ops.$class_name($init_args_str)
+        out = prim($input_args_str)
+
+    is equivalent to
+
+    .. code-block::
+
+        ops.$func_name($args_str)
+
+    Refer to :func:`mindspore.ops.$func_name` for more details.
+    \"\"\"
+"""
+
+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.
+ */"""
+
+arg_default_value = Template("""
+\"\"\"Operator labels and args default value.\"\"\"
+from mindspore.common import dtype as mstype
+
+op_args_default_value = {
+$gen_default_py
+}
+""")
+
+
+op_labels_template = Template("""
+op_labels = {
+$gen_label_py
+}
+""")
+
+
+lite_ops_h_class_template = Template("""class OPS_API ${op_name} : public BaseOperator {
+ public:
+  MIND_API_BASE_MEMBER(${op_name});
+  ${op_name}() : BaseOperator(kName${op_name}) {}${lite_ops_h_code}
+};
+
+""")
+
+op_cc_template = Template("""class OPS_API ${op_name} : public BaseOperator {
+ public:
+  MIND_API_BASE_MEMBER(${op_name});
+  ${op_name}() : BaseOperator(kName${op_name}) {}${arg_prim_init_list}
+};
+
+""")
+
+op_template = Template("""void ${op_name}::set_${arg_name}(const ${dtype} &${arg_name})"""
+                       """             { (void)this->AddAttr("${arg_name}", api::MakeValue(${arg_name})); }\n\n"""
+                       """${dtype} ${op_name}::get_${arg_name}() const"""
+                       """             { return GetValue<${dtype}>(GetAttr("${arg_name}")); }\n\n""")
+
+ACLNN_KERNEL_CC_TEMPLATE = Template.load_from_file(
+    os.path.join(WORK_PATH, f'./{K.MS_OPS_KERNEL_PATH}/ascend/opapi/template/aclnn_kernel_cc.tpl'))
+
+ACLNN_KERNEL_H_TEMPLATE = Template.load_from_file(
+    os.path.join(WORK_PATH, f'./{K.MS_OPS_KERNEL_PATH}/ascend/opapi/template/aclnn_kernel_h.tpl'))
+
+update_output_shape_and_size_template = Template("""
+void ${kernelmod_name}::UpdateOutputShapeAndSize(const std::vector<KernelTensor *> &,
+                                                const std::vector<KernelTensor *> &outputs) {
+  // Delete these comment and complete the function:
+  // Using outputs[index_x]->SetShapeVector(update_shape) and outputs[index_x]->set_size(update_size)
+}
+""")
+
+
+UPDATE_OUTPUT_SHAPE_AND_SIZE = """
+  bool IsNeedUpdateOutputShapeAndSize() override { return true; }
+  void UpdateOutputShapeAndSize(const std::vector<KernelTensor *> &inputs, const std::vector<KernelTensor *> &outputs);
+"""
+TUPLE_TENSOR_NOT_SUPPORTED = Template("""
+    It is not supported for ${op_name} with tuple[tensor] inputs when using auto generate.
+    Please provide a KernelMod name in yaml and using python gen_aclnn_implement.py -n xx manually.""")
+
+FUNCTIONAL_MAP_CC_TEMPLATE = Template.load_from_file(
+    os.path.join(WORK_PATH,
+                 f'./mindspore/ccsrc/pipeline/pynative/op_function/template/functional_map_cc.tpl'))
+
+FUNCTIONAL_MAP_H_TEMPLATE = Template.load_from_file(
+    os.path.join(WORK_PATH,
+                 f'./mindspore/ccsrc/pipeline/pynative/op_function/template/functional_map_h.tpl'))
+
+ADD_TENSOR_DOCS_TEMPLATE = Template.load_from_file(
+    os.path.join(WORK_PATH, './mindspore/ccsrc/pipeline/pynative/op_function/template/tensor_docs_py.tpl'))
+
+AUTO_GRAD_IMPL_CC_TEMPLATE = Template.load_from_file(
+    os.path.join(WORK_PATH, './mindspore/ccsrc/pipeline/pynative/op_function/template/auto_grad_impl_cc.tpl'))
+
+AUTO_GRAD_REG_H_TEMPLATE = Template.load_from_file(
+    os.path.join(WORK_PATH, './mindspore/ccsrc/pipeline/pynative/op_function/template/auto_grad_reg_h.tpl'))
+
+FUNCTIONS_CC_TEMPLATE = Template.load_from_file(
+    os.path.join(WORK_PATH, './mindspore/ccsrc/pipeline/pynative/op_function/template/functions_cc.tpl'))
+
+FUNCTION_BODY_TEMPLATE = Template.load_from_file(
+    os.path.join(WORK_PATH, './mindspore/ccsrc/pipeline/pynative/op_function/template/function_body.tpl'))
+
+FUNCTIONS_H_TEMPLATE = Template.load_from_file(
+    os.path.join(WORK_PATH, './mindspore/ccsrc/pipeline/pynative/op_function/template/functions_h.tpl'))
+
+DO_GRAD_FUNCTION_BODY_TEMPLATE = Template.load_from_file(
+    os.path.join(WORK_PATH, './mindspore/ccsrc/pipeline/pynative/op_function/template/do_grad_function.tpl'))