mindspore 2.6.0rc1__cp310-cp310-macosx_11_0_arm64.whl → 2.7.0rc1__cp310-cp310-macosx_11_0_arm64.whl

mindspore/.commit_id

@@ -1 +1 @@
-__commit_id__ = ''[sha1]:7f763125,[branch]:(HEAD,origin/r2.6,r2.6)''
+__commit_id__ = ''[sha1]:e69e001d,[branch]:(HEAD,origin/r2.7.rc1,r2.7.rc1)''

mindspore/__init__.py

@@ -16,7 +16,7 @@
 from __future__ import absolute_import
 
 from mindspore.run_check import run_check
-from mindspore import common, dataset, mindrecord, train, log, amp
+from mindspore import common, dataset, mindrecord, train, log, amp, device_manager
 from mindspore import profiler, communication, numpy, parallel, hal, runtime, device_context
 from mindspore.common import *
 from mindspore.common import _tensor_docs

mindspore/_checkparam.py

@@ -118,20 +118,21 @@ def _format_str_two_value(val1, val2, rel):
 
 
 def _check_3d_int_or_tuple(arg_name, arg_value, prim_name, allow_five=False, ret_five=False,
-                           greater_zero=True, third_one=False, three_input=False):
+                           greater_zero=True, third_one=False, three_input=False, pad_value=1):
     """
     Checks whether an argument is a positive int or tuple with 3 or 5(when allow_five is True) positive int elements.
     """
 
-    def _raise_message(third_one_flag=False, three_input_flag=False):
+    def _raise_message(third_one_flag=False, three_input_flag=False, ret_value=None):
+        ret_value = arg_value if ret_value is None else ret_value
         if third_one_flag:
             raise ValueError(f"For '{prim_name}', the depth of parameter '{arg_name}' must be 1, " \
                              f"but got {ret_value[-3]}.")
         if three_input_flag:
             raise ValueError(f"For '{prim_name}', the parameter '{arg_name}' must be an positive integer " \
-                             f"or a tuple of three positive integer, but got {arg_value}.")
+                             f"or a tuple of three positive integer, but got {ret_value}.")
         raise ValueError(f"For '{prim_name}', the parameter '{arg_name}' must be an positive integer or " \
-                         f"a tuple of three {'or five ' if allow_five else ''}positive integer, but got {arg_value}")
+                         f"a tuple of three {'or five ' if allow_five else ''}positive integer, but got {ret_value}")
 
     def _get_return_value():
         def _check():
