mindspore 2.0.0a0__cp37-none-any.whl → 2.0.0rc1__cp37-none-any.whl

mindspore/rewrite/node.py

@@ -20,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
@@ -222,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,
@@ -624,7 +650,8 @@ class Node:
         """
         self._targets = targets
         if self._node_type in (NodeType.CallCell, NodeType.CallMethod, NodeType.CallPrimitive,
-                               NodeType.Tree, NodeType.CallFunction):
+                               NodeType.Tree, NodeType.CallFunction, NodeType.CellContainer,
+                               NodeType.MathOps):
             self._sync_assign_targets_to_ast()
 
     def get_func(self) -> ScopedValue:
@@ -721,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()
@@ -743,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)
@@ -763,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):
@@ -783,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:
@@ -1099,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:
@@ -1133,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):
@@ -1188,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)
@@ -1198,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/parsers/assign_parser.py

@@ -15,21 +15,23 @@
 """Parse ast.Assign in construct function to node of SymbolTree."""
 from typing import Union
 import ast
+import sys
+import inspect
 import astunparse
 
 from mindspore import log as logger
 from mindspore._extends.parse.namespace import CellNamespace
-from mindspore.nn import Cell
+from mindspore.nn import Cell, SequentialCell
 from mindspore.ops import operations as P
 from mindspore.ops import Primitive
 from mindspore.rewrite.parser_register import ParserRegister
 from mindspore.rewrite.namespace import is_subtree, is_functional, get_functional
 from mindspore.rewrite.symbol_tree import SymbolTree
-from mindspore.rewrite.node import Node, TreeNode
+from mindspore.rewrite.node import Node, TreeNode, CellContainer
 from mindspore.rewrite.parser import Parser
 from mindspore.rewrite.parser_register import reg_parser
 from mindspore.rewrite.api.scoped_value import ScopedValue, ValueType
-from mindspore.rewrite.symbol_tree_builder import SymbolTreeBuilder
+from mindspore.rewrite.symbol_tree_builder import SymbolTreeBuilder, FunctionSymbolTreeBuilder
 from mindspore.rewrite.ast_helpers import AstReplacer, AstModifier
 from mindspore.rewrite.common.event import Event
 from ..common import error_str
@@ -65,7 +67,7 @@ class AssignParser(Parser):
         tuple_elts = node.elts
         tuple_values = []
         for tuple_elt in tuple_elts:
-            if not isinstance(tuple_elt, (ast.Constant, ast.Name)):
+            if not isinstance(tuple_elt, (ast.Constant, ast.Name, ast.Attribute)):
                 raise RuntimeError(f"Only support ast.Constant or ast.Name as elts of ast.Tuple, "
                                    f"but got ast type {type(tuple_elt).__name__}",
                                    child_node=tuple_elt, father_node=node)
@@ -73,6 +75,8 @@ class AssignParser(Parser):
                 tuple_values.append(tuple_elt.value)
             elif isinstance(tuple_elt, ast.Name):
                 tuple_values.append(tuple_elt.id)
+            elif isinstance(tuple_elt, ast.Attribute):
+                tuple_values.append("".join([tuple_elt.value.id, '.', tuple_elt.attr]))
         return ScopedValue.create_variable_value(tuple(tuple_values))
 
     @staticmethod
@@ -281,15 +285,15 @@ class AssignParser(Parser):
             if len(body.targets) > 1:
                 raise NotImplementedError(error_str("not support multi-targets in assign now!", father_node=body))
             target = body.targets[0]
-            if not isinstance(target, ast.Attribute) or not (target.value, ast.Name) or target.value.id != "self":
+            if not isinstance(target, ast.Attribute) or not isinstance(target.value, ast.Name):
                 continue
-            if target.attr != func_name:
+            if target.value.id != "self" or target.attr != func_name:
                 continue
             changed = True
-            global_vars_key = "_".join([func_name, "args"])
-            stree.add_global_vars(global_vars_key, sub_tree.get_global_vars())
-            args_call = AstModifier.create_call(ScopedValue.create_naming_value("get", "global_vars"),
-                                                [ScopedValue.create_variable_value(global_vars_key)])
+            setattr(stree.get_origin_network(), func_name, sub_tree.get_origin_network())
+            args_call = AstModifier.create_call(ScopedValue(ValueType.NamingValue, "", "getattr"),
+                                                [ScopedValue(ValueType.NamingValue, "", "obj"),
+                                                 ScopedValue(ValueType.StringValue, "", func_name)])
             body.value = ast.Call(func=ast.Name(class_name, ast.Store()), args=[args_call], keywords=[])
             break
         return changed
@@ -308,6 +312,91 @@ class AssignParser(Parser):
         call_args = [AssignParser._create_scopedvalue(arg) for arg in father_ast_node.value.args]
         return Node.create_call_buildin_op(op, father_ast_node, targets, func, call_args, {})
 
+    @staticmethod
+    def _create_inputs_for_cell_container(father_ast_node) -> ['Node']:
+        """Create inputs for cell container first node."""
+        call_ast_node = father_ast_node.value
+        if not isinstance(call_ast_node, ast.Call):
+            raise RuntimeError(error_str(f"when creating input node for cellcontainer, value of input father ast node"
+                                         "is not ast.Call!'", child_node=call_ast_node, father_node=father_ast_node))
+        first_node_inputs: ['Node'] = []
+        exist_param_name = []
+        for arg in call_ast_node.args:
+            if isinstance(arg, ast.Name):
+                param_name = arg.id
+            elif isinstance(arg, ast.arg):
+                param_name = arg.arg
+            else:
+                raise RuntimeError(error_str(f"only support ast.arg, ast.arg in arguments arg, but got "
+                                             f"'{type(arg).__name__}'", child_node=arg, father_node=call_ast_node))
+            if param_name in exist_param_name:
+                raise RuntimeError(error_str(f"Cellcontianer has duplicate input names", child_node=arg,
+                                             father_node=call_ast_node))
+            exist_param_name.append(param_name)
+            node = Node.create_input_node(arg, param_name, name=f"input_{param_name}")
+            first_node_inputs.append(node)
+
+        if call_ast_node.keywords:
+            raise RuntimeError(error_str(f"Not support keyword input for cellcontainer now.",
+                                         child_node=call_ast_node, father_node=father_ast_node))
+
+        return first_node_inputs
+
+    def _cell_container_process(self, ast_node, stree, targets, func, call_args, call_kwargs, op_name, container_obj):
+        """ parse cell container object."""
+        cell_container = CellContainer(ast_node, targets, func, call_args, call_kwargs, op_name, container_obj)
+        cell_container.set_belong_symbol_tree(stree)
+        first_node_inputs = AssignParser._create_inputs_for_cell_container(ast_node)
+        for i, cell in enumerate(container_obj):
+            is_sub_tree = is_subtree(type(cell).__name__)
+            if is_sub_tree:
+                stb = SymbolTreeBuilder(cell)
+                new_stree = stb.build()
+                replacer = AstReplacer(new_stree.get_class_ast())
+                replacer.replace_all(new_stree.get_ori_cls_name(), new_stree.get_opt_cls_name())
+                sub_node = TreeNode.create_tree_node(new_stree, ast_node, targets, func, call_args, call_kwargs,
+                                                     type(cell).__name__, cell)
+            else:
+                sub_node = Node.create_call_buildin_op(cell, ast_node, targets, func, call_args, call_kwargs,
+                                                       type(cell).__name__)
+            # add sub node to cell_container
+            cell_container.append(sub_node)
+            # set node inputs
+            if i == 0:
+                sub_node.set_inputs(first_node_inputs)
+            else:
+                sub_node.set_inputs([cell_container.node_list[i-1]])
+        return cell_container
+
+    def _process_external_function(self, stree, func_name):
+        """Process external function."""
+        for k, m in sys.modules.items():
+            if k in ("_ast", "ast"):
+                continue
+            if hasattr(m, func_name):
+                func = getattr(m, func_name)
+                source_code = inspect.getsource(func)
+                ast_root: ast.Module = ast.parse(source_code)
+                stree._external_func_ast.append(ast_root.body[0]) # pylint: disable=protected-access
+                return func, ast_root.body[0]
+            return None, None
+
+    def _process_internal_function(self, stree: SymbolTree, func_name):
+        """Process internal function."""
+        func = getattr(stree._origin_network, func_name) # pylint: disable=protected-access
+        ast_node = None
+        for body in stree._class_ast.body: # pylint: disable=protected-access
+            if isinstance(body, ast.FunctionDef) and func_name == body.name:
+                ast_node = body
+        return func, ast_node
+
+    def _create_func_subtree(self, op, targets, father_ast_node, ast_node, call_args, call_kwargs, func_name):
+        """Create subtree of function."""
+        stb = FunctionSymbolTreeBuilder(op, ast_node)
+        new_stree = stb.build()
+        return TreeNode.create_tree_node(new_stree, father_ast_node, targets, func_name, call_args, call_kwargs,
+                                         func_name, op)
+
     def _convert_ast_call_to_node(self, ast_node: ast.Call, father_ast_node: ast.Assign, stree: SymbolTree) -> Node:
         """
         Convert ast.Call to a symbol tree node.
