mindstudio-probe 8.3.2__py3-none-any.whl → 26.0.0a1__py3-none-any.whl

msprobe/msaccucmp/cmp_utils/path_check.py

@@ -0,0 +1,274 @@
+# coding=utf-8
+# -------------------------------------------------------------------------
+#  This file is part of the MindStudio project.
+# Copyright (c) 2025 Huawei Technologies Co.,Ltd.
+#
+# MindStudio is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#          http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+# -------------------------------------------------------------------------
+
+"""
+Function:
+This file mainly involves the path check function.
+"""
+import os
+import re
+import stat
+from enum import Enum
+
+from msprobe.msaccucmp.cmp_utils import log
+from msprobe.msaccucmp.cmp_utils import utils
+from msprobe.msaccucmp.cmp_utils.reg_manager import RegManager
+from msprobe.msaccucmp.cmp_utils.constant.compare_error import CompareError
+from msprobe.msaccucmp.cmp_utils.constant.const_manager import ConstManager
+
+
+class PathType(Enum):
+    """
+    The enum for path type
+    """
+    All = 0
+    File = 1
+    Directory = 2
+
+
+def _check_path_file_or_directory(path: str, path_type: PathType) -> int:
+    ret = CompareError.MSACCUCMP_NONE_ERROR
+    if path_type == PathType.File:
+        if os.path.exists(path) and not os.path.isfile(path):
+            log.print_error_log('The path "%r" is not a file. Please check the path.' % path)
+            ret = CompareError.MSACCUCMP_INVALID_PATH_ERROR
+    elif path_type == PathType.Directory:
+        if not os.path.isdir(path):
+            log.print_error_log('The path "%r" is not a directory. Please check the path.' % path)
+            ret = CompareError.MSACCUCMP_INVALID_PATH_ERROR
+    return ret
+
+
+def get_path_list_for_str(path_str: str) -> list:
+    """
+    Get path list for string
+    :param path_str: the user input string
+    :return: the path list
+    """
+    if ',' not in path_str:
+        new_path = os.path.realpath(path_str)
+        ret = check_path_valid(new_path, True, False)
+        if ret != CompareError.MSACCUCMP_NONE_ERROR:
+            raise CompareError(ret)
+        return [new_path]
+    input_path_list = []
+    for input_path in path_str.split(','):
+        new_path = os.path.realpath(input_path.strip())
+        ret = check_path_valid(new_path, True, False)
+        if ret != CompareError.MSACCUCMP_NONE_ERROR:
+            continue
+        input_path_list.append(new_path)
+    if not input_path_list:
+        log.print_error_log(
+            'There is no valid file in "%r". Please check the path.' % path_str)
+        raise CompareError(CompareError.MSACCUCMP_INVALID_PATH_ERROR)
+    return input_path_list
+
+
+def check_output_path_valid(path: str, exist: bool, path_type: PathType = PathType.Directory) -> int:
+    """
+    Check output path valid
+    :param path: the path to check
+    :param exist: the path exist
+    :param path_type: the path type
+    :return: VectorComparisonErrorCode
+    """
+    if os.path.islink(os.path.abspath(path)):
+        log.print_error_log('The path "%r" is a softlink, not permitted.' % path)
+        return CompareError.MSACCUCMP_INVALID_PATH_ERROR
+    output_path = os.path.realpath(path)
+    if path_type == PathType.File:
+        output_path = os.path.dirname(output_path)
+    if not os.path.exists(output_path):
+        try:
+            os.makedirs(output_path, mode=0o700)
+        except OSError as ex:
+            log.print_error_log('Failed to create "%r". %s' % (output_path, str(ex)))
+            return CompareError.MSACCUCMP_INVALID_PATH_ERROR
+        finally:
+            pass
+    return check_path_valid(path, exist, True, path_type)
+
+
+def check_exec_file_valid(exist_path: str) -> int:
+    """
+    Check exec path valid
+    :param path: the path to check
+    :return: VectorComparisonErrorCode
+    """
+    file_stat = os.stat(exist_path)
+    if file_stat.st_uid != 0 and file_stat.st_uid != os.getuid():
+        log.print_error_log('You are not the owner of the path "%r".' % exist_path)
+        return CompareError.MSACCUCMP_INVALID_PATH_ERROR
+
+    if file_stat.st_gid != 0 and file_stat.st_gid not in os.getgroups():
+        log.print_error_log('You are not in the group of the path "%r".' % exist_path)
+        return CompareError.MSACCUCMP_INVALID_PATH_ERROR
+
+    ret = check_others_permission(exist_path)
+    if ret != CompareError.MSACCUCMP_NONE_ERROR:
+        raise CompareError(ret)
+    
+    return check_path_valid(exist_path, True, False, PathType.File)
+
+
+def check_path_all_file_exec_valid(custom_path):
+    # all file and dir in custom path check safe
+    file_count = 0
+    for up_dir, dirs, files in os.walk(custom_path):
+        if len(up_dir.split(os.path.sep)) > ConstManager.MAX_WALK_DIR_DEEP_NUM:
+            raise CompareError(f"custom path is deep then {ConstManager.MAX_WALK_DIR_DEEP_NUM}")
+        
+        for name in files:
+            sub_file_path = os.path.join(up_dir, name)
+            ret = check_exec_file_valid(sub_file_path)
+            if ret != CompareError.MSACCUCMP_NONE_ERROR:
+                raise CompareError(ret)
+            utils.check_file_size(sub_file_path, ConstManager.ONE_MB, is_raise=True)
+            file_count = file_count + 1
+            if file_count > ConstManager.MAX_WALK_FILE_NUM:
+                raise CompareError(f"file count in custom path is more then {ConstManager.MAX_WALK_FILE_NUM}")
+
+        for name in dirs:
+            sub_dir_path = os.path.join(up_dir, name)
+            ret = check_path_valid(sub_dir_path, True, False, PathType.Directory)
+            if ret != CompareError.MSACCUCMP_NONE_ERROR:
+                raise CompareError(ret)
+
+
+def check_name_valid(name: str) -> int:
+    """
+    Check name valid
+    :param name: the name to check
+    :return: VectorComparisonErrorCode
+    """
+    if name == "":
+        log.print_error_log("The parameter is null.")
+        return CompareError.MSACCUCMP_INVALID_PARAM_ERROR
+    name_pattern = re.compile(RegManager.SUPPORT_PATH_PATTERN)
+    match = name_pattern.match(name)
+    if match is None:
+        log.print_only_support_error('name', name, '"A-Za-z0-9_\\./:()=-"')
+        return CompareError.MSACCUCMP_INVALID_PARAM_ERROR
+    return CompareError.MSACCUCMP_NONE_ERROR
+
+
+def is_same_owner(path) -> bool:
+    file_stat = os.stat(path)
+    if os.getuid() != 0 and file_stat.st_uid != os.getuid():
+        return False
+    return True
+
+
+def is_group_and_others_writable(path) -> bool:
+    file_stat = os.stat(path)
+    file_mode = file_stat.st_mode
+    if bool(file_mode & stat.S_IWGRP) or bool(file_mode & stat.S_IWOTH):
+        return True
+    return False
+
+
+def is_parent_dir_has_right_permission(path) -> bool:
+    if not is_same_owner(path) or is_group_and_others_writable(path):
+        return False
+    return True
+
+
+def check_path_valid(path: str, exist: bool, have_write_permission: bool = False,
+                     path_type: PathType = PathType.All) -> int:
+    """
+    Check path valid
+    :param path: the path to check
+    :param exist: the path exist
+    :param have_write_permission: have write permission
+    :param path_type: the path type
+    :return: VectorComparisonErrorCode
+    """
+    if path == "":
+        log.print_error_log("The path is null.")
+        return CompareError.MSACCUCMP_INVALID_PARAM_ERROR
+
+    ret = check_name_valid(path)
+    if ret != CompareError.MSACCUCMP_NONE_ERROR:
+        return ret
+    if os.path.islink(os.path.abspath(path)):
+        log.print_error_log('The path "%r" is a softlink, not permitted.' % path)
+        return CompareError.MSACCUCMP_INVALID_PATH_ERROR
+
+    exist_path = os.path.realpath(path)
+    if not exist:
+        exist_path = os.path.dirname(exist_path)
+
+    if not os.path.exists(exist_path):
+        log.print_error_log('The path "%r" does not exist.' % exist_path)
+        return CompareError.MSACCUCMP_INVALID_PATH_ERROR
+
+    if not os.access(exist_path, os.R_OK):
+        log.print_error_log('You do not have permission to read the path "%r".' % exist_path)
+        return CompareError.MSACCUCMP_INVALID_PATH_ERROR
+
+    if have_write_permission and not os.access(exist_path, os.W_OK):
+        log.print_error_log('You do not have permission to write the path "%r".' % exist_path)
+        return CompareError.MSACCUCMP_INVALID_PATH_ERROR
+    
+    file_stat = os.stat(exist_path)
+    if os.getuid() != 0 and file_stat.st_uid != os.getuid() and file_stat.st_gid not in os.getgroups():
+        log.print_error_log('You are neither the owner nor in the group of the path "%r".' % exist_path)
+        return CompareError.MSACCUCMP_INVALID_PATH_ERROR
+
+    if bool(file_stat.st_mode & stat.S_IWGRP):
+        log.print_warn_log(f"The file path is writable by group: {exist_path}.")
+
+    if bool(file_stat.st_mode & stat.S_IWOTH):
+        log.print_error_log(f"The file must not allow write access to others. File path: {exist_path}.")
+        return CompareError.MSACCUCMP_INVALID_PATH_ERROR
+
+
+    parent_directory = os.path.dirname(os.path.abspath(path))
+    if not have_write_permission and not is_parent_dir_has_right_permission(parent_directory):
+        log.print_warn_log('The permissions of the parent directory of the current file are incorrect.')
+
+    return _check_path_file_or_directory(path, path_type)
+
+
+def check_write_path_secure(path: str):
+    if os.path.islink(path):
+        os.unlink(path)
+    if os.path.exists(path):
+        os.remove(path)
+
+
+def check_others_permission(exist_path: str) -> int:
+    """
+    Check others permission
+    :param path: the path to check
+    :return: VectorComparisonErrorCode
+    """
+    file_stat = os.stat(exist_path)
+    file_mode = file_stat.st_mode
+    # 判断others或group权限是否有写权限
+    if file_stat.st_gid != 0 and bool(file_mode & stat.S_IWGRP):
+        log.print_error_log(f"File {exist_path} is not safe. Groups have writing permission to this file.")
+        return CompareError.MSACCUCMP_INVALID_PATH_ERROR
+
+    if bool(file_mode & stat.S_IWOTH):
+        log.print_error_log("File %r is dangerous. Others have writing "
+                            "permission to this file. Please use chmod to dismiss the writing permission." % exist_path)
+        return CompareError.MSACCUCMP_INVALID_PATH_ERROR
+
+    return CompareError.MSACCUCMP_NONE_ERROR
+

