mindspore 1.10.0__cp38-cp38-win_amd64.whl → 2.0.0rc1__cp38-cp38-win_amd64.whl

mindspore/rewrite/ast_transformers/flatten_recursive_stmt.py

@@ -13,11 +13,14 @@
 # limitations under the License.
 # ============================================================================
 """Ast optimizer for flatten recursive call."""
-from __future__ import absolute_import
+
 from typing import Any, Tuple
 import ast
 from ast import FunctionDef
+import astunparse
+
 from mindspore import log as logger
+from ..common import error_str
 
 
 class FlattenRecursiveStmt(ast.NodeTransformer):
@@ -35,7 +38,8 @@ class FlattenRecursiveStmt(ast.NodeTransformer):
             ast.Call: ["args"],
             ast.BinOp: ["left", "right"],
             ast.BoolOp: ["values"],
-            ast.unaryop: ["operand"],
+            ast.UnaryOp: ["operand"],
+            ast.Compare: ["left", "comparators"],
         }
 
     @staticmethod
@@ -52,7 +56,7 @@ class FlattenRecursiveStmt(ast.NodeTransformer):
                 target_name = "function"
         elif isinstance(node, ast.Return):
             target_name = "return_value"
-        elif isinstance(node, (ast.BinOp, ast.boolop, ast.UnaryOp)):
+        elif isinstance(node, (ast.BinOp, ast.BoolOp, ast.UnaryOp)):
             target_name = type(node.op).__name__.lower() + "_var"
         elif isinstance(node, ast.Tuple):
             target_name = type(node).__name__.lower() + "_var"
@@ -79,6 +83,20 @@ class FlattenRecursiveStmt(ast.NodeTransformer):
         new_target_name = FlattenRecursiveStmt._generate_target_name(node, target_names)
         return new_target_name, ast.Assign(targets=[ast.Name(id=new_target_name, ctx=ast.Store())], value=node)
 
+    @staticmethod
+    def _flatten_list(node_list, target_names):
+        """Flatten a list of node."""
+        results = list()
+        new_list = list()
+        for node in node_list:
+            if isinstance(node, ast.Call):
+                new_target, new_node = FlattenRecursiveStmt._create_new_assign_node(node, target_names)
+                results.append(new_node)
+                new_list.append(ast.Name(id=new_target, ctx=ast.Load()))
+            else:
+                new_list.append(node)
+        return results, new_list
+
     def _flatten_statement(self, node: ast.AST, target_names) -> [ast.AST]:
         """Flatten recursive statement according to different node type."""
         flatten_config = self._flatten_table.get(type(node))
@@ -96,6 +114,10 @@ class FlattenRecursiveStmt(ast.NodeTransformer):
                     else:
                         new_list.append(ast.Name(id=new_target_name, ctx=ast.Load()))
                         results.append(new_node)
+                    if isinstance(todo, (ast.Tuple, tuple)):
+                        _res, _new_list = FlattenRecursiveStmt._flatten_list(new_node.value.elts, [new_target_name])
+                        new_node.value.elts = _new_list
+                        results.extend(_res)
                 setattr(node, todo_name, new_list)
             elif isinstance(todos, dict):
                 new_dict = []
@@ -130,7 +152,9 @@ class FlattenRecursiveStmt(ast.NodeTransformer):
             targets = child.targets
             for target in targets:
                 if not isinstance(target, (ast.Name, ast.Tuple)):
-                    raise RuntimeError("currently only support ast.Name targets")
+                    raise RuntimeError(
+                        error_str(f"currently only support ast.Name targets, but got ast type "
+                                  f"'{type(target).__name__}'", child_node=target, father_node=child))
                 if isinstance(target, ast.Name):
                     target_name = target.id
                     if target_name not in target_names:
@@ -138,7 +162,10 @@ class FlattenRecursiveStmt(ast.NodeTransformer):
                 elif isinstance(target, ast.Tuple):
                     for elt in target.elts:
                         if not isinstance(elt, ast.Name):
-                            raise RuntimeError("currently only support ast.Name in ast.Tuple.")
+                            raise RuntimeError(
+                                error_str(f"currently only support ast.Name in ast.Tuple, "
+                                          f"but got ast type '{type(elt).__name__}'", child_node=elt,
+                                          father_node=child))
                         target_name = elt.id
                         if target_name not in target_names:
                             target_names.append(target_name)
