mindspore 2.2.11__cp39-cp39-win_amd64.whl → 2.3.0__cp39-cp39-win_amd64.whl

mindspore/rewrite/ast_helpers/ast_creator.py

@@ -1,115 +0,0 @@
-# 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.
-# ============================================================================
-"""Create ast node in specific scope."""
-import ast
-from mindspore.rewrite.ast_creator_register import ast_creator_registry
-import mindspore as ms
-
-
-def ast_args_creator(args: list):
-    """Create an arg list."""
-    ast_args = list()
-    for arg in args:
-        ast_arg = ast_create_arg_value(arg)
-        ast_args.append(ast_arg)
-    return ast_args
-
-
-def ast_assign_creator(targets: ast.AST, value: ast.AST):
-    """Create an ast.Assign node."""
-    return ast.Assign(targets=targets, value=value, lineno=0, col_offset=0)
-
-
-def ast_attributer_creator(attribute: str):
-    """Create an ast.Attribute node"""
-    value, attr = attribute.rsplit(".", 1)
-    if "." in value:
-        ast_value = ast_attributer_creator(value)
-    else:
-        ast_value = ast_name_creator(value)
-    return ast.Attribute(value=ast_value, attr=attr, lineno=0, col_offset=0, ctx="Load()")
-
-
-def ast_call_creator(func: ast.AST, args: list, keywords: list):
-    """Create an ast.Call node"""
-    return ast.Call(func=func, args=args, keywords=keywords, lineno=0, col_offset=0)
-
-
-def ast_create_arg_value(value):
-    """Create arg node by type."""
-    if isinstance(value, (int, float)):
-        ast_value = ast_num_creator(value)
-    elif isinstance(value, str):
-        ast_value = ast_str_creator(value)
-    elif value in (ms.float16, ms.float32, ms.float64):
-        ast_value = ast_attributer_creator(".".join(["mindspore", str(value).lower()]))
-    elif isinstance(value, ms.rewrite.node.Node):
-        ast_value = ast_str_creator(value.get_targets()[0])
-    else:
-        raise TypeError("Unsupported arg type: ", type(value))
-    return ast_value
-
-
-def ast_index_creator(index: ast.Num):
-    """Create ast.Index node."""
-    index = ast_num_creator(index)
-    return ast.Index(value=index, lineno=0, col_offset=0)
-
-
-def ast_keyword_creator(arg: str, value):
-    """Create ast.keyword node."""
-    ast_value = ast_create_arg_value(value)
-    return ast.keyword(arg=arg, value=ast_value)
-
-
-def ast_kwargs_creator(kwargs: dict):
-    """Create ast.keyword node list."""
-    keywords = list()
-    for k, v in kwargs.items():
-        kw = ast_keyword_creator(k, v)
-        keywords.append(kw)
-    return keywords
-
-
-def ast_name_creator(id_: str):
-    """Create an ast.Name node."""
-    return ast.Name(id=id_, ctx=ast.Store, lineno=0, col_offset=0)
-
-
-def ast_num_creator(num: int):
-    """Create an ast.Num node."""
-    return ast.Num(n=num, lineno=0, col_offset=0)
-
-
-def ast_str_creator(s: str):
-    """Create an ast.str node."""
-    return ast.Str(s=s, lineno=0, col_offset=0)
-
-
-def ast_subscript_creator(value: ast.AST, index: int):
-    """Create an ast.Subscript node."""
-    s = ast_index_creator(index)
-    return ast.Subscript(value=value, slice=s, lineno=0, col_offset=0, ctx=ast.Load)
-
-
-ast_creator_registry.register("Args", ast_args_creator)
-ast_creator_registry.register("Assign", ast_assign_creator)
-ast_creator_registry.register("Attribute", ast_attributer_creator)
-ast_creator_registry.register("Call", ast_call_creator)
-ast_creator_registry.register("Index", ast_index_creator)
-ast_creator_registry.register("KwArgs", ast_kwargs_creator)
-ast_creator_registry.register("Name", ast_name_creator)
-ast_creator_registry.register("Num", ast_num_creator)
-ast_creator_registry.register("Subscript", ast_subscript_creator)

mindspore/rewrite/ast_transformers/flatten_recursive_stmt.py