@@ -340,9 +429,19 @@ class AssignParser(Parser):
                 func = get_functional(func_name.split(".")[-1])
                 node = stree.inner_create_call_function(func_name, father_ast_node, func_name, func, targets,
                                                         call_args, call_kwargs)
-                return node
-            raise RuntimeError(error_str(f"operator instance undefined.",
-                                         child_node=ast_node.func, father_node=ast_node))
+            elif hasattr(stree._origin_network, func_name): # pylint: disable=protected-access
+                func, ast_node = self._process_internal_function(stree, func_name)
+                node = self._create_func_subtree(func, targets, father_ast_node, ast_node, call_args, call_kwargs,
+                                                 func_name)
+            else:
+                func, ast_node = self._process_external_function(stree, func_name)
+                node = self._create_func_subtree(func, targets, father_ast_node, ast_node, call_args, call_kwargs,
+                                                 func_name)
+            return node
+        if isinstance(op, SequentialCell):
+            node = self._cell_container_process(father_ast_node, stree, targets, func, call_args, call_kwargs,
+                                                func_name, op)
+            return node
         if isinstance(op, Primitive):
             return Node.create_call_buildin_op(op, father_ast_node, targets, func, call_args, call_kwargs, func_name)
         if isinstance(op, Cell):
@@ -394,6 +493,74 @@ class AssignParser(Parser):
         raise RuntimeError("For MindSpore Rewrite, only support Primitive or Cell operator or Primitive operator, got ",
                            type(op).__name__)
 
