mindspore 1.10.0__cp37-none-any.whl → 2.0.0rc1__cp37-none-any.whl

mindspore/rewrite/parsers/assign_parser.py

@@ -13,25 +13,28 @@
 # limitations under the License.
 # ============================================================================
 """Parse ast.Assign in construct function to node of SymbolTree."""
-from __future__ import absolute_import
 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 ..symbol_tree import SymbolTree
-from ..node import Node, TreeNode
-from ..parser import Parser
-from ..parser_register import reg_parser
-from ..api.scoped_value import ScopedValue, ValueType
-from ..symbol_tree_builder import SymbolTreeBuilder
-from ..ast_helpers import AstReplacer, AstModifier
-from ..common.event import Event
-from ..namespace import is_subtree
+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, 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, FunctionSymbolTreeBuilder
+from mindspore.rewrite.ast_helpers import AstReplacer, AstModifier
+from mindspore.rewrite.common.event import Event
+from ..common import error_str
 
 
 class AssignParser(Parser):
@@ -64,12 +67,16 @@ class AssignParser(Parser):
         tuple_elts = node.elts
         tuple_values = []
         for tuple_elt in tuple_elts:
-            if not isinstance(tuple_elt, (ast.Constant, ast.Name)):
-                raise RuntimeError("Only support ast.Constant or ast.Name as elts of ast.Tuple.")
+            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)
             if isinstance(tuple_elt, ast.Constant):
                 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
@@ -92,7 +99,9 @@ class AssignParser(Parser):
         if isinstance(node, ast.Attribute):
             scope = node.value
             if not isinstance(scope, ast.Name):
-                raise RuntimeError("value of target of ast.Assign should be a ast.Name when target is a ast.Attribute.")
+                raise RuntimeError(error_str(f"value of target of ast.Assign should be a ast.Name when target is a "
+                                             f"ast.Attribute, but got ast type '{type(scope).__name__}'",
+                                             child_node=scope, father_node=node))
             return ScopedValue.create_naming_value(node.attr, scope.id)
         if isinstance(node, ast.Tuple):
             return AssignParser._create_scopedvalue_from_tuple_ast(node)
@@ -102,7 +111,9 @@ class AssignParser(Parser):
             return ScopedValue.create_variable_value(node.n)
         if isinstance(node, (ast.Str, ast.Bytes)):
             return ScopedValue.create_variable_value(node.s)
-        raise RuntimeError("Unsupported ast type to argument:", node)
+        raise RuntimeError(error_str(f"only support (ast.Name, ast.Attribute, ast.Tuple, ast.Constant, ast.Num"
+                                     f"ast.Str, ast.Bytes to argument), but got ast type '{type(node).__name__}'",
+                                     father_node=node))
 
     @staticmethod
     def _get_func_name(ast_node: ast.Call) -> str:
@@ -125,7 +136,8 @@ class AssignParser(Parser):
             return func.attr
         if isinstance(func, ast.Call):
             return AssignParser._get_func_name(func)
-        raise RuntimeError("FuncValue is should be Name or a Attribute or a Call:", astunparse.unparse(func))
+        raise RuntimeError(error_str(f"funcValue should be Name or a Attribute or a Call, but got ast type "
+                                     f"'{type(func).__name__}'", child_node=func, father_node=ast_node))
 
     @staticmethod
     def _get_func_scope(ast_node: ast.Call) -> str:
@@ -146,13 +158,13 @@ class AssignParser(Parser):
         if isinstance(func, ast.Name):
             return ""
         if isinstance(func, ast.Attribute):
-            value = func.value
-            if not isinstance(value, ast.Name):
-                raise RuntimeError("FuncValue is should be Name:", ast.dump(func))
-            return value.id
+            parser = ParserRegister.instance().get_parser(type(func))
+            value = parser.process(None, func)
+            return value.rsplit(".", 1)[0]
         if isinstance(func, ast.Call):
             return AssignParser._get_func_scope(func)