msprobe/msaccucmp/cmp_utils/reg_manager.py

@@ -0,0 +1,98 @@
+# coding=utf-8
+# -------------------------------------------------------------------------
+#  This file is part of the MindStudio project.
+# Copyright (c) 2025 Huawei Technologies Co.,Ltd.
+#
+# MindStudio is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#          http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+# -------------------------------------------------------------------------
+
+"""
+Function:
+This file mainly involves the reg const.
+"""
+
+import re
+
+from msprobe.msaccucmp.cmp_utils.constant.const_manager import ConstManager
+
+
+class RegManager:
+    """
+    The class for reg manager
+    """
+    NUMBER_PATTERN = r"^[0-9]+$"
+
+    # mapping of built in algorithms to numbers, the indexes correspond one-to-one to the list above
+    BUILTIN_ALGORITHM_INDEX_PATTERN = r"^([0-" + str(len(ConstManager.BUILT_IN_ALGORITHM) - 1) + "])$"
+
+    # Standard
+    STANDARD_DUMP_PATTERN = r"^([A-Za-z0-9_-]+\.[0-9]+)\.[0-9]{1,255}\.pb$"
+
+    # Qunat
+    QUANT_DUMP_PATTERN = r"^([A-Za-z0-9_-]+\.[0-9]+)\.[0-9]{1,255}\.quant$"
+
+    # Offline
+    OFFLINE_DUMP_PATTERN = r"^[A-Za-z0-9_-]+\.([A-Za-z0-9_-]+)\.[0-9]+" \
+                           r"(\.[0-9]+)?\.[0-9]{1,255}(\.[0-9]+\.[0-9]+\.[0-9]+)?(\.[0-9]+)?"
+    OFFLINE_NUMPY_PATTERN = r"^([A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[0-9]+" \
+                            r"\.[0-9]{1,255})\.[0-9]+\.\b(npy|data|bin|txt)\b$"
+    OFFLINE_FFTS_DUMP_PATTERN = r"^[A-Za-z0-9_-]+\.([A-Za-z0-9_-]+)\.[0-9]+" \
+                                r"(\.[0-9]+)?\.[0-9]{1,255}\.[0-9]+\.[0-9]+\.[0-9]+"
+
+    # Standard
+    NUMPY_DUMP_PATTERN = r"^([\.A-Za-z0-9_-]+\.[0-9]+)\.[0-9]{1,255}\.npy$"
+
+    STANDARD_NUMPY_PATTERN = r"^([\.A-Za-z0-9_-]+\.[0-9]+\.[0-9]{1,255})\.npy$"
+
+    SUPPORT_SHAPE_PATTERN = r"^([0-9]+,)+[0-9]+$"
+
+    # matching `convert_xxx_to_yyy.py`, the `{1,128}` is used for limiting string length, bypassing ReDoS attack.
+    FORMAT_CONVERT_FILE_NAME_PATTERN = r"^(convert_[A-Za-z0-9_]{1,128}_to_[A-Za-z0-9_]{1,128})\.py[c]?$"
+
+    SUPPORT_PATH_PATTERN = r"^[A-Za-z0-9_\./:()=\\-]+$"
+
+    FFTS_MANUAL_FIELD_PATTERN = r"lxslice[0-9]+"
+
+    LXSLICE_PATTERN = r"_lxslice[0-9]+"
+
+    SGT_FLIED_PATTERN = r"sgt_graph_[0-9]+"
+
+    @staticmethod
+    def match_pattern(pattern: str, value: any) -> bool:
+        """
+        The value match pattern or not
+        :param pattern: the pattern
+        :param value: the value to match
+        :return bool
+        """
+        re_pattern = re.compile(pattern)
+        match = re_pattern.match(value)
+        return match is not None
+
+    @staticmethod
+    def match_group(pattern: str, value: any) -> (bool, any):
+        """
+        The value match pattern or not
+        :param pattern: the pattern
+        :param value: the value to match
+        :return bool, match
+        """
+        re_pattern = re.compile(pattern)
+        match = re_pattern.match(value)
+        if match is not None:
+            return True, match
+        return False, match
+
+    @staticmethod
+    def get_matchs(pattern: str, value: any) -> list:
+        re_pattern = re.compile(pattern)
+        return [match for match in re.finditer(re_pattern, value)]