+    @staticmethod
+    def _tuple_elts_support_scopledvalue(value: ast.Tuple) -> bool:
+        """ check whether each element's type in tuple is supported by scopled value. """
+        if not isinstance(value, ast.Tuple):
+            raise RuntimeError("For AssignParser._tuple_elts_support_scopledvalue(), the type of value should be "
+                               f"Tuple, but got {type(value).__name__}")
+
+        for elt in value.elts:
+            if not isinstance(elt, (ast.Name, ast.Attribute, ast.Tuple, ast.Constant, ast.Num, ast.Str, ast.Bytes)):
+                return False
+        return True
+
+    @staticmethod
+    def _convert_ast_mathops_to_node(ast_node: Union[ast.BinOp, ast.UnaryOp, ast.BoolOp, ast.Compare],
+                                     father_ast_node: ast.Assign) -> Node:
+        """
+        Convert ast node of math operations(ast.BinOp, ast.UnaryOp, ast.BoolOp, ast.Compare) to
+        a symbol tree node.
+
+        Args:
+            ast_node (Union[ast.BinOp, ast.UnaryOp, ast.BoolOp, ast.Compare]): An assign node with mathematival
+                operation in construct function.
+            father_ast_node (ast.Assign): Assign node in construct.
+
+        Returns:
+            An instance of Node in Symbol Tree.
+
+        Raises:
+            TypeError: The type of parameter 'ast_node' is not in (ast.BinOp, ast.UnaryOp, ast.BoolOp, ast.Compare).
+
+        """
+        if not isinstance(ast_node, (ast.BinOp, ast.UnaryOp, ast.BoolOp, ast.Compare)):
+            raise TypeError("The type of parameter 'ast_node' must be one of (ast.BinOp, ast.UnaryOp, "
+                            "ast.BoolOp, ast.Compare), but got ", type(ast_node))
+
+        targets = AssignParser._get_targets(AssignParser._create_scopedvalue(father_ast_node.targets[0]))
+        args = []
+        op_type_str = type(ast_node).__name__
+        op_type = ScopedValue.create_naming_value(op_type_str)
+        ops = {}
+        name = op_type_str
+        if isinstance(ast_node, ast.BinOp):
+            op = type(ast_node.op).__name__
+            name = f'{name}_{op}'
+            ops['0'] = ScopedValue.create_naming_value(op)
+            args.append(AssignParser._create_scopedvalue(ast_node.left))
+            args.append(AssignParser._create_scopedvalue(ast_node.right))
+        elif isinstance(ast_node, ast.UnaryOp):
+            op = type(ast_node.op).__name__
+            name = f'{name}_{op}'
+            ops['0'] = ScopedValue.create_naming_value(op)
+            args.append(AssignParser._create_scopedvalue(ast_node.operand))
+        elif isinstance(ast_node, ast.BoolOp):
+            op = type(ast_node.op).__name__
+            name = f'{name}_{op}'
+            ops['0'] = ScopedValue.create_naming_value(op)
+            for value in ast_node.values:
+                args.append(AssignParser._create_scopedvalue(value))
+        elif isinstance(ast_node, ast.Compare):
+            args.append(AssignParser._create_scopedvalue(ast_node.left))
+            for idx, ast_op in enumerate(ast_node.ops):
+                op = type(ast_op).__name__
+                name = f'{name}_{op}'
+                ops[str(idx)] = ScopedValue.create_naming_value(op)
+                args.append(AssignParser._create_scopedvalue(ast_node.comparators[idx]))
+        name = name.lower()
+        return Node.create_mathops_node(father_ast_node, targets, op_type, args, ops, name)
+
     def process(self, stree: SymbolTree, node: ast.Assign):
         """
         Parse ast.Assign and create a node in symbol tree.
@@ -413,52 +580,63 @@ class AssignParser(Parser):
         """
 
         targets = node.targets