@@ -155,6 +182,20 @@ class FlattenRecursiveStmt(ast.NodeTransformer):
             child = node.body[index]
             if isinstance(child, ast.Assign):
                 stmt = child.value
+            elif isinstance(child, ast.If):
+                if isinstance(child.body[0], ast.Return) and not isinstance(child.test, ast.UnaryOp):
+                    if isinstance(child.body[0].value, ast.Call):
+                        if_body = child.body
+                        if_func = if_body[0].value
+                        expr = "x = " + astunparse.unparse(if_func)
+                        if_body = ast.parse(expr)
+                        if_body = if_body.body+ast.parse("return x").body
+                        child.body = if_body
+                        stmt = child
+                    else:
+                        stmt = child
+                else:
+                    stmt = child
             elif isinstance(child, ast.Expr):
                 stmt = child.value
             else:

mindspore/rewrite/ast_transformers/remove_return_out_of_if.py

@@ -13,12 +13,14 @@
 # limitations under the License.
 # ============================================================================
 """Fold if return."""
-from __future__ import absolute_import
+
 import ast
 import copy
 from typing import Any, Union
 from enum import Enum
 
+from ..common import error_str
+
 
 class ReturnType(Enum):
     """
@@ -121,7 +123,7 @@ class RemoveReturnOutOfIf(ast.NodeTransformer):
             RuntimeError: Father node has not input attr.
         """
         if not hasattr(father_node, attr):
-            raise RuntimeError('Father node has not input attr', attr)
+            raise RuntimeError(error_str(f"Father node has not input attr '{attr}'", father_node=father_node))
         father_node_attr = getattr(father_node, attr)
         if RemoveReturnOutOfIf._last_node_is_return(if_node) == ReturnType.IfNotAllReturn:
             # nodes should be copied to all branches which not end with return
@@ -193,7 +195,8 @@ class RemoveReturnOutOfIf(ast.NodeTransformer):
 
             # assert body and or-else all end with return
             if not isinstance(last_node.body[-1], ast.Return) or not isinstance(last_node.orelse[-1], ast.Return):