msprobe/msaccucmp/cmp_utils/tlv_parse.py

@@ -0,0 +1,279 @@
+# coding=utf-8
+# -------------------------------------------------------------------------
+#  This file is part of the MindStudio project.
+# Copyright (c) 2025 Huawei Technologies Co.,Ltd.
+#
+# MindStudio is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#          http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+# -------------------------------------------------------------------------
+
+"""
+Function:
+This file mainly involves the tlv info parse function.
+
+How to use:
+
+1、Tag map:
+
+TLV_CONFIG_TAB = [
+    {'Name': 'data_type',  'TLV_Type': 'ATOM', 'Ele_Type': 'INT32'},
+    {'Name': 'data_id',    'TLV_Type': 'ATOM', 'Ele_Type': 'INT32'},
+    {'Name': 'shape_dims', 'TLV_Type': 'TLNV', 'Ele_Type': 'UINT64', 'Tag': 1}
+]
+
+2、parse an bytes:
+from msprobe.msaccucmp.cmp_utils.tlv_parse import TLV
+
+class ParseInfo:
+    def __init__(self):
+        self.data_type = 0
+        self.data_id = 0
+        self.shape_dims = []
+
+aux = b'0x5a\0x5a\0x5a\0x5a' + \
+      b'0x11\0x11\0x11\0x11' + \
+      b'0x01\0x00\0x00\0x00' + \
+      b'0x10\0x00\0x00\0x00' + \
+      b'0x0a\0x0a\0x0a\0x0b\0x0b\0x0b\0x0b\0x0b' + \
+      b'0x0b\0x0b\0x0b\0x0b\0x0b\0x0b\0x0b\0x0b'
+
+input = ParseInfo()
+tlv = TLV(TLV_CONFIG_TAB)
+aux, input = tlv.parse_tlv_by_cfg_tab(aux, input)
+
+"""
+import struct
+
+from msprobe.msaccucmp.cmp_utils import log
+from msprobe.msaccucmp.cmp_utils.constant.compare_error import CompareError
+
+CHAR_SIZE = 1
+INT16_SIZE = 2
+UINT16_SIZE = 2
+INT32_SIZE = 4
+UINT32_SIZE = 4
+INT64_SIZE = 8
+UINT64_SIZE = 8
+
+_UNPACK_FORMAT = {
+    'CHAR': {'FMT': 's', 'SIZE': 1},
+    'UINT16': {'FMT': 'H', 'SIZE': 2},
+    'INT16': {'FMT': 'h', 'SIZE': 2},
+    'UINT32': {'FMT': 'I', 'SIZE': 4},
+    'INT32': {'FMT': 'i', 'SIZE': 4},
+    'UINT64': {'FMT': 'Q', 'SIZE': 8},
+    'INT64': {'FMT': 'q', 'SIZE': 8},
+}
+
+TLV_TYPE = ['ATOM', 'TLV', 'TLNV', 'NV']
+
+
+class NestedObj:
+    pass
+
+
+class TLV:
+    def __init__(self, tlv_tab, tag_type="UINT32", len_type="UINT32") -> None:
+        self.tlv_tab = tlv_tab
+        self.tag_type = tag_type
+        self.len_type = len_type
+
+    @staticmethod
+    def _unpack_single_element(aux: bytes, ele_type) -> (bytes, any):
+        type_para = _UNPACK_FORMAT.get(ele_type)
+        ele_fmt, ele_size = type_para.get('FMT'), type_para.get('SIZE')
+
+        if len(aux) < ele_size:
+            raise CompareError(CompareError.MSACCUCMP_PARSE_NANO_DUMP_FILE_ERROR)
+        try:
+            value = struct.unpack(ele_fmt, aux[:ele_size])[0]
+        except struct.error as error:
+            raise CompareError(CompareError.MSACCUCMP_PARSE_NANO_DUMP_FILE_ERROR) from error
+
+        if ele_type == 'CHAR' and isinstance(value, bytes):
+            value = value.decode(encoding="utf-8")
+
+        return aux[ele_size:], value
+
+    @staticmethod
+    def _check_tl(tag, length, tlv_cfg):
+        tag_in_cfg, ele_type = tlv_cfg.get("Tag"), tlv_cfg.get('Ele_Type')
+
+        if tag_in_cfg != tag:
+            log.print_error_log(
+                'Failed to parse of tag_in_cfg: %s, tag_in_stream: %s.' % (tag_in_cfg, tag))
+            raise CompareError(CompareError.MSACCUCMP_PARSE_NANO_DUMP_FILE_ERROR)
+
+        if not isinstance(ele_type, list):
+            ele_size = _UNPACK_FORMAT.get(ele_type).get('SIZE')
+            if length < ele_size:
+                log.print_error_log(
+                    'Failed to parse of tag: %s. length:%d < single ele_size:%d' % (tag_in_cfg, length, ele_size))
+                raise CompareError(CompareError.MSACCUCMP_PARSE_NANO_DUMP_FILE_ERROR)
+
+    def parse_tlv_by_cfg_tab(self, content: bytes, x: object) -> (bytes, object):
+        aux = content
+        self._check_cfg_tab(self.tlv_tab)
+
+        for tlv_cfg in self.tlv_tab:
+            tlv_type = tlv_cfg.get('TLV_Type')
+            if tlv_type == 'ATOM':
+                aux, x = self._unpack_atom_value(aux, tlv_cfg, x)
+            elif tlv_type == 'TLV':
+                aux, x = self._unpack_tlv_value(aux, tlv_cfg, x)
+            elif tlv_type == 'TLNV':
+                aux, x = self._unpack_tlnv_value(aux, tlv_cfg, x)
+            elif tlv_type == 'NV':
+                num_attr_name = tlv_cfg.get('N')
+                num = getattr(x, num_attr_name)
+                aux, x = self._unpack_nv_value(aux, tlv_cfg, x, num)
+        return aux, x
+
+    def _check_cfg_tab(self, tlv_tab):
+        for tlv_cfg in tlv_tab:
+            tlv_type, ele_type = tlv_cfg.get('TLV_Type'), tlv_cfg.get('Ele_Type')
+            if tlv_type not in TLV_TYPE:
+                log.print_error_log('%s invalid tlv_type: %s.' % (tlv_cfg.get('Name'), tlv_type))
+                raise CompareError(CompareError.MSACCUCMP_PARSE_NANO_DUMP_FILE_ERROR)
+
+            # Nested tlv
+            if isinstance(ele_type, list):
+                self._check_cfg_tab(ele_type)
+            elif _UNPACK_FORMAT.get(ele_type) is None:
+                log.print_error_log('invalid ele_type: %s.' % ele_type)
+                raise CompareError(CompareError.MSACCUCMP_PARSE_NANO_DUMP_FILE_ERROR)
+
+            if tlv_type == 'NV':
+                num_attr_name = tlv_cfg.get('N')
+                if num_attr_name is None:
+                    log.print_error_log("is tlv_tpye is NV, 'N' must be given!")
+                    raise CompareError(CompareError.MSACCUCMP_PARSE_NANO_DUMP_FILE_ERROR)
+        return
+
+    def _unpack_atom_value(self, aux: bytes, tlv_cfg, x: object) -> (bytes, object):
+        ele_type, ele_name = tlv_cfg.get('Ele_Type'), tlv_cfg.get('Name')
+
+        if isinstance(ele_type, list):
+            # parse Nested tlv value
+            sub_tlv_tab = ele_type
+            sub_tlv = TLV(sub_tlv_tab)
+            nested_obj = NestedObj()
+            aux, value = sub_tlv.parse_tlv_by_cfg_tab(aux, nested_obj)
+        else:
+            try:
+                # parse single element
+                aux, value = self._unpack_single_element(aux, ele_type)
+            except CompareError as error:
+                log.print_error_log('Failed to parse of ele name: %s, value_type: %s, '
+                                    'Please check the dump file:%s.' % (tlv_cfg.get('Name'), ele_type, str(error)))
+                raise CompareError(CompareError.MSACCUCMP_PARSE_NANO_DUMP_FILE_ERROR) from error
+
+        setattr(x, ele_name, value)
+        return aux, x
+
+    def _parse_tag_len(self, aux: bytes) -> (bytes, any, any):
+        aux, tag = self._unpack_single_element(aux, self.tag_type)
+        aux, length = self._unpack_single_element(aux, self.len_type)
+        return aux, tag, length
+
+    def _unpack_tlv_value(self, aux: bytes, tlv_cfg, x: object) -> (bytes, object):
+        ele_type, ele_name = tlv_cfg.get('Ele_Type'), tlv_cfg.get('Name')
+
+        # tag, len
+        try:
+            aux_try, tag, length = self._parse_tag_len(aux)
+        except CompareError:
+            setattr(x, ele_name, None)
+            log.print_info_log('Failed to parse of ele name: %s, ele_type: %s' % (ele_name, ele_type))
+            return aux, x
+        try:
+            self._check_tl(tag, length, tlv_cfg)
+        except CompareError:
+            log.print_info_log('Failed to parse of ele name: %s, ele_type: %s' % (ele_name, ele_type))
+            setattr(x, ele_name, None)
+            return aux, x
+
+        new_aux, new_x = self._unpack_atom_value(aux_try, tlv_cfg, x)
+        return new_aux, new_x
+
+    def _unpack_tlnv_value(self, aux: bytes, tlv_cfg, x: object) -> (bytes, object):
+        tag_in_cfg, ele_type, ele_name = tlv_cfg.get("Tag"), tlv_cfg.get('Ele_Type'), tlv_cfg.get('Name')
+
+        # tag, len
+        try:
+            aux_try, tag, length = self._parse_tag_len(aux)
+        except CompareError:
+            setattr(x, ele_name, None)
+            log.print_info_log('skip to parse tlv of ele name: %s, ele_type: %s' % (ele_name, ele_type))
+            return aux, x
+        try:
+            self._check_tl(tag, length, tlv_cfg)
+        except CompareError:
+            log.print_info_log('skip to parse tlv of ele name: %s, ele_type: %s' % (ele_name, ele_type))
+            setattr(x, ele_name, None)
+            return aux, x
+
+        aux = aux_try
+
+        # get list num of value
+        if _UNPACK_FORMAT.get(ele_type) is not None:
+            ele_size = _UNPACK_FORMAT.get(ele_type).get('SIZE')
+            ele_num = int(length / ele_size)
+
+            try:
+                aux, x = self._unpack_nv_value(aux, tlv_cfg, x, ele_num)
+            except CompareError as error:
+                log.print_error_log('Failed to parse of ele name: %s, value_type: %s, '
+                                    'Please check the dump file:%s.' % (tlv_cfg.get('Name'), ele_type, str(error)))
+                raise CompareError(CompareError.MSACCUCMP_PARSE_NANO_DUMP_FILE_ERROR) from error
+
+        elif isinstance(ele_type, list):
+            value = []
+            sub_aux = aux[:length]
+
+            while (len(sub_aux) > 0):
+                # Nested tlv
+                sub_tlv_tab = ele_type
+                sub_tlv, nested_obj = TLV(sub_tlv_tab), NestedObj()
+                sub_aux, single_value = sub_tlv.parse_tlv_by_cfg_tab(sub_aux, nested_obj)
+                value.append(single_value)
+
+            setattr(x, tlv_cfg.get('Name'), value)
+            aux = aux[length:]
+        return aux, x
+
+    def _unpack_nv_value(self, aux: bytes, tlv_cfg, x: object, ele_num) -> (bytes, object):
+        ele_type, ele_name = tlv_cfg.get('Ele_Type'), tlv_cfg.get('Name')
+        value = []
+
+        for _ in range(ele_num):
+            if isinstance(ele_type, list):
+                # Nested tlv
+                sub_tlv_tab = ele_type
+                sub_tlv, nested_obj = TLV(sub_tlv_tab), NestedObj()
+                aux, single_value = sub_tlv.parse_tlv_by_cfg_tab(aux, nested_obj)
+                value.append(single_value)
+            else:
+                try:
+                    # single element
+                    aux, single_value = self._unpack_single_element(aux, ele_type)
+                except CompareError as error:
+                    log.print_error_log('Failed to parse of ele name: %s, value_type: %s, '
+                                        'Please check the dump file:%s.' % (tlv_cfg.get('Name'), ele_type, str(error)))
+                    raise CompareError(CompareError.MSACCUCMP_PARSE_NANO_DUMP_FILE_ERROR) from error
+                value.append(single_value)
+
+        if ele_type == 'CHAR' and isinstance(value, list):
+            value_str = "".join(value)
+            setattr(x, tlv_cfg.get('Name'), value_str)
+        else:
+            setattr(x, tlv_cfg.get('Name'), value)
+        return aux, x