-        if len(targets) != 1:
-            raise RuntimeError(
-                error_str(f"only support one target in assign now.", child_node=targets, father_node=node))
-        value = node.value
-        if isinstance(value, ast.Call):
-            node_ = self._convert_ast_call_to_node(value, node, stree)
-            stree.append_origin_field(node_)
-        elif isinstance(value, ast.BinOp):
-            if isinstance(value.op, ast.Add):
-                node_ = AssignParser._convert_ast_binop_to_node(value, node)
+        try:
+            if len(targets) != 1:
+                raise RuntimeError(
+                    error_str(f"only support one target in assign now.", child_node=targets, father_node=node))
+            value = node.value
+            if isinstance(value, ast.Call):
+                stree.update_scope_for_unique(value)
+                node_ = self._convert_ast_call_to_node(value, node, stree)
                 stree.append_origin_field(node_)
-            else:
+            elif isinstance(value, (ast.BinOp, ast.UnaryOp, ast.BoolOp, ast.Compare)):
+                node_ = AssignParser._convert_ast_mathops_to_node(value, node)
+                stree.append_origin_field(node_)
+            elif isinstance(value, ast.Subscript):
                 logger.info(f"ops-call({astunparse.unparse(node)}) in assign will be supported in near feature, "
                             f"ignored as a python node now")
                 stree.try_append_python_node(node, node)