-        raise RuntimeError("FuncValue should be Name or a Attribute or a Call:", ast.dump(func))
+        raise RuntimeError(error_str(f"funcValue should be Name or a Attribute or a Call, but got ast type "
+                                     f"'{type(func).__name__}'", child_node=func, father_node=ast_node))
 
     @staticmethod
     def _get_symbol_object(symbol_name, origin_net):
@@ -226,7 +238,8 @@ class AssignParser(Parser):
         if all_targets.type == ValueType.TupleValue:
             for single_target in all_targets.value:
                 if not isinstance(single_target, ScopedValue) and not isinstance(single_target.value, str):
-                    raise RuntimeError("Only support str target in tuple.")
+                    raise RuntimeError(f"For MindSpore Rewrite, only support str target in tuple, but got type "
+                                       f"{type(single_target).__name__}")
                 targets.append(single_target)
         else:
             targets.append(all_targets)
@@ -270,17 +283,17 @@ class AssignParser(Parser):
             if not isinstance(body, ast.Assign):
                 continue
             if len(body.targets) > 1:
-                raise NotImplementedError("Not support multi-targets in assign now!")
+                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
@@ -299,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.
@@ -325,8 +423,25 @@ class AssignParser(Parser):
 
         _, op = AssignParser._find_op_and_type(func_scope, func_name, stree)
         if op is None:
-            raise RuntimeError("Operator instance undefined: '", astunparse.unparse(ast_node.func), "' of '",
-                               astunparse.unparse(ast_node), "'")
+            if is_functional(func_name):
+                parser = ParserRegister.instance().get_parser(type(ast_node.func))
+                func_name = parser.process(stree, ast_node.func)
+                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)
+            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):
@@ -375,7 +490,76 @@ class AssignParser(Parser):
                 return TreeNode.create_tree_node(new_stree, father_ast_node, targets, func, call_args, call_kwargs,
                                                  func_name, new_stree.get_origin_network())
             return Node.create_call_buildin_op(op, father_ast_node, targets, func, call_args, call_kwargs, func_name)
-        raise RuntimeError("Only support Cell operator or Primitive operator, got ", type(op).__name__)
+        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):
         """
@@ -396,47 +580,63 @@ class AssignParser(Parser):
         """
 
         targets = node.targets
-        if len(targets) != 1:
-            raise RuntimeError("Only support one target in assign now")
-        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(f"Unsupported statement({astunparse.unparse(node)}) in construct function!")
 
 
 g_assign_parser = reg_parser(AssignParser())

mindspore/rewrite/parsers/attribute_parser.py

@@ -0,0 +1,56 @@
+# 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.
+# ============================================================================
+"""Parse ast.Assign in construct function to node of SymbolTree."""
+import ast
+
+from mindspore.rewrite.parser import Parser
+from mindspore.rewrite.symbol_tree import SymbolTree
+from mindspore.rewrite.parser_register import ParserRegister
+
+from mindspore.rewrite.parser_register import reg_parser
+from ..common import error_str
+
+
+class AttributeParser(Parser):
+    """Parse ast.Attribute in construct function to node of SymbolTree."""
+
+    def target(self):
+        """Parse target type."""
+        return ast.Attribute
+
+    def process(self, stree: SymbolTree, node: ast.Attribute):
+        """
+        Parse ast.Attribute node.
+
+        Args:
+            stree ([SymbolTree]): Symbol Tree under parsing.
+            node ([ast.Attribute]): An ast.Attribute node.
+
+        Returns:
+            The value of node.
+
+        Raises:
+            TypeError: Attribute parser only supports parsing ast.Attribute type nodes.
+        """
+        if not isinstance(node, ast.Attribute):
+            raise TypeError(error_str(f"Attribute parser only supports parsing ast.Attribute type nodes, but got "
+                                      f"'{type(node).__name__}'", father_node=node))
+        parser = ParserRegister.instance().get_parser(type(node.value))
+        value = parser.process(stree, node.value)
+
+        return ".".join([value, node.attr])
+
+
+g_attribute_parser = reg_parser(AttributeParser())