-                raise RuntimeError("Body and orelse of if nodes not all end with ast.Return.")
+                raise RuntimeError(error_str("Body and orelse of if nodes not all end with ast.Return.",
+                                             father_node=last_node))
             output_name = RemoveReturnOutOfIf._get_output_names(output_names)
             # replace body return
             body_new_last_node = ast.Assign(

mindspore/rewrite/common/__init__.py

@@ -16,3 +16,5 @@
 `common` package of MindSpore Rewrite package.
 Define some common instruments.
 """
+
+from .rewrite_elog import error_str

mindspore/rewrite/common/event.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 # ============================================================================
 """Event Enum as type of event."""
-from __future__ import absolute_import
+
 from enum import Enum
 
 

mindspore/rewrite/common/observable.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 # ============================================================================
 """Base class, observable of observer design pattern."""
-from __future__ import absolute_import
+
 from .observer import Observer
 from .event import Event
 

mindspore/rewrite/common/observer.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 # ============================================================================
 """Abstract class, observer of observer design pattern."""
-from __future__ import absolute_import
+
 import abc
 from .event import Event
 

mindspore/rewrite/common/rewrite_elog.py

@@ -0,0 +1,35 @@
+# Copyright 2022 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.
+# ============================================================================
+"""Error Log for Rewrite."""
+
+import ast
+import astunparse
+
+
+def error_str(reason: str, child_node: ast.expr = None, father_node: ast.expr = None) -> str:
+    """Raise error func for Rewrite."""
+    output_estr = "Unsupported grammar in MindSpore Rewrite, "
+    output_estr += reason
+    if child_node:
+        output_estr += "\n" + "-" * 100 + "\n"
+        output_estr += astunparse.unparse(child_node)
+        output_estr += "-" * 100 + "\n"
+        if father_node:
+            output_estr += "\nin\n"
+    if father_node:
+        output_estr += "-" * 100 + "\n"
+        output_estr += astunparse.unparse(father_node)
+        output_estr += "-" * 100 + "\n"
+    return output_estr

mindspore/rewrite/namer.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 # ============================================================================
 """Unique name producer for target, name of node, class name, etc."""
-from __future__ import absolute_import
+
 from typing import Union
 
 from .node import Node
@@ -153,7 +153,7 @@ class NodeNamer(Namer):
         if isinstance(node_or_name, Node):
             origin_name = node_or_name.get_name()
             if origin_name is None or not origin_name:
-                if node_or_name.get_node_type() in (NodeType.CallCell, NodeType.CallPrimitive):
+                if node_or_name.get_node_type() in (NodeType.CallCell, NodeType.CallPrimitive, NodeType.CallFunction):
                     if not isinstance(node_or_name, Node):
                         raise TypeError("node_or_name should be Node, got: ", type(node_or_name))
                     targets = node_or_name.get_targets()

mindspore/rewrite/namespace.py

@@ -13,22 +13,32 @@
 # limitations under the License.
 # ============================================================================
 """Define the namespace of MindSpore op definition."""
-from __future__ import absolute_import
 from .._extends.parse.namespace import CellNamespace
 
 
 _ms_common_ns = CellNamespace('mindspore.common')
 _ms_nn_ns = CellNamespace('mindspore.nn')
-_ms_ops_ns = CellNamespace('mindspore.ops')
+_ms_ops_ns = CellNamespace('mindspore.ops.operations')
+_ms_functional_ns = CellNamespace('mindspore.ops.functional')
 
 
 def is_subtree(cls_name):
     """Determine whether 'cls_name' is a subtree."""
-    if cls_name == "SequentialCell":
-        return True
     if cls_name == "QuantizeWrapperCell":
         return False
     if cls_name in _ms_common_ns or cls_name in _ms_nn_ns or cls_name in _ms_ops_ns:
         return False
 
     return True
+
+
+def is_functional(func_name):
+    """Determine whether 'cls_name' is a functional."""
+    return func_name in _ms_functional_ns
+
+
+def get_functional(func_name):
+    """Get the function corresponding to the func_name."""
+    if func_name in _ms_functional_ns:
+        return _ms_functional_ns[func_name]
+    return None

mindspore/rewrite/node.py

@@ -13,7 +13,6 @@
 # limitations under the License.
 # ============================================================================
 """Node class define of Rewrite. See detail in Node class docstring."""
-from __future__ import absolute_import
 from typing import Optional, Union
 import ast
 import inspect
@@ -21,7 +20,7 @@ import inspect
 from mindspore.nn import Cell
 from mindspore.ops import Primitive
 from mindspore import log as logger
-from .._checkparam import Validator, Rel
+from .. import _checkparam as Validator
 from .ast_helpers import AstModifier
 from .api.scoped_value import ScopedValue, ValueType
 from .api.node_type import NodeType
@@ -85,7 +84,9 @@ class Node:
         """
         self._node_type: NodeType = node_type
         self._ast_node: Optional[ast.AST] = ast_node
-        self._attribute: {str, object} = Node._get_cell_or_prim_op_attribute(instance)
+        self._attribute: {str, object} = {}
+        if node_type in (NodeType.CallModule, NodeType.CallCell, NodeType.CallPrimitive):
+            self._attribute = Node._get_cell_or_prim_op_attribute(instance)
         self._instance = instance
         self._name = name
         self._func: Optional[ScopedValue] = func
@@ -221,6 +222,32 @@ class Node:
         return cls(NodeType.Output, ast_node, None, ScopedValue.create_naming_value("return"), real_return_values, {},
                    name, None)
 
+    @classmethod
+    def create_mathops_node(cls, ast_node: ast.AST, targets: [ScopedValue],
+                            op_type: ScopedValue, args: [ScopedValue],
+                            ops: {str: list}, name: str = ""):
+        """
+        Class method of Node. Instantiate an instance of node whose type is `MathOps` .
+        A mathops node is used to represent a node with mathematical operations, such as
+        `y = a + b` , `y = not a` , `y = 0 < a < 1`, `y = a or b` , etc.
+
+        Args:
+            ast_node ([ast.AST, optional]): An instance of ast.AST represents corresponding node in ast. The type of
+                node is ast.Assign, and the type of ast_node.value is one of ast.BinOp, ast.UnaryOp, ast.BoolOp and
+                ast.Compare.
+            targets (list[ScopedValue]): Targets of mathematical operations. A list of instance of `ScopedValue`.
+                See detail in docstring of Node class.
+            op_type (ScopedValue): The type of ast_node.value saved by string. A ScopedValue with NamingValue type.
+            args (list[ScopedValue]): Values participating in the mathematical operations. All values are saved
+                sequentially in the list.
+            ops (dict[str:ScopedValue]): Operators participating in the mathematical operations. All operators are
+            saved sequentially in the dict, and keys are numbers in string format, such as {'0':'add', '1':'sub'}.
+            name (str): A string represents name of node. Name of node will be unique when inserted into `SymbolTree`.
+                Name of node also used as field name in network class. The format of mathops node name
+                is 'AstNodeName_AstOpName_n'.
+        """
+        return cls(NodeType.MathOps, ast_node, targets, op_type, args, ops, name, None)
+
     @staticmethod
     def create_call_op(op: Union[Cell, Primitive], ast_node: Optional[ast.AST], targets: [Union[ScopedValue, str]],
                        func: Union[ScopedValue, str], args: [ScopedValue] = None, kwargs: {str: ScopedValue}=None,
@@ -622,7 +649,9 @@ class Node:
             targets ([ScopedValue]): A list of instances of ScopedValue as new targets.
         """
         self._targets = targets
-        if self._node_type in (NodeType.CallCell, NodeType.CallMethod, NodeType.CallPrimitive, NodeType.Tree):
+        if self._node_type in (NodeType.CallCell, NodeType.CallMethod, NodeType.CallPrimitive,
+                               NodeType.Tree, NodeType.CallFunction, NodeType.CellContainer,
+                               NodeType.MathOps):
             self._sync_assign_targets_to_ast()
 
     def get_func(self) -> ScopedValue:
@@ -719,12 +748,12 @@ class Node:
             ValueError: If `node` has multi-outputs while `out_idx` is None or `out_idx` is not offered.
         """
         Validator.check_value_type("node", node, [Node], "Node")
-        Validator.check_int_range(arg_idx, 0, self._args_num, Rel.INC_LEFT, "arg_idx")
+        Validator.check_int_range(arg_idx, 0, self._args_num, Validator.INC_LEFT, "arg_idx")
         if out_idx is None:
             if len(node._targets) != 1:
                 raise RuntimeError("node should has one output when out_idx is not provided")
             out_idx = 0
-        Validator.check_int_range(out_idx, 0, len(node._targets), Rel.INC_LEFT, "arg_idx")
+        Validator.check_int_range(out_idx, 0, len(node._targets), Validator.INC_LEFT, "arg_idx")
         new_arg = node._targets[out_idx]
         self._normalized_args[self._normalized_args_keys[arg_idx]] = new_arg
         self._sync_arg()
@@ -741,7 +770,7 @@ class Node:
         Raises:
             ValueError: If `index` is out of range.
         """
-        Validator.check_int_range(index, 0, self._args_num, Rel.INC_LEFT, "index")
+        Validator.check_int_range(index, 0, self._args_num, Validator.INC_LEFT, "index")
         Validator.check_value_type("arg", arg, [ScopedValue, str], "Node")
         if isinstance(arg, str):
             arg = ScopedValue.create_naming_value(arg)
@@ -761,7 +790,7 @@ class Node:
         Raises:
             TypeError: Element of new argument is not an instance of ScopedValue.
         """
-        Validator.check_int_range(len(args), 0, self._args_num, Rel.INC_LEFT, "Length of args")
+        Validator.check_int_range(len(args), 0, self._args_num, Validator.INC_LEFT, "Length of args")
         Validator.check_element_type_of_iterable("args", args, [ScopedValue], "Node")
         for arg_index, arg in enumerate(args):
             if not isinstance(arg, ScopedValue):
@@ -781,7 +810,7 @@ class Node:
             TypeError: Value of new argument is not an instance of ScopedValue.
             RuntimeError: Length of new arguments is not equal to length of old arguments.
         """
-        Validator.check_int_range(len(kwargs), 0, self._kwargs_num, Rel.INC_LEFT, "Length of kwargs")
+        Validator.check_int_range(len(kwargs), 0, self._kwargs_num, Validator.INC_LEFT, "Length of kwargs")
         Validator.check_element_type_of_dict("kwargs", kwargs, [str], [ScopedValue], "Node")
         for key, arg in kwargs.items():
             if key not in self._normalized_args.keys() or key not in self._normalized_args_keys:
@@ -1097,7 +1126,7 @@ class Node:
                     elt.id = scoped_value.value
                 elif isinstance(elt, ast.Attribute) and isinstance(elt.value, ast.Name):
                     elt.value.id = scoped_value.scope
-                    elt.value = scoped_value.value
+                    elt.attr = scoped_value.value
                 else:
                     raise RuntimeError("Only support constant or symbol in tuple now")
         else:
@@ -1131,14 +1160,50 @@ class Node:
             raise RuntimeError("Unsupported return value type: ", return_value_ast)
         ast.fix_missing_locations(return_ast)
 
+    def _sync_mathops_node_args_to_ast(self):
+        """
+        Sync values from self._normalized_args to the ast node for mathematical operations.
+        """
+        if self._ast_node is None:
+            return
+        if not isinstance(self._ast_node, ast.Assign):
+            raise TypeError(f"type of node should be ast.Assign, but got {type(self._ast_node)}")
+        mathops_node = self._ast_node.value
+        if isinstance(mathops_node, ast.BinOp):
+            left = mathops_node.left
+            right = mathops_node.right
+            AstModifier.update_arg_value(self._normalized_args.get(self._normalized_args_keys[0]), left)
+            AstModifier.update_arg_value(self._normalized_args.get(self._normalized_args_keys[1]), right)
+        elif isinstance(mathops_node, ast.UnaryOp):
+            operand = mathops_node.operand
+            AstModifier.update_arg_value(self._normalized_args.get(self._normalized_args_keys[0]), operand)
+        elif isinstance(mathops_node, ast.BoolOp):
+            values = mathops_node.values
+            for arg_index in range(self._args_num):
+                arg_value = self._normalized_args.get(self._normalized_args_keys[arg_index])
+                AstModifier.update_arg_value(arg_value, values[arg_index])
+        elif isinstance(mathops_node, ast.Compare):
+            left = mathops_node.left
+            AstModifier.update_arg_value(self._normalized_args.get(self._normalized_args_keys[0]), left)
+            comparators = mathops_node.comparators
+            for arg_index in range(1, self._args_num):
+                arg_value = self._normalized_args.get(self._normalized_args_keys[arg_index])
+                AstModifier.update_arg_value(arg_value, comparators[arg_index - 1])
+        else:
+            raise TypeError("The type of 'mathops_node' must be one of (ast.BinOp, ast.UnaryOp, "
+                            "ast.BoolOp, ast.Compare), but got ", type(mathops_node))
+
     def _sync_arg(self):
         """Sync _normalized_args to corresponding ast node when updated."""
-        if self._node_type in (NodeType.CallCell, NodeType.CallPrimitive, NodeType.Tree):
+        if self._node_type in (NodeType.CallCell, NodeType.CallPrimitive, NodeType.Tree,\
+                               NodeType.CellContainer, NodeType.CallFunction):
             self._sync_call_cell_args_to_ast()
         elif self._node_type == NodeType.Output:
             self._sync_return_node_to_ast()
         elif self._node_type == NodeType.CallMethod:
             self._sync_call_method_args_to_ast()
+        elif self._node_type == NodeType.MathOps:
+            self._sync_mathops_node_args_to_ast()
 
 
 class TreeNode(Node):
@@ -1186,8 +1251,6 @@ class TreeNode(Node):
             instance: Object in network corresponding to this node.
         """
 
-        if not isinstance(instance, Cell):
-            raise ValueError("Argument instance should be a Cell: ", type(instance))
         non_custom_args = Node._handle_custom_obj_in_args(args)
         non_custom_kwargs = Node._handle_custom_obj_in_kwargs(kwargs)
         new_targets = Node._handle_targets(targets)
@@ -1196,3 +1259,88 @@ class TreeNode(Node):
         if ast_node is None:
             ast_node = AstModifier.create_call_assign(new_targets, func, non_custom_args, non_custom_kwargs)
         return cls(tree, ast_node, new_targets, func, args, kwargs, name, instance)
+
+
+class CellContainer(Node):
+    """ Container for saving cell-objects node. """
+    class _Visitor():
+        """ A iterator of CellContainer nodes. """
+        def __init__(self, cellcontainer):
+            self._cellcontainer = cellcontainer
+
+        def __len__(self):
+            """ Get the number of nodes. """
+            return self._cellcontainer.node_count
+
+        def __iter__(self):
+            """Create an iterator over the CellContainer."""
+            count = len(self._cellcontainer.node_list)
+            i = 0
+            while i < count:
+                curr = self._cellcontainer.node_list[i]
+                if curr.valid:
+                    yield curr
+                i += 1
+
+    def __init__(self, ast_node: ast.AST, targets: [ScopedValue], func: ScopedValue,
+                 args: [ScopedValue], kwargs: {str: ScopedValue}, name: str, instance):
+        """Constructor of CellContainer.
+
+        Args:
+            ast_node (ast.AST): An instance of ast.AST represents corresponding node in ast.
+            targets (list[ScopedValue]): A list of instance of ScopedValue. See detail in docstring of Node class.
+            func ([ScopedValue, optional]): An instance of ScopedValue. See detail in docstring of Node class.
+            args (list[ScopedValue]): A list of instance of ScopedValue. See detail in docstring of Node class.
+            kwargs (dict{str: ScopedValue}): A list of instance of ScopedValue. See detail in docstring of Node class.
+            name (str): A string represents name of node. Name of node will be unique when inserted into SymbolTree.
+                Name of node also used as field name in network class.
+            instance: Object in network corresponding to this node.
+        """
+        if isinstance(func, str):
+            func = ScopedValue.create_naming_value(func)
+        super().__init__(NodeType.CellContainer, ast_node, targets, func, args, kwargs, name, instance)
+        self._node_list = list()
+        self._node_count = 0
+
+    @property
+    def node_count(self):
+        """Number of nodes."""
+        return len(self._node_list)
+
+    @property
+    def node_list(self):
+        """ Get node list. """
+        return self._node_list
+
+    def append(self, node):
+        """ Append new node to node list. """
+        setattr(node, "container", self)
+        setattr(node, "valid", True)
+        node.set_belong_symbol_tree(self.get_belong_symbol_tree())
+        self._node_list.append(node)
+        # when creating a cell_container, node instance is already in SequentialCell cell_list
+        # so here we need to write a if judgement
+        if node.get_instance() not in self.get_instance().cell_list:
+            self.get_instance().append(node.get_instance())
+
+    def erase(self, node):
+        """Erase node form container."""
+        index_node = self.node_list.index(node)
+        index_instance = self.get_instance().cell_list.index(node.get_instance())
+        if index_node != index_instance:
+            raise RuntimeError("In MindSpore Rewrite CellContainer, erasing a node raises index error!!!")
+        setattr(node, "valid", False)
+        del self.get_instance()[index_node]
+        del self._node_list[index_node]
+
+    def insert(self, index, node):
+        """Insert node into container"""
+        self.node_list.insert(index, node)
+        setattr(node, "container", self)
+        setattr(node, "valid", True)
+        node.set_belong_symbol_tree(self.get_belong_symbol_tree())
+        self.get_instance()._insert(index, node.get_instance())
+
+    def nodes(self):
+        """ Return a iterator of node."""
+        return self._Visitor(self)

mindspore/rewrite/parser.py

@@ -13,7 +13,6 @@
 # limitations under the License.
 # ============================================================================
 """Base class of parser."""
-from __future__ import absolute_import
 import abc
 import ast
 

mindspore/rewrite/parser_register.py

@@ -13,7 +13,6 @@
 # limitations under the License.
 # ============================================================================
 """Parser register."""
-from __future__ import absolute_import
 from typing import Optional
 
 from .parser import Parser

mindspore/rewrite/parsers/arguments_parser.py

@@ -13,12 +13,12 @@
 # limitations under the License.
 # ============================================================================
 """Parse ast.arguments to input-node of SymbolTree."""
-from __future__ import absolute_import
 import ast
 
 from ..parser import Parser
 from ..parser_register import reg_parser
 from ..symbol_tree import SymbolTree
+from ..common import error_str
 
 
 class ArgumentsParser(Parser):
@@ -44,7 +44,8 @@ class ArgumentsParser(Parser):
 
         for arg in node.args:
             if not isinstance(arg, ast.arg):
-                raise RuntimeError("Unsupported ast type in arguments arg: ", arg)
+                raise RuntimeError(error_str(f"only support ast.arg in arguments arg, but got '{type(arg).__name__}'",
+                                             child_node=arg, father_node=node))
             stree.append_input_node(arg, arg.arg)
 
         if hasattr(node, "vararg"):