-        elif isinstance(value, (ast.BoolOp, ast.Subscript)):
-            logger.info(f"ops-call({astunparse.unparse(node)}) in assign will be supported in near feature, "
-                        f"ignored as a python node now")
-            stree.try_append_python_node(node, node)
-        elif isinstance(value, (ast.Name, ast.Constant, ast.Attribute, ast.Num, ast.NameConstant, ast.Bytes, ast.Str)):
-            if isinstance(value, ast.Name):
-                node_name = "name_assign"
-            elif isinstance(value, ast.Constant):
-                node_name = "constant_assign"
+            elif isinstance(value, (ast.Name, ast.Constant, ast.Attribute, ast.Num, ast.NameConstant,
+                                    ast.Bytes, ast.Str)):
+                if isinstance(value, ast.Name):
+                    node_name = "name_assign"
+                elif isinstance(value, ast.Constant):
+                    node_name = "constant_assign"
+                elif isinstance(value, ast.Attribute):
+                    node_name = "attribute_assign"
+                    stree.update_scope_for_unique(value)
+                else:
+                    node_name = "other_assign"
+                targets = AssignParser._get_targets(AssignParser._create_scopedvalue(node.targets[0]))
+                call_args = [AssignParser._create_scopedvalue(value)]
+                node_ = Node.create_call_pass_through_method(node, targets, call_args, {}, node_name)
+                stree.append_origin_field(node_)
+            elif isinstance(value, ast.Tuple):
+                if AssignParser._tuple_elts_support_scopledvalue(value):
+                    # ensure that each element's type in tuple is supported by scopled value
+                    targets = AssignParser._get_targets(AssignParser._create_scopedvalue(node.targets[0]))
+                    args = []
+                    for elt in value.elts:
+                        args.append(AssignParser._create_scopedvalue(elt))
+                    node_ = Node.create_call_method(node, targets, ScopedValue.create_naming_value("tuple"),
+                                                    args, {}, "tuple")
+                    stree.append_origin_field(node_)
+                else:
+                    logger.warning(f"some elements in Tuple of assign({astunparse.unparse(node)}) are not supported "
+                                   "in rewrite, fallback to python")
+                    stree.try_append_python_node(node, node)
+            elif isinstance(value, (ast.List, ast.Dict)):
+                # add these as callmethod node if necessary
+                stree.try_append_python_node(node, node)
             else:
-                node_name = "attribute_assign"
-            targets = AssignParser._get_targets(AssignParser._create_scopedvalue(node.targets[0]))
-            call_args = [AssignParser._create_scopedvalue(value)]
-            node_ = Node.create_call_pass_through_method(node, targets, call_args, {}, node_name)
-            stree.append_origin_field(node_)
-        elif isinstance(value, ast.Tuple):
-            targets = AssignParser._get_targets(AssignParser._create_scopedvalue(node.targets[0]))
-            args = []
-            for elt in value.elts:
-                args.append(AssignParser._create_scopedvalue(elt))
-            node_ = Node.create_call_method(node, targets, ScopedValue.create_naming_value("tuple"), args, {}, "tuple")
-            stree.append_origin_field(node_)
-        elif isinstance(value, (ast.List, ast.Dict)):
-            # add these as callmethod node if necessary
+                raise RuntimeError(
+                    error_str(f"only support (ast.Call, ast.BinOp, ast.BoolOp, ast.Subscript, ast.Name, ast.Constant, "
+                              f"ast.Attribute, ast.Num, ast.NameConstant, ast.Bytes, ast.Str, ast.Tuple, ast.List, "
+                              f"ast.Dict) as value of ast.assign, but got ast type '{type(value).__name__}'",
+                              child_node=value, father_node=node))
+        except RuntimeError:
+            logger.info(f"ops-call({astunparse.unparse(node)}) not supported in rewrite, fallback to python")
             stree.try_append_python_node(node, node)
-        else:
-            raise RuntimeError(
-                error_str(f"only support (ast.Call, ast.BinOp, ast.BoolOp, ast.Subscript, ast.Name, ast.Constant, "
-                          f"ast.Attribute, ast.Num, ast.NameConstant, ast.Bytes, ast.Str, ast.Tuple, ast.List, ast.Dict"
-                          f") as value of ast.assign, but got ast type '{type(value).__name__}'", child_node=value,
-                          father_node=node))
 
 
 g_assign_parser = reg_parser(AssignParser())