@@ -1,267 +0,0 @@
-# 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.
-# ============================================================================
-"""Ast optimizer for flatten recursive call."""
-
-import sys
-from typing import Any, Tuple, List
-import keyword
-import ast
-
-from mindspore import log as logger
-from ..common import error_str
-
-if sys.version_info >= (3, 9):
-    import ast as astunparse # pylint: disable=reimported, ungrouped-imports
-else:
-    import astunparse
-
-FLATTEN_BLACK_LIST = ["set_vertex_attr",]
-
-class FlattenRecursiveStmt(ast.NodeTransformer):
-    """Ast optimizer for flatten recursive call."""
-
-    def __init__(self):
-        """
-        Constructor of FlattenRecursiveStmt.
-
-        Returns:
-            An instance of ast optimizer for flatten recursive call.
-        """
-        self._flatten_table: dict = {
-            ast.Return: ["value"],
-            ast.Call: ["args"],
-            ast.BinOp: ["left", "right"],
-            ast.BoolOp: ["values"],
-            ast.UnaryOp: ["operand"],
-            ast.Compare: ["left", "comparators"],
-            ast.If: ["test"]
-        }
-        self._transform_functions = []
-        self._transform_if = False
-        self._symbol_tree = None # Used to get unique name
-
-    @staticmethod
-    def _check_flatten_black_list(node: ast.AST):
-        """Check whether node in flatten black list"""
-        func_name = ""
-        # Get func name of node
-        if isinstance(node, ast.Call):
-            if isinstance(node.func, ast.Name):
-                func_name = node.func.id
-            elif isinstance(node.func, ast.Attribute):
-                func_name = node.func.attr
-        # Check func name of node
-        if func_name and func_name in FLATTEN_BLACK_LIST:
-            return True
-        return False
-
-    def _generate_target_name(self, node: ast.AST, target_names):
-        """Generate unique target name."""
-        if isinstance(node, ast.Call):
-            func = node.func
-            if isinstance(func, ast.Name):
-                target_name = func.id + "_var"
-            elif isinstance(func, ast.Attribute):
-                target_name = func.attr + "_var"
-            else:
-                logger.info("unhandled type of func of ast.Call while generating new target name: %s ", type(func))
-                target_name = "function"
-        elif isinstance(node, ast.Return):
-            target_name = "return_value"
-        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"
-        elif isinstance(node, ast.Name):
-            target_name = node.id
-        elif isinstance(node, ast.Attribute) and isinstance(node.value, ast.Name):
-            target_name = f"{node.value.id}_{node.attr}"
-        else:
-            logger.info("unhandled type of node while generating new target name: %s ", type(node))
-            target_name = type(node).__name__.lower() + "_var"
-        # avoid python keyword
-        if keyword.iskeyword(target_name):
-            target_name = target_name + "_var"
-        suffix = 0
-        result = target_name
-        while result in target_names:
-            suffix += 1
-            result = f"{target_name}_{suffix}"
-        if self._symbol_tree:
-            result = self._symbol_tree.unique_name(result)
-        target_names.append(result)
-        return result
-
-    def _create_new_assign_node(self, node: ast.AST, target_names) -> Tuple[str, ast.AST]:
-        """Create new assign node to be inserted into ast.FunctionDef."""
-        if isinstance(node, (ast.Name, ast.Constant, ast.Num, ast.Str, ast.NameConstant, ast.Bytes, ast.Ellipsis)):
-            return "", node
-        new_target_name = self._generate_target_name(node, target_names)
-        return new_target_name, ast.Assign(targets=[ast.Name(id=new_target_name, ctx=ast.Store())], value=node)
-
-    def _flatten_list(self, 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 = self._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."""
-        if FlattenRecursiveStmt._check_flatten_black_list(node):
-            return []
-        flatten_config = self._flatten_table.get(type(node))
-        if flatten_config is None:
-            return []
-        results = []
-        for todo_name in flatten_config:
-            todos = getattr(node, todo_name)
-            if isinstance(todos, list):
-                new_list = []
-                for todo in todos:
-                    # Starred expression(e.g. *args) cannot be flatten.
-                    if isinstance(todo, ast.Starred):
-                        new_list.append(todo)
-                        continue
-                    new_target_name, new_node = self._create_new_assign_node(todo, target_names)
-                    if id(new_node) == id(todo):
-                        new_list.append(todo)
-                    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 = self._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 = []
-                for key, value in todos:
-                    new_target_name, new_node = self._create_new_assign_node(value, target_names)
-                    if id(new_node) == id(value):
-                        new_dict[key] = value
-                    else:
-                        new_dict[key] = ast.Name(id=new_target_name, ctx=ast.Load())
-                        results.append(new_node)
-                setattr(node, todo_name, new_dict)
-            else:
-                new_target_name, new_node = self._create_new_assign_node(todos, target_names)
-                if id(new_node) != id(todos):
-                    setattr(node, todo_name, ast.Name(id=new_target_name, ctx=ast.Load()))
-                    results.append(new_node)
-        return results
-
-    def _save_target_names(self, target_names, ast_body: List[ast.AST]):
-        """Saving target names in ast_body before getting unique names."""
-        for child in ast_body:
-            if isinstance(child, (ast.Assign, ast.Expr)):
-                child_value = child.value
-            else:
-                child_value = child
-            if not self._flatten_table.get(type(child_value)):
-                continue
-
-            if not isinstance(child, ast.Assign):
-                continue
-            targets = child.targets
-            for target in targets:
-                if not isinstance(target, (ast.Name, ast.Tuple, ast.List)):
-                    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:
-                        target_names.append(target_name)
-                elif isinstance(target, (ast.Tuple, ast.List)):
-                    for elt in target.elts:
-                        if not isinstance(elt, ast.Name):
-                            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)
-
-    def _visit_ast_bodies(self, ast_body: List[ast.AST]):
-        """Traverse nodes in ast_body and flatten nodes recursive."""
-        target_names = []
-        self._save_target_names(target_names, ast_body)
-        index = len(ast_body) - 1
-        while index >= 0:
-            child = ast_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 not isinstance(child.body[0].value, (ast.Name, ast.Constant)):
-                        return_val_ast = child.body[0].value
-                        return_name = self._generate_target_name(return_val_ast, target_names)
-                        new_assign_code = f"{return_name} = {astunparse.unparse(return_val_ast)}"
-                        new_assign_ast = ast.parse(new_assign_code).body[0]
-                        new_return_ast = ast.parse(f"return {return_name}").body[0]
-                        child.body = [new_assign_ast, new_return_ast]
-                stmt = child
-            elif isinstance(child, ast.Expr):
-                stmt = child.value
-            else:
-                stmt = child
-            results = self._flatten_statement(stmt, target_names)
-            if results:
-                for result in reversed(results):
-                    ast_body.insert(index, result)
-                    index += 1
-            index -= 1
-
-    def visit_FunctionDef(self, node: ast.FunctionDef) -> Any: # pylint: disable=invalid-name
-        """Traverse nodes in _transform_functions and flatten recursive nodes."""
-        if node.name not in self._transform_functions:
-            return node
-        self._visit_ast_bodies(node.body)
-        return node
-
-    def visit_If(self, node: ast.If) -> Any: # pylint: disable=invalid-name
-        """Traverse nodes in if node and flatten recursive nodes."""
-        if not self._transform_if:
-            return node
-        self._visit_ast_bodies(node.body)
-        if node.orelse:
-            self._visit_ast_bodies(node.orelse)
-        return node
-
-    def transform(self, ast_root, transform_functions=None, stree=None):
-        """Interface of FlattenRecursiveStmt."""
-        self._transform_functions = transform_functions if transform_functions else ["construct"]
-        self._transform_if = False
-        self._symbol_tree = stree
-        ast_root = self.visit(ast_root)
-        ast_root = ast.fix_missing_locations(ast_root)
-        return ast_root
-
-    def transform_if(self, ast_if, stree=None):
-        """Interface of FlattenRecursiveStmt."""
-        self._transform_functions = []
-        self._transform_if = True
-        self._symbol_tree = stree
-        ast_if = self.visit(ast_if)
-        ast_if = ast.fix_missing_locations(ast_if)
-        return ast_if

mindspore/rewrite/ast_transformers/remove_return_out_of_if.py

@@ -1,228 +0,0 @@
-# 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.
-# ============================================================================
-"""Fold if return."""
-
-import ast
-import copy
-from typing import Any, Union
-from enum import Enum
-
-from ..common import error_str
-
-
-class ReturnType(Enum):
-    """
-    ValueType represents type of nodes.
-
-    - A `NotReturn` represents the node is not a return node.
-    - A `IfNotAllReturn` represents the node is an ast.If node and not all branches of it end with return.
-    - A `Return` represents the node is a return node or an ast.If node of which all branches of it end with return.
-    """
-    NotReturn = 0
-    IfNotAllReturn = 1
-    Return = 2
-
-
-class RemoveReturnOutOfIf(ast.NodeTransformer):
-    """
-    Ast optimizer for removing all returns out of if control flow.
-
-    Example one:
-        def func(x):
-            if x == 1:
-                return x - 1
-            x += 1
-            return x
-
-    will be optimized to
-        def func(x):
-            if x == 1:
-                output_0 = x - 1
-            else:
-                x += 1
-                output_0 = x
-            return output_0
-
-    Example two:
-        def func(x):
-            if x == 1:
-                x = 0
-            elif x == 2:
-                x = 4
-            else:
-                return x
-            x += 1
-            return x + 1
-
-    will be optimized to
-        def func(x):
-            if x == 1:
-                x = 0
-                x += 1
-                output_1 = x + 1
-            else:
-                if x == 2:
-                    x = 4
-                    x += 1
-                    output_0 = x + 1
-                else:
-                    output_0 = x
-                output_1 = output_0
-            return output_1
-    """
-
-    @staticmethod
-    def _last_node_is_return(node: Union[ast.Return, ast.If]) -> ReturnType:
-        """
-        Judge whether input node represents a return node.
-        Return a numeric value according to different cases:
-            0: Input node is not an ast.Return or input node is an ast.If of which all branches not end with ast.Return;
-            1: Input node is an ast.If and not all branches end with ast.Return;
-            2: Input node is an ast.Return or input node is an ast.If of which all branches end with ast.Return.
-        """
-        if not isinstance(node, ast.Return) and not isinstance(node, ast.If):
-            return ReturnType.NotReturn
-        if isinstance(node, ast.Return):  # last node is ast.Return
-            return ReturnType.Return
-        # all branches of ast.If not end with ast.Return
-        if node.body and RemoveReturnOutOfIf._last_node_is_return(node.body[-1]) == ReturnType.NotReturn \
-                and (not node.orelse or RemoveReturnOutOfIf._last_node_is_return(node.orelse[-1]) ==
-                     ReturnType.NotReturn):
-            return ReturnType.NotReturn
-        # all branches of ast.If end with ast.Return
-        if node.body and RemoveReturnOutOfIf._last_node_is_return(node.body[-1]) == ReturnType.Return \
-                and node.orelse and RemoveReturnOutOfIf._last_node_is_return(node.orelse[-1]) == ReturnType.Return:
-            return ReturnType.Return
-        # not all branches of ast.If end with ast.Return
-        return ReturnType.IfNotAllReturn
-
-    @staticmethod
-    def _fold_return(father_node: Union[ast.FunctionDef, ast.If], if_node: ast.If, if_index: int, attr: str):
-        """
-        Fold following nodes into if node when not all branches of ast.If end with ast.Return.
-
-        Args:
-            father_node (Union[ast.FunctionDef, ast.If]): Father node.
-            if_node (ast.If): A if node.
-            if_index (int): Index of the if node in body or or-else of father node.
-            attr (str): Attribute of father node, can be 'body' or 'orelse'.
-
-        Raises:
-            RuntimeError: Father node has not input attr.
-        """
-        if not hasattr(father_node, 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
-            if if_node.body and RemoveReturnOutOfIf._last_node_is_return(if_node.body[-1]) != ReturnType.Return:
-                for index in range(if_index + 1, len(father_node_attr)):
-                    node = copy.deepcopy(father_node_attr[index])
-                    if_node.body.append(node)
-            if not if_node.orelse or (if_node.orelse and RemoveReturnOutOfIf._last_node_is_return(if_node.orelse[-1])
-                                      != ReturnType.Return):
-                for index in range(if_index + 1, len(father_node_attr)):
-                    node = copy.deepcopy(father_node_attr[index])
-                    if_node.orelse.append(node)
-            # delete original nodes
-            remove_num = len(father_node_attr) - if_index - 1
-            for _ in range(remove_num):
-                father_node_attr.pop()
-
-    @staticmethod
-    def _fold(father_node: Union[ast.FunctionDef, ast.If], attr: str):
-        """Fold nodes. Iterate into body and orelse of if node."""
-        if not hasattr(father_node, attr) or not getattr(father_node, attr):
-            return
-
-        if isinstance(getattr(father_node, attr)[-1], ast.If):
-            RemoveReturnOutOfIf._fold(getattr(father_node, attr)[-1], 'body')  # if.body
-            RemoveReturnOutOfIf._fold(getattr(father_node, attr)[-1], 'orelse')  # if.orelse
-
-        cur_index = len(getattr(father_node, attr)) - 2  # no following nodes to fold when if node is the last one
-        while cur_index >= 0:
-            child = getattr(father_node, attr)[cur_index]
-            if isinstance(child, ast.If):
-                RemoveReturnOutOfIf._fold_return(father_node, child, cur_index, attr)
-                RemoveReturnOutOfIf._fold(child, 'body')  # if.body
-                RemoveReturnOutOfIf._fold(child, 'orelse')  # if.orelse
-            cur_index -= 1
-
-    @staticmethod
-    def _get_output_names(output_names: [str]):
-        """Generate unique output names."""
-        name: str = 'output_{}'.format(len(output_names))
-        output_names.append(name)
-        return name
-
-    @staticmethod
-    def _move_out_return(output_names: [str], father_node: Union[ast.FunctionDef, ast.If], attr: str):
-        """
-        Move all return node out of if nodes.
-        Replace all original return nodes in ast.If with ast.Assign nodes which represent 'output = return value'.
-        And add new ast.Return node to the end of father node.
-
-        Args:
-            output_names ([str]): All unique output names.
-            father_node (Union[ast.FunctionDef, ast.If]): Father node.
-            attr (str): Attribute of father nodes, can be 'body' or 'orelse'.
-
-        Raises:
-            RuntimeError: After iterative processing body and orelse of if nodes not all end with ast.Return.
-        """
-        if not hasattr(father_node, attr) or not getattr(father_node, attr):
-            return
-
-        last_node = getattr(father_node, attr)[-1]
-        if isinstance(last_node, ast.If) and RemoveReturnOutOfIf._last_node_is_return(last_node) == ReturnType.Return:
-            # the body or orelse of last if node should be ast.Return or ast.If
-            if isinstance(last_node.body[-1], ast.If):
-                RemoveReturnOutOfIf._move_out_return(output_names, last_node, 'body')
-            if isinstance(last_node.orelse[-1], ast.If):
-                RemoveReturnOutOfIf._move_out_return(output_names, last_node, 'orelse')
-
-            # 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(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(
-                targets=[ast.Name(id=output_name, ctx=ast.Store())], value=last_node.body[-1].value)
-            last_node.body.pop()
-            last_node.body.append(body_new_last_node)
-            # replace else return
-            else_new_last_node = ast.Assign(
-                targets=[ast.Name(id=output_name, ctx=ast.Store())], value=last_node.orelse[-1].value)
-            last_node.orelse.pop()
-            last_node.orelse.append(else_new_last_node)
-            # add new return node
-            new_return_node = ast.Return(value=ast.Name(id=output_name, cts=ast.Store()))
-            getattr(father_node, attr).append(new_return_node)
-
-    def visit_FunctionDef(self, node: ast.FunctionDef) -> Any:
-        """Iterate construct node and fold following nodes into if node when condition is met."""
-        if node.name != "construct":
-            return node
-        RemoveReturnOutOfIf._fold(node, 'body')
-        output_names = []
-        RemoveReturnOutOfIf._move_out_return(output_names, node, 'body')
-        return node
-
-    def transform(self, ast_root):
-        """Transform."""
-        ast_root = self.visit(ast_root)
-        ast_root = ast.fix_missing_locations(ast_root)
-        return ast_root

mindspore/rewrite/namespace.py

@@ -1,53 +0,0 @@
-# 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.
-# ============================================================================
-"""Define the namespace of MindSpore op definition."""
-from .._extends.parse.namespace import CellNamespace
-
-
-_ms_common_ns = CellNamespace('mindspore.common')
-_ms_nn_ns = CellNamespace('mindspore.nn')
-_ms_ops_ns = CellNamespace('mindspore.ops.operations')
-_ms_functional_ns = CellNamespace('mindspore.ops.functional')
-
-# Elements in _subtree_black_list will not be converted to symbol tree.
-# Only str and types are stored in _subtree_black_list.
-_subtree_black_list = ["QuantizeWrapperCell",]
-
-def is_subtree(cls_inst):
-    """Determine whether 'cls_inst' is a subtree."""
-    cls_name = type(cls_inst).__name__
-    black_list_types = tuple([elem for elem in _subtree_black_list if not isinstance(elem, str)])
-    if cls_name in _subtree_black_list or isinstance(cls_inst, black_list_types):
-        return False
-    if cls_name in _ms_common_ns and isinstance(cls_inst, _ms_common_ns[cls_name]):
-        return False
-    if cls_name in _ms_nn_ns and isinstance(cls_inst, _ms_nn_ns[cls_name]):
-        return False
-    if cls_name in _ms_ops_ns and isinstance(cls_inst, _ms_ops_ns[cls_name]):
-        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