@@ -144,9 +145,10 @@ def _check_3d_int_or_tuple(arg_name, arg_value, prim_name, allow_five=False, ret
 
         _check()
         if isinstance(arg_value, int):
-            ret = (1, 1, arg_value, arg_value, arg_value) if ret_five else (arg_value, arg_value, arg_value)
+            ret = (pad_value, pad_value, arg_value, arg_value, arg_value) \
+                if ret_five else (arg_value, arg_value, arg_value)
         elif len(arg_value) == 3:
-            ret = (1, 1, arg_value[0], arg_value[1], arg_value[2]) if ret_five else arg_value
+            ret = (pad_value, pad_value, arg_value[0], arg_value[1], arg_value[2]) if ret_five else arg_value
         else:  # case: len(arg_value) == 5
             ret = arg_value if ret_five else (arg_value[2], arg_value[3], arg_value[4])
 
@@ -159,12 +161,12 @@ def _check_3d_int_or_tuple(arg_name, arg_value, prim_name, allow_five=False, ret
                     continue
                 if not greater_zero and item >= 0:
                     continue
-            _raise_message()
+            _raise_message(ret_value=ret_value)
 
     def _check_third_one(ret_value):
         if third_one:
             if ret_value[-3] != 1:
-                _raise_message(third_one_flag=third_one)
+                _raise_message(third_one_flag=third_one, ret_value=ret_value)
 
     check_value_type(arg_name, arg_value, (int, tuple), prim_name)
     if three_input and isinstance(arg_value, tuple):
@@ -1288,6 +1290,33 @@ def _expand_tuple(n_dimensions):
     return convert
 
 
+def _check_int_sequence_len(sequence, valid_len):
+    if not len(sequence) is valid_len:
+        raise TypeError(f"When expanding an sequence to tuple, input sequence dimension must be {valid_len}, " \
+                        f"but got {sequence}")
+    for i in sequence:
+        if not isinstance(i, int) or isinstance(i, bool):
+            raise TypeError(f"When expanding an sequence to tuple, " \
+                            f"the type of element in input sequence must be an integer, but got {type(i)}.")
+
+
+def _expand_sequence_to_tuple(n_dimensions):
+    """To expand an int number to tuple."""
+
+    def convert(m):
+        if not isinstance(m, (tuple, list)):
+            if isinstance(m, int) and not isinstance(m, bool):
+                return tuple(repeat(m, n_dimensions))
+            raise TypeError(f"When expanding an input to tuple, input type must be integer or tuple[int]/list[int], " \
+                            f"but got {type(m)}")
+        _check_int_sequence_len(m, n_dimensions)
+        if isinstance(m, list):
+            return tuple(m)
+        return m
+
+    return convert
+
+
 def _check_data_type_valid(data, valid_type):
     """Check data type valid."""
     if valid_type is None:
@@ -1342,7 +1371,9 @@ def check_output_data(data):
 once = _expand_tuple(1)
 twice = _expand_tuple(2)
 triple = _expand_tuple(3)
-
+once_sequence = _expand_sequence_to_tuple(1)
+twice_sequence = _expand_sequence_to_tuple(2)
+triple_sequence = _expand_sequence_to_tuple(3)
 
 def args_type_check(*type_args, **type_kwargs):
     """Check whether input data type is correct."""

mindspore/{_deprecated → _extends/optimize}/__init__.py

@@ -1,4 +1,4 @@
-# Copyright 2024 Huawei Technologies Co., Ltd
+# Copyright 2025 Huawei Technologies Co., Ltd
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -12,6 +12,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ============================================================================
-"""Store the deprecated api temporarily."""
+"""
+Interfaces for optimize module.
+"""
+
 from __future__ import absolute_import
-from mindspore._deprecated.jit import jit
+
+__all__ = ['set_lazy_inline']
+
+from .cell_utils import set_lazy_inline

mindspore/_extends/optimize/cell_utils.py

@@ -0,0 +1,96 @@
+# Copyright 2025 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.
+# ============================================================================
+"""
+Interfaces for optimize module.
+"""
+
+from mindspore import log as logging
+from mindspore.nn import Cell
+
+
+def process_cell_init_args(cells, reusing_count, allow_list, denny_list):
+    """
+    process all the cells to use lazy inline with the conditions..
+
+    Args:
+        cells(Object map): All the cells information.
+        reusing_count(int): The count of the same key of the cell instance.
+        allow_list:(list):  The allow list of the cell class to apply lazy inline
+        denny_list:(list):  The denny list of the cell class to apply lazy inline
+    Returns:
+        void
+    """
+    type_instance = {}
+    class_name = {}
+
+    for k in cells.keyrefs():
+        v = cells[k]
+        if k.construct.__code__.co_filename.find("mindspore/nn") != -1:
+            continue
+        if denny_list and any(deny in k.cls_name for deny in denny_list):
+            continue
+        if allow_list and not any(allow in k.cls_name for allow in allow_list):
+            continue
+
+        pickle_args = k.cls_name + str(id(k.__class__)) + "[" + str(v[1]) + ":kws:" + str(v[2]) + "]"
+
+        instances = type_instance.get(pickle_args)
+        if instances is not None:
+            instances.append(k)
+            if len(instances) > reusing_count:
+                if not hasattr(k, "cell_init_args"):
+                    setattr(k, "cell_init_args", "lazy_inline_" + pickle_args)
+                    logging.debug("Reusing cell info: %s , id: %s , args: %s",
+                                  k.construct.__code__.co_filename + "/" + k.cls_name, id(k), pickle_args)
+                    setattr(k, "no_inline", False)
+            elif len(instances) == reusing_count:
+                class_name[v[0]] = k.construct.__code__.co_filename + "/" + k.cls_name
+                logging.info("Reusing Cell: %s , args: %s", k.construct.__code__.co_filename + "/" + k.cls_name,
+                             pickle_args)
+
+                for i in instances:
+                    if not hasattr(i, "cell_init_args"):
+                        setattr(i, "cell_init_args", "lazy_inline_" + pickle_args)
+                        logging.debug("Reusing cell info: %s , id: %s , args: %s",
+                                      i.construct.__code__.co_filename + "/" + i.cls_name, id(i), pickle_args)
+                        setattr(i, "no_inline", False)
+        else:
+            type_instance[pickle_args] = [k]
+
+    return class_name
+
+
+def set_lazy_inline(reusing_count=3, allow_list=None, denny_list=None):
+    """
+    Apply all the cells to use lazy inline with the conditions.
+
+    Args:
+        cells(Object map): All the cells information.
+        reusing_count(int): The count of the same key of the cell instance.
+        allow_list:(list):  The allow list of the cell class to apply lazy inline
+        denny_list:(list):  The denny list of the cell class to apply lazy inline
+    Returns:
+        void
+    """
+    cells = Cell.global_cells
+    if denny_list is None:
+        denny_list = []
+    if allow_list is None:
+        allow_list = []
+
+    denny_list.append("_Output")
+    denny_list.append("_MicroBatch")
+    reusing_cells = process_cell_init_args(cells, reusing_count, allow_list, denny_list)
+    return reusing_cells

mindspore/_extends/parse/__init__.py

@@ -30,7 +30,7 @@ from .parser import (Parser, create_instance, is_supported_create_instance_type,
                      get_obj_defined_from_obj_type, is_from_third_party_library, get_const_abs, get_const_round,
                      get_const_len, convert_to_namedtuple, check_attrs, generate_lambda_object,
                      check_is_subclass, check_attr_is_property, get_method_info, can_constant_fold,
-                     convert_to_mutable)
+                     convert_to_mutable, get_ast_augassign_namespace_symbol)
 
 __all__ = ['Parser', 'create_instance', 'is_supported_create_instance_type', 'generate_scope', 'get_attr_from_object',
            'get_bprop_method_of_class', 'get_class_instance_type', 'get_class_member_namespace_symbol',
@@ -45,4 +45,4 @@ __all__ = ['Parser', 'create_instance', 'is_supported_create_instance_type', 'ge
            'is_class_member_recursive', 'get_obj_defined_from_obj_type',
            'is_from_third_party_library', 'get_const_abs', 'get_const_round', 'get_const_len', 'get_method_info',
            'convert_to_namedtuple', 'check_attrs', 'generate_lambda_object', 'check_is_subclass', 'check_attr_is_property',
-           'can_constant_fold', 'convert_to_mutable']
+           'can_constant_fold', 'convert_to_mutable', 'get_ast_augassign_namespace_symbol']

mindspore/_extends/parse/compile_config.py

@@ -1,4 +1,4 @@
-# Copyright 2024 Huawei Technologies Co., Ltd
+# Copyright 2024-2025 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.
@@ -275,16 +275,6 @@ Value Range:
 """
 STRICT_CHECK_PARENT_CONTEXT = ''
 
-"""
-Name: CELL_PARAMETER_HOOK
-Function: Whether to enable cell parameter hook.
-          Cell parameter hook is an experimental api that may be deleted later.
-Value Range:
-    1: Enable
-    Default: Disable
-"""
-CELL_PARAMETERS_HOOK = ''
-
 """
 Name: CHECK_BPROP
 Function: Whether to check back propagation nodes. The checking ensures that the shape and dtype of
@@ -315,15 +305,6 @@ Value Range:
 """
 DEBUG_LEVEL = ''
 
-"""
-Name: PYNATIVE_JIT_GRAD_MODE
-Function: Which method used for grad jit in pynative mode
-Value Range:
-    1: Replace ValueNode
-    Default: Parametrization
-"""
-PYNATIVE_JIT_GRAD_MODE = ''
-
 """
 Name: PIJIT_SUBGRAPH_BREAK_OPTIMIZE
 Function: Whether to enable subgraph break optimization in PIJit.
@@ -333,6 +314,15 @@ Value Range:
 """
 PIJIT_SUBGRAPH_BREAK_OPTIMIZE = ''
 
+"""
+Name: ENABLE_ELIMINATE_UNUSED_PARAMS
+Function: Whether to enable eliminate unused parameters optimization in PIJit.
+Value Range:
+    1: Enable, Disable if other value.
+    Default: Disable.
+"""
+ENABLE_ELIMINATE_UNUSED_PARAMS = ''
+
 """
 Name: PUT_ALL_CNODE_INTO_ORDER_LIST
 Function: Whether to put all CNode into order list in back prop.
@@ -342,6 +332,36 @@ Value Range:
 """
 PUT_ALL_CNODE_INTO_ORDER_LIST = ''
 
+"""
+Name: CHECK_PASS_NODE_SCOPE
+Function: Whether to check
+Value Range:
+    1: Enable
+    Default: Disable.
+"""
+CHECK_PASS_NODE_SCOPE = ''
+
+"""
+Name: CHECK_INVALID_VIEW_INPLACE_DOUT_LEVEL
+Function: The level of check invalid dout under view+inplace scene
+Value Range:
+    1: Only check scenario 1
+    2: Only check scenario 2
+    Default(""): Check all invalid dout for view inplace scene
+    Others: No invalid dout check for view inplace scene
+"""
+CHECK_INVALID_VIEW_INPLACE_DOUT_LEVEL = ''
+
+"""
+Name: JIT_ENABLE_AUGASSIGN_INPLACE
+Function: Whether enable augassign inplace.
+Value Range:
+    0: Disable
+    1: Enable
+    Default: Disable
+"""
+JIT_ENABLE_AUGASSIGN_INPLACE = '0'
+
 __all__ = [
     "COMPILE_PROFILE",
     "COMPILE_PROFILE_FINISH_ACTION",
@@ -372,11 +392,13 @@ __all__ = [
     "ENABLE_RECOMPUTE_BEFORE_INLINE",
     "STRICT_CHECK_PARENT_CONTEXT",
     "AUTO_PASSES_OPTIMIZE_PATH",
-    "CELL_PARAMETERS_HOOK",
     "CHECK_BPROP",
     "GRAD_FOR_SCALAR",
     "DEBUG_LEVEL",
-    "PYNATIVE_JIT_GRAD_MODE",
     "PIJIT_SUBGRAPH_BREAK_OPTIMIZE",
+    "ENABLE_ELIMINATE_UNUSED_PARAMS",
     "PUT_ALL_CNODE_INTO_ORDER_LIST",
+    "CHECK_PASS_NODE_SCOPE",
+    "CHECK_INVALID_VIEW_INPLACE_DOUT_LEVEL",
+    "JIT_ENABLE_AUGASSIGN_INPLACE"
 ]

mindspore/_extends/parse/deprecated/deprecated_tensor_method.py

@@ -33,7 +33,7 @@ deprecated_tensor_method_map = {
     # 7 allclose
     "allclose": "tensor_allclose",
     # 8 any
-    "any": "tensor_any",
+    "any": "reduce_tensor_any",
     # 9 arctan2
     "arctan2": "tensor_arctan2",
     # 10 argmax

mindspore/_extends/parse/parser.py

@@ -42,9 +42,9 @@ from mindspore.common.api import _JitExecutor
 from mindspore.common import dtype as mstype
 from mindspore.common.parameter import Parameter
 from mindspore.common import mutable
-from mindspore._checkparam import is_stub_tensor
 from .namespace import Namespace, ModuleNamespace, ClosureNamespace, ClassMemberNamespace
-from .resources import parse_object_map, ops_symbol_map, convert_object_map, convert_class_to_function_map, trope_ns
+from .resources import (parse_object_map, parse_augassign_object_map, ops_symbol_map, convert_object_map,
+                        convert_class_to_function_map, trope_ns)
 from .resources import SYMBOL_UNDEFINE, constant_fold_functions
 from .jit_fallback_modules.check_utils import third_party_checker
 from ...common.api import _convert_python_data
@@ -264,7 +264,7 @@ def resolve_symbol(namespace, symbol):
     if isinstance(resolve_, _JitExecutor):
         logger.debug("Resolve class _JitExecutor, resolve fn instead.")
         resolve_ = resolve_.fn
-    logger.debug(f"Found '{symbol}' in {namespace.__str__()}, resolved: {resolve_} / {type(resolve_)}")
+    logger.debug("Found '%s' in %s, resolved: %s / %s", symbol, namespace, resolve_, type(resolve_))
     return resolve_
 
 
@@ -667,6 +667,14 @@ def get_ast_namespace_symbol(obj):
     return ops_info
 
 
+def get_ast_augassign_namespace_symbol(obj):
+    """Get obj type and namespace and symbol."""
+    # Get symbol from object map.
+    ops_info = parse_augassign_object_map.get(type(obj), SYMBOL_UNDEFINE)
+    logger.debug("ops info: %r", ops_info)
+    return ops_info
+
+
 def get_operation_symbol(obj):
     """Get obj operation symbol."""
     ops_symbol = ops_symbol_map.get(type(obj), SYMBOL_UNDEFINE)
@@ -680,6 +688,7 @@ def get_operation_namespace_symbol(var: str):
     logger.debug("get operation ops info: %r", ops_info)
     return ops_info
 
+
 def get_ast_type(node):
     """Get the ast type."""
     ast_type = AST_SUB_TYPE_UNKNOWN
@@ -784,32 +793,6 @@ def get_arg_spec_and_default_values(func):
     return arg_spec, defaults
 
 
-def _convert_stub_tensor(data):
-    """Convert stub tensor output to tensor"""
-    if is_stub_tensor(data):
-        return data.stub_sync()
-    if isinstance(data, tuple):
-        # Handle namedtuple since its type is tuple.
-        if hasattr(data, "_fields"):
-            type_name = data.__class__.__name__
-            data_dict = data._asdict()
-            fields = data_dict.keys()
-            return namedtuple(type_name, fields)(**_convert_stub_tensor(data_dict))
-        return tuple(_convert_stub_tensor(x) for x in data)
-    if data.__class__ is list:
-        # Keep the list object not change.
-        for i in range(len(data)):
-            data[i] = _convert_stub_tensor(data[i])
-        return data
-    if data.__class__ is dict:
-        # Keep the dict object not change.
-        keys = tuple(data.keys())
-        for key in keys:
-            data[_convert_stub_tensor(key)] = _convert_stub_tensor(data.pop(key))
-        return data
-    return data
-
-
 def eval_script(exp_str, params):
     """Evaluate a python expression."""
     if not isinstance(params, tuple):
@@ -823,7 +806,6 @@ def eval_script(exp_str, params):
     try:
         local_params = _convert_python_data(local_params)
         res = eval(exp_str, global_params, local_params)
-        res = _convert_stub_tensor(res)
     except Exception as e:
         error_info = f"When eval '{exp_str}' by using JIT Fallback feature, an error occurred: " + str(e)
         logger.debug(error_info)
@@ -852,7 +834,7 @@ def get_script_id_attrs(script):
 
 def generate_lambda_object(script):
     """Generate lambda expression object using script"""
-    return eval(script, {}, {})
+    return eval_script(script, ({}, {}))
 
 
 def get_global_params():
@@ -924,20 +906,6 @@ def get_method_info(obj):
     return class_name_and_method_name[0], class_name_and_method_name[1]
 
 
-def is_ms_tensor_method(obj):
-    """Check if the obj is a method of MindSpore Tensor"""
-    if not hasattr(obj, '__name__') or not hasattr(Tensor, obj.__name__):
-        return False
-    fn = inspect.unwrap(obj.__func__ if isinstance(obj, types.MethodType) else obj)
-    tensor_method = getattr(Tensor, obj.__name__)
-    tensor_method = tensor_method.__func__ if hasattr(tensor_method, "__func__") else tensor_method
-    is_builtin_tensor = False
-    if inspect.isbuiltin(obj):
-        class_name_and_method_name = obj.__qualname__.split('.')
-        is_builtin_tensor = obj.__module__ is None and class_name_and_method_name[0] == Tensor.__name__
-    return fn == tensor_method or is_builtin_tensor
-
-
 def can_constant_fold(obj):
     """Check if the obj is the function can be constantly folded."""
     return obj in constant_fold_functions
@@ -1037,31 +1005,38 @@ class Parser:
                              "the code 'def __init__(self, combine_fn=lambda x: x + 1):' rewritten as\n"
                              "'def __init__(self, combine_fn=\nlambda x: x + 1\n):' will solve the problem.")
 
+    def save_source_code(self, attr_name, source_lines):
+        """Save cell and func source code to support run graph mode with pyc or so."""
+        if '/mindspore/' in self.filename or '\\mindspore\\' in self.filename:
+            return
+        if getattr(self.fn, attr_name, None) == source_lines:
+            return
+        if not os.access(self.filename, os.W_OK):
+            raise PermissionError(f"Don't have the write permission on the file {self.filename}.")
+        with open(self.filename, 'a') as f:
+            logger.debug(f"setattr for {self.fn}, attr: {attr_name}, value: {source_lines}")
+            f.write(f"\n# Set source attribute for function {self.function_name} "
+                    f"to support run so or pyc file in Graph Mode."
+                    f"\nsetattr({self.function_name}, '{attr_name}', {source_lines})\n")
+            setattr(self.fn, attr_name, source_lines)
+
     def parse(self):
         """Parse the function or method."""
         logger.debug("fn: %r", self.fn)
         if isinstance(self.fn, (types.FunctionType, types.MethodType)) or \
            type(self.fn).__name__ == 'cython_function_or_method':
-            attr = 'source'
+            attr_name = 'source'
             try:
                 source_lines = inspect.getsourcelines(self.fn)
-                if context.get_context('support_binary') and \
-                   '/mindspore/' not in self.filename and '\\mindspore\\' not in self.filename and \
-                   (not hasattr(self.fn, attr) or getattr(self.fn, attr) != source_lines):
-                    if not os.access(self.filename, os.W_OK):
-                        raise PermissionError(f"Don't have the write permission on the file {self.filename}.")
-                    with open(self.filename, 'a') as f:
-                        f.write(f"\n# Set source attribute for function {self.function_name} "
-                                f"to support run so or pyc file in Graph Mode."
-                                f"\nsetattr({self.function_name}, '{attr}', {source_lines})\n")
-                        setattr(self.fn, attr, source_lines)
+                if context.get_context('support_binary') or os.getenv('MS_SUPPORT_BINARY', None) == '1':
+                    self.save_source_code(attr_name, source_lines)
             except (OSError, TypeError) as e:
-                if hasattr(self.fn, attr):
-                    source_lines = getattr(self.fn, attr)
+                if hasattr(self.fn, attr_name):
+                    source_lines = getattr(self.fn, attr_name)
+                elif e.__str__() == "could not get source code":
+                    raise OSError(f"Mindspore can not compile temporary source code in terminal. "
+                                  f"Please write source code to a python file and run the file.")
                 else:
-                    if e.__str__() == "could not get source code":
-                        raise OSError(f"Mindspore can not compile temporary source code in terminal. "
-                                      f"Please write source code to a python file and run the file.")
                     raise e
             self.lines, self.line_offset = source_lines
             original_src = ''.join(self.lines)
@@ -1072,7 +1047,7 @@ class Parser:
                 self.col_offset = \
                     len(original_src.split('\n')[0]) - len(src.split('\n')[0])
                 logger.debug("Get source: %s", src)
-                if not hasattr(self.fn, attr):
+                if not hasattr(self.fn, attr_name):
                     self.check_lambda(src)
                 try:
                     ast_tokens = asttokens.ASTTokens(src, parse=True)

mindspore/_extends/parse/resources.py

@@ -76,6 +76,45 @@ parse_object_map = {
     SYMBOL_UNDEFINE: (None, 'undefine', ''),
 }
 
+parse_augassign_object_map = {
+    # ast grammar
+    ast.Add:        (trope_ns, 'augassign_add', '+='),
+    ast.Sub:        (trope_ns, 'augassign_sub', '-='),
+    ast.Mult:       (trope_ns, 'augassign_mul', '*='),
+    ast.Div:        (trope_ns, 'augassign_div', '/='),
+    ast.FloorDiv:   (trope_ns, 'augassign_floordiv', '//='),
+
+    ast.Mod:        (trope_ns, 'mod', '%'),
+    ast.Pow:        (trope_ns, 'pow', '**'),
+    ast.MatMult:    (trope_ns, 'matmul', '@'),
+    ast.LShift:     (trope_ns, 'lshift', '<<'),
+    ast.RShift:     (trope_ns, 'rshift', '>>'),
+    ast.BitAnd:     (trope_ns, 'and_', '&'),
+    ast.BitOr:      (trope_ns, 'or_', '|'),
+    ast.BitXor:     (trope_ns, 'xor', '^'),
+    ast.UAdd:       (trope_ns, 'pos', '+'),
+    ast.USub:       (trope_ns, 'neg', '-'),
+    ast.Invert:     (trope_ns, 'invert', '~'),
+    ast.Not:        (trope_ns, 'not_', 'not'),
+    ast.Eq:         (trope_ns, 'eq', '=='),
+    ast.NotEq:      (trope_ns, 'ne', '!='),
+    ast.Lt:         (trope_ns, 'lt', '<'),
+    ast.Gt:         (trope_ns, 'gt', '>'),
+    ast.LtE:        (trope_ns, 'le', '<='),
+    ast.GtE:        (trope_ns, 'ge', '>='),
+    ast.Is:         (trope_ns, 'is_', 'is'),
+    ast.IsNot:      (trope_ns, 'is_not', 'is not'),
+    ast.In:         (trope_ns, 'contains', 'in'),
+    ast.NotIn:      (trope_ns, 'not_contains', 'not in'),
+
+    # operation symbol type
+    'getitem':      (composite_ns, 'getitem', ''),
+    'ms_next':      (composite_ns, 'ms_next', ''),
+
+    # undefined type
+    SYMBOL_UNDEFINE: (None, 'undefine', ''),
+}
+
 # Operation symbols corresponding to ast grammar
 ops_symbol_map = {
     # ast grammar