mindspore 2.4.10__cp39-cp39-win_amd64.whl → 2.5.0__cp39-cp39-win_amd64.whl

mindspore/hal/stream.py

@@ -21,8 +21,13 @@ from mindspore._c_expression import default_stream as default_stream_
 from mindspore._c_expression import communication_stream as communication_stream_
 
 from mindspore import _checkparam as Validator
+from mindspore import log as logger
 from .event import Event
 
+function_stream_status = {'record_event': False, 'wait_event': False, 'wait_stream': False,
+                          'query': False, 'synchronize': False, 'set_cur_stream': False,
+                          'current_stream': False, 'default_stream': False,
+                          'communication_stream': False, 'StreamCtx': False}
 
 class Stream(Stream_):
     r"""
@@ -31,13 +36,15 @@ class Stream(Stream_):
     A device stream is a linear sequence of execution that belongs to a specific device,
     independent from other streams.
 
-    For a quick start of using Stream, please refer to `Illustration of stream management <https://www.mindspore.cn/docs/en/master/api_python/samples/hal/stream_manager.html>`_ .
+    Note:
+        - The api will be deprecated, please use the api :class:`mindspore.runtime.Stream`.
 
     Args:
         priority (int, optional): priority of the stream, lower numbers represent higher priorities.
             By default, streams have priority ``0``.
         kwargs (dict): keyword arguments.
     """
+
     def __init__(self, priority=0, **kwargs):
         self.init_finished = False
         if 'stream' in kwargs and kwargs['stream'] is not None:
@@ -84,6 +91,12 @@ class Stream(Stream_):
              [5. 5. 5.]
              [5. 5. 5.]]
         """
+        if not function_stream_status['record_event']:
+            function_stream_status['record_event'] = True
+            logger.warning(
+                "WARN_DEPRECATED: The usage of mindspore.hal.Stream().record_event() is deprecated."
+                " Please use mindspore.runtime.Stream().record_event()"
+            )
         if event is None:
             event = Event()
         if not isinstance(event, Event):
@@ -121,6 +134,12 @@ class Stream(Stream_):
              [5. 5. 5.]
              [5. 5. 5.]]
         """
+        if not function_stream_status['wait_event']:
+            function_stream_status['wait_event'] = True
+            logger.warning(
+                "WARN_DEPRECATED: The usage of mindspore.hal.current_stream().wait_event(event) is deprecated."
+                " Please use mindspore.runtime.current_stream().wait_event(event)"
+            )
         if not isinstance(event, Event):
             raise TypeError(f"For 'wait_event', the argument 'event' should be Event,"
                             f" but got {type(event)}.")
@@ -156,6 +175,12 @@ class Stream(Stream_):
             >>> print(d)
             [[4. 4.]]
         """
+        if not function_stream_status['wait_stream']:
+            function_stream_status['wait_stream'] = True
+            logger.warning(
+                "WARN_DEPRECATED: The usage of mindspore.hal.Stream() is deprecated."
+                " Please use mindspore.runtime.Stream()"
+            )
         if not isinstance(stream, Stream):
             raise TypeError(f"For 'wait_stream', the argument 'stream' should be Stream,"
                             f" but got {type(stream)}.")
@@ -199,6 +224,12 @@ class Stream(Stream_):
             >>> s1.synchronize()
             >>> assert s1.query()
         """
+        if not function_stream_status['query']:
+            function_stream_status['query'] = True
+            logger.warning(
+                "WARN_DEPRECATED: The usage of mindspore.hal.Stream() is deprecated."
+                " Please use mindspore.runtime.Stream()"
+            )
         # pylint: disable=useless-super-delegation
         return super().query()
 
@@ -221,6 +252,9 @@ def synchronize():
     r"""
     Synchronize all streams on current device.(Each MindSpore process only occupies one device)
 
+    Note:
+        - The api will be deprecated, please use the api :func:`mindspore.runtime.synchronize` instead.
+
     Examples:
         >>> import mindspore as ms
         >>> import numpy as np
@@ -233,6 +267,12 @@ def synchronize():
         >>> ms.hal.synchronize()
         >>> assert s1.query()
     """
+    if not function_stream_status['synchronize']:
+        function_stream_status['synchronize'] = True
+        logger.warning(
+            "WARN_DEPRECATED: The usage of mindspore.hal.synchronize() is deprecated."
+            " Please use mindspore.runtime.synchronize()"
+        )
     synchronize_()
 
 
@@ -241,6 +281,9 @@ def set_cur_stream(stream):
     Sets the current stream.This is a wrapper API to set the stream.
     Usage of this function is discouraged in favor of the ``stream`` context manager.
 
+    Note:
+        - The api will be deprecated, please use the api :func:`mindspore.runtime.set_cur_stream` instead.
+
     Args:
         stream (Stream): selected stream. This function is a no-op
             if this argument is ``None``.
@@ -257,6 +300,12 @@ def set_cur_stream(stream):
         >>> assert ms.hal.current_stream() == s1
         >>> ms.hal.set_cur_stream(ms.hal.default_stream())
     """
+    if not function_stream_status['set_cur_stream']:
+        function_stream_status['set_cur_stream'] = True
+        logger.warning(
+            "WARN_DEPRECATED: The usage of mindspore.hal.Stream() is deprecated."
+            " Please use mindspore.runtime.Stream()"
+        )
     if stream is None:
         return
     if not isinstance(stream, Stream):
@@ -269,6 +318,9 @@ def current_stream():
     r"""
     Return current stream used on this device.
 
+    Note:
+        - The api will be deprecated, please use the api :func:`mindspore.runtime.current_stream` instead.
+
     Returns:
         stream (Stream), current stream.
 
@@ -277,6 +329,12 @@ def current_stream():
         >>> cur_stream = ms.hal.current_stream()
         >>> assert cur_stream == ms.hal.default_stream()
     """
+    if not function_stream_status['current_stream']:
+        function_stream_status['current_stream'] = True
+        logger.warning(
+            "WARN_DEPRECATED: The usage of mindspore.hal.current_stream() is deprecated."
+            " Please use mindspore.runtime.current_stream()"
+        )
     return Stream(stream=current_stream_())
 
 
@@ -284,6 +342,9 @@ def default_stream():
     r"""
     Return default stream on this device.
 
+    Note:
+        - The api will be deprecated, please use the api :func:`mindspore.runtime.default_stream` instead.
+
     Returns:
         stream (Stream), default stream.
 
@@ -292,22 +353,36 @@ def default_stream():
         >>> cur_stream = ms.hal.current_stream()
         >>> assert cur_stream == ms.hal.default_stream()
     """
+    if not function_stream_status['default_stream']:
+        function_stream_status['default_stream'] = True
+        logger.warning(
+            "WARN_DEPRECATED: The usage of mindspore.hal.default_stream() is deprecated."
+            " Please use mindspore.runtime.default_stream()"
+        )
     return Stream(stream=default_stream_())
 
 
 def communication_stream():
     r"""
-    Return default stream on this device.
+    Return communication stream on this device.
+
+    Note:
+        - The api will be deprecated, please use the api :func:`mindspore.runtime.communication_stream` instead.
 
     Returns:
-        stream (Stream), default stream.
+        stream (Stream), communication stream.
 
-    TODO
     Examples:
         >>> import mindspore as ms
-        >>> cur_stream = ms.hal.current_stream()
-        >>> assert cur_stream == ms.hal.default_stream()
+        >>> ms.hal.communication_stream()
+        Stream(device_name=Ascend, device_id:0, stream id:1)
     """
+    if not function_stream_status['communication_stream']:
+        function_stream_status['communication_stream'] = True
+        logger.warning(
+            "WARN_DEPRECATED: The usage of mindspore.hal.communication_stream() is deprecated."
+            " Please use mindspore.runtime.communication_stream()"
+        )
     return Stream(stream=communication_stream_())
 
 
@@ -315,6 +390,9 @@ class StreamCtx():
     r"""
     Context-manager that selects a given stream.
 
+    Note:
+        - The api will be deprecated, please use the api :class:`mindspore.runtime.StreamCtx`.
+
     All kernels queued within its context will be enqueued on a selected
     stream.
 
@@ -336,7 +414,14 @@ class StreamCtx():
         >>> ms.hal.synchronize()
         >>> assert s1.query()
     """
+
     def __init__(self, ctx_stream):
+        if not function_stream_status['StreamCtx']:
+            function_stream_status['StreamCtx'] = True
+            logger.warning(
+                "WARN_DEPRECATED: The usage of mindspore.hal.StreamCtx(s1) is deprecated."
+                " Please use mindspore.runtime.StreamCtx(s1)"
+            )
         if ctx_stream is not None and not isinstance(ctx_stream, Stream):
             raise TypeError(f"For 'StreamCtx', the argument 'ctx_stream' should be Stream,"
                             f" but got {type(ctx_stream)}.")

mindspore/include/api/context.h

@@ -27,7 +27,6 @@ namespace mindspore {
 enum DelegateMode {
   kNoDelegate = 0,
   kCoreML = 1,
-  kNNAPI = 2,
 };
 
 enum DeviceType {

mindspore/log.py

@@ -26,6 +26,7 @@ from logging.handlers import RotatingFileHandler
 import traceback
 import threading
 import platform
+from datetime import datetime
 
 if platform.system() != "Windows":
     import fcntl
@@ -225,6 +226,17 @@ def critical(msg, *args, **kwargs):
     _get_logger().critical(msg, *args, **kwargs)
 
 
+def vlog_print(level, module, file, line, message):
+    '''Read environment variable VLOG_v and print to log'''
+    if os.environ.get("VLOG_v") == level:
+        now = datetime.now()
+        formatted_time = now.strftime("%Y-%m-%d-%H:%M:%S.%f")[:-3] + f".{now.microsecond // 1000}"
+        path = 'mindspore' + file.split("mindspore")[-1]
+        pid = os.getpid()
+        thread_id = threading.get_ident()
+        print(f"[V{level}] {module}({pid},{thread_id},python):{formatted_time} [{path}:{line}] {message}", flush=True)
+
+
 def get_level():
     """
     Get the logger level.

mindspore/mindrecord/__init__.py

@@ -39,5 +39,5 @@ from .config import *
 
 __all__ = ['FileWriter', 'FileReader', 'MindPage',
            'Cifar10ToMR', 'Cifar100ToMR', 'CsvToMR', 'ImageNetToMR', 'MnistToMR', 'TFRecordToMR',
-           'set_enc_key', 'set_enc_mode', 'set_dec_mode', 'set_hash_mode',
+           'set_enc_key', 'set_enc_mode', 'set_dec_mode',
            'SUCCESS', 'FAILED']

mindspore/mindrecord/config.py

@@ -20,10 +20,9 @@ Common imported modules in corresponding API examples are as follows:
 
 .. code-block::
 
-    from mindspore.mindrecord import set_enc_key, set_enc_mode, set_dec_mode, set_hash_mode
+    from mindspore.mindrecord import set_enc_key, set_enc_mode, set_dec_mode
 """
 
-import hashlib
 import os
 import shutil
 import stat
@@ -36,47 +35,33 @@ from .shardutils import MIN_FILE_SIZE
 
 __all__ = ['set_enc_key',
            'set_enc_mode',
-           'set_dec_mode',
-           'set_hash_mode']
+           'set_dec_mode']
 
 
-# default encode key and hash mode
+# default encode key
 ENC_KEY = None
 ENC_MODE = "AES-GCM"
 DEC_MODE = None
 HASH_MODE = None
 
 
-# the final mindrecord after hash check and encode should be like below
-# 1. for create new mindrecord: should do hash first, then encode
-# mindrecord ->
-#               mindrecord+hash_value+len(4bytes)+'HASH' ->
-#                                                                enc_mindrecord+'ENCRYPT'
-# 2. for read mindrecord, should decode first, then do hash check
-# enc_mindrecord+'ENCRYPT' ->
-#                             mindrecord+hash_value+len(4bytes)+'HASH'
+# the final mindrecord after encode should be like below
+# 1. for create new mindrecord
+# mindrecord -> enc_mindrecord+'ENCRYPT'
+# 2. for read mindrecord
+# enc_mindrecord+'ENCRYPT' -> mindrecord
 
 
 # mindrecord file encode end flag, we will append 'ENCRYPT' to the end of file
 ENCRYPT_END_FLAG = str('ENCRYPT').encode('utf-8')
 
 
-# mindrecord file hash check flag, we will append hash value+'HASH' to the end of file
-HASH_END_FLAG = str('HASH').encode('utf-8')
-
-
-# length of hash value (4bytes) + 'HASH'
-LEN_HASH_WITH_END_FLAG = 4 + len(HASH_END_FLAG)
-
-
 # directory which stored decrypt mindrecord files
 DECRYPT_DIRECTORY = ".decrypt_mindrecord"
 DECRYPT_DIRECTORY_LIST = []
 
 
-# time for warning when encrypt/decrypt or calculate hash takes too long time
-CALCULATE_HASH_TIME = 0
-VERIFY_HASH_TIME = 0
+# time for warning when encrypt/decrypt takes too long time
 ENCRYPT_TIME = 0
 DECRYPT_TIME = 0
 WARNING_INTERVAL = 30   # 30s
@@ -86,9 +71,6 @@ def set_enc_key(enc_key):
     """
     Set the encode key.
 
-    Note:
-        When the encryption algorithm is ``"SM4-CBC"`` , only 16 bit length key are supported.
-
     Args:
         enc_key (str): Str-type key used for encryption. The valid length is 16, 24, or 32.
             ``None`` indicates that encryption is not enabled.
@@ -129,9 +111,9 @@ def set_enc_mode(enc_mode="AES-GCM"):
 
     Args:
         enc_mode (Union[str, function], optional): This parameter is valid only when enc_key is not set to ``None`` .
-            Specifies the encryption mode or customized encryption function, currently supports ``"AES-GCM"``,
-            ``"AES-CBC"`` and ``"SM4-CBC"`` . Default: ``"AES-GCM"`` . If it is customized encryption, users need
-            to ensure its correctness and raise exceptions when errors occur.
+            Specifies the encryption mode or customized encryption function, currently supports ``"AES-GCM"`` .
+            Default: ``"AES-GCM"`` . If it is customized encryption, users need
+            to ensure its correctness, the security of the encryption algorithm and raise exceptions when errors occur.
 
     Raises:
         ValueError: The input is not valid encode mode or callable function.
@@ -150,7 +132,7 @@ def set_enc_mode(enc_mode="AES-GCM"):
     if not isinstance(enc_mode, str):
         raise ValueError("The input enc_mode is not str.")
 
-    if enc_mode not in ["AES-GCM", "AES-CBC", "SM4-CBC"]:
+    if enc_mode not in ["AES-GCM"]:
         raise ValueError("The input enc_mode is invalid.")
 
     ENC_MODE = enc_mode
@@ -173,8 +155,8 @@ def set_dec_mode(dec_mode="AES-GCM"):
 
     Args:
         dec_mode (Union[str, function], optional): This parameter is valid only when enc_key is not set to ``None`` .
-            Specifies the decryption mode or customized decryption function, currently supports ``"AES-GCM"``,
-            ``"AES-CBC"`` and ``"SM4-CBC"`` . Default: ``"AES-GCM"`` . ``None`` indicates that decryption
+            Specifies the decryption mode or customized decryption function, currently supports ``"AES-GCM"`` .
+            Default: ``"AES-GCM"`` . ``None`` indicates that decryption
             mode is not defined. If it is customized decryption, users need to ensure its correctness and raise
             exceptions when errors occur.
 
@@ -199,7 +181,7 @@ def set_dec_mode(dec_mode="AES-GCM"):
     if not isinstance(dec_mode, str):
         raise ValueError("The input dec_mode is not str.")
 
-    if dec_mode not in ["AES-GCM", "AES-CBC", "SM4-CBC"]:
+    if dec_mode not in ["AES-GCM"]:
         raise ValueError("The input dec_mode is invalid.")
 
     DEC_MODE = dec_mode
@@ -244,7 +226,7 @@ def _get_dec_mode_as_str():
     if DEC_MODE is None:
         if callable(ENC_MODE):
             raise RuntimeError("You use custom encryption, so you must also define custom decryption.")
-        valid_dec_mode = ENC_MODE   # "AES-GCM" / "AES-CBC" / "SM4-CBC"
+        valid_dec_mode = ENC_MODE   # "AES-GCM"
     elif callable(DEC_MODE):
         valid_dec_mode = "UDF-ENC"  # "UDF-ENC"
     else:
@@ -256,287 +238,6 @@ def _get_dec_mode_as_str():
     return str(valid_dec_mode).encode('utf-8')
 
 
-def set_hash_mode(hash_mode):
-    """
-    Set the hash mode to ensure mindrecord file integrity.
-
-    Args:
-        hash_mode (Union[str, function]): The parameter is used to specify the hash mode. Specifies the hash
-            mode or customized hash function, currently supports ``None``, ``"sha256"``,
-            ``"sha384"``, ``"sha512"``, ``"sha3_256"``, ``"sha3_384"``
-            and ``"sha3_512"``. ``None`` indicates that hash check is not enabled.
-
-    Raises:
-        ValueError: The input is not valid hash mode or callable function.
-
-    Examples:
-        >>> from mindspore.mindrecord import set_hash_mode
-        >>>
-        >>> set_hash_mode("sha256")
-    """
-    global HASH_MODE
-
-    if hash_mode is None:
-        HASH_MODE = None
-        return
-
-    if callable(hash_mode):
-        HASH_MODE = hash_mode
-        return
-
-    if not isinstance(hash_mode, str):
-        raise ValueError("The input hash_mode is not str.")
-
-    if hash_mode not in ["sha256", "sha384", "sha512", "sha3_256", "sha3_384", "sha3_512"]:
-        raise ValueError("The input hash_mode is invalid.")
-
-    HASH_MODE = hash_mode
-
-
-def _get_hash_func():
-    """Get the hash func by hash mode"""
-    global HASH_MODE
-
-    if HASH_MODE is None:
-        raise RuntimeError("The HASH_MODE is None, no matching hash function.")
-
-    if callable(HASH_MODE):
-        return HASH_MODE
-
-    if HASH_MODE == "sha256":
-        return hashlib.sha256()
-    if HASH_MODE == "sha384":
-        return hashlib.sha384()
-    if HASH_MODE == "sha512":
-        return hashlib.sha512()
-    if HASH_MODE == "sha3_256":
-        return hashlib.sha3_256()
-    if HASH_MODE == "sha3_384":
-        return hashlib.sha3_384()
-    if HASH_MODE == "sha3_512":
-        return hashlib.sha3_512()
-    raise RuntimeError("The HASH_MODE: {} is invalid.".format(HASH_MODE))
-
-
-def _get_hash_mode():
-    """Get the hash check mode."""
-    global HASH_MODE
-
-    return HASH_MODE
-
-
-def calculate_file_hash(filename, whole=True):
-    """Calculate the file's hash"""
-    if not os.path.exists(filename):
-        raise RuntimeError("The input: {} is not exists.".format(filename))
-
-    if not os.path.isfile(filename):
-        raise RuntimeError("The input: {} should be a regular file.".format(filename))
-
-    # get the hash func
-    m = _get_hash_func()
-
-    f = open(filename, 'rb')
-
-    # get the file size first
-    if whole:
-        file_size = os.path.getsize(filename)
-    else:
-        len_hash_offset = os.path.getsize(filename) - LEN_HASH_WITH_END_FLAG
-        try:
-            f.seek(len_hash_offset)
-        except Exception as e:  # pylint: disable=W0703
-            f.close()
-            raise RuntimeError("Seek the file: {} to position: {} failed. Error: {}"
-                               .format(filename, len_hash_offset, str(e)))
-
-        len_hash = int.from_bytes(f.read(4), byteorder='big')  # length of hash value is 4 bytes
-        file_size = os.path.getsize(filename) - LEN_HASH_WITH_END_FLAG - len_hash
-
-    offset = 64 * 1024 * 1024    ## read the offset 64M
-    current_offset = 0           ## use this to seek file
-
-    # read the file with offset and do sha256 hash
-    hash_value = str("").encode('utf-8')
-    while True:
-        if (file_size - current_offset) >= offset:
-            read_size = offset
-        elif file_size - current_offset > 0:
-            read_size = file_size - current_offset
-        else:
-            # have read the entire file
-            break
-
-        try:
-            f.seek(current_offset)
-        except Exception as e:  # pylint: disable=W0703
-            f.close()
-            raise RuntimeError("Seek the file: {} to position: {} failed. Error: {}"
-                               .format(filename, current_offset, str(e)))
-
-        data = f.read(read_size)
-        if callable(m):
-            hash_value = m(data, hash_value)
-            if not isinstance(hash_value, bytes):
-                raise RuntimeError("User defined hash function should return hash value which is bytes type.")
-            if hash_value is None:
-                raise RuntimeError("User defined hash function return empty.")
-        else:
-            m.update(data)
-
-        current_offset += read_size
-
-    f.close()
-
-    if callable(m):
-        return hash_value
-    return m.digest()
-
-
-def append_hash_to_file(filename):
-    """append the hash value to the end of file"""
-    if not os.path.exists(filename):
-        raise RuntimeError("The input: {} is not exists.".format(filename))
-
-    if not os.path.isfile(filename):
-        raise RuntimeError("The input: {} should be a regular file.".format(filename))
-
-    logger.info("Begin to calculate the hash of the file: {}.".format(filename))
-    start = time.time()
-
-    hash_value = calculate_file_hash(filename)
-
-    # append hash value, length of hash value (4bytes) and HASH_END_FLAG to the file
-    f = open(filename, 'ab')
-    f.write(hash_value)     # append the hash value
-    f.write((len(hash_value)).to_bytes(4, byteorder='big', signed=False))  # append the length of hash value
-    f.write(HASH_END_FLAG)  # append the HASH_END_FLAG
-    f.close()
-
-    end = time.time()
-    global CALCULATE_HASH_TIME
-    CALCULATE_HASH_TIME += end - start
-    if CALCULATE_HASH_TIME > WARNING_INTERVAL:
-        logger.warning("It takes another " + str(WARNING_INTERVAL) +
-                       "s to calculate the hash value of the mindrecord file.")
-        CALCULATE_HASH_TIME = CALCULATE_HASH_TIME - WARNING_INTERVAL
-
-    # change the file mode
-    os.chmod(filename, stat.S_IRUSR | stat.S_IWUSR)
-
-    return True
-
-
-def get_hash_end_flag(filename):
-    """get the hash end flag from the file"""
-    if not os.path.exists(filename):
-        raise RuntimeError("The input: {} is not exists.".format(filename))
-
-    if not os.path.isfile(filename):
-        raise RuntimeError("The input: {} should be a regular file.".format(filename))
-
-    # get the file size first
-    file_size = os.path.getsize(filename)
-    offset = file_size - len(HASH_END_FLAG)
-    f = open(filename, 'rb')
-
-    # get the hash end flag which is HASH_END_FLAG
-    try:
-        f.seek(offset)
-    except Exception as e:  # pylint: disable=W0703
-        f.close()
-        raise RuntimeError("Seek the file: {} to position: {} failed. Error: {}".format(filename, offset, str(e)))
-
-    data = f.read(len(HASH_END_FLAG))
-    f.close()
-
-    return data
-
-
-def get_hash_value(filename):
-    """get the file's hash"""
-    if not os.path.exists(filename):
-        raise RuntimeError("The input: {} is not exists.".format(filename))
-
-    if not os.path.isfile(filename):
-        raise RuntimeError("The input: {} should be a regular file.".format(filename))
-
-    # get the file size first
-    file_size = os.path.getsize(filename)
-
-    # the hash_value+len(4bytes)+'HASH' is stored in the end of the file
-    offset = file_size - LEN_HASH_WITH_END_FLAG
-    f = open(filename, 'rb')
-
-    # seek the position for the length of hash value
-    try:
-        f.seek(offset)
-    except Exception as e:  # pylint: disable=W0703
-        f.close()
-        raise RuntimeError("Seek the file: {} to position: {} failed. Error: {}".format(filename, offset, str(e)))
-
-    len_hash = int.from_bytes(f.read(4), byteorder='big')  # length of hash value is 4 bytes
-    hash_value_offset = file_size - len_hash - LEN_HASH_WITH_END_FLAG
-
-    # seek the position for the hash value
-    try:
-        f.seek(hash_value_offset)
-    except Exception as e:  # pylint: disable=W0703
-        f.close()
-        raise RuntimeError("Seek the file: {} to position: {} failed. Error: {}"
-                           .format(filename, hash_value_offset, str(e)))
-
-    # read the hash value
-    data = f.read(len_hash)
-    f.close()
-
-    return data
-
-
-def verify_file_hash(filename):
-    """Calculate the file hash and compare it with the hash value which is stored in the file"""
-    if not os.path.exists(filename):
-        raise RuntimeError("The input: {} is not exists.".format(filename))
-
-    if not os.path.isfile(filename):
-        raise RuntimeError("The input: {} should be a regular file.".format(filename))
-
-    # verify the hash end flag
-    stored_hash_end_flag = get_hash_end_flag(filename)
-    if _get_hash_mode() is not None:
-        if stored_hash_end_flag != HASH_END_FLAG:
-            raise RuntimeError("The mindrecord file is not hashed. You can set " +
-                               "'mindspore.mindrecord.config.set_hash_mode(None)' to disable the hash check.")
-    else:
-        if stored_hash_end_flag == HASH_END_FLAG:
-            raise RuntimeError("The mindrecord file is hashed. You need to configure " +
-                               "'mindspore.mindrecord.config.set_hash_mode(...)' to enable the hash check.")
-        return True
-
-    # get the pre hash value from the end of the file
-    stored_hash_value = get_hash_value(filename)
-
-    logger.info("Begin to verify the hash of the file: {}.".format(filename))
-    start = time.time()
-
-    # calculate hash by the file
-    current_hash = calculate_file_hash(filename, False)
-
-    if stored_hash_value != current_hash:
-        raise RuntimeError("The input file: " + filename + " hash check fail. The file may be damaged. "
-                           "Or configure a correct hash mode.")
-
-    end = time.time()
-    global VERIFY_HASH_TIME
-    VERIFY_HASH_TIME += end - start
-    if VERIFY_HASH_TIME > WARNING_INTERVAL:
-        logger.warning("It takes another " + str(WARNING_INTERVAL) +
-                       "s to verify the hash value of the mindrecord file.")
-        VERIFY_HASH_TIME = VERIFY_HASH_TIME - WARNING_INTERVAL
-
-    return True
-
-
 def encrypt(filename, enc_key, enc_mode):
     """Encrypt the file and the original file will be deleted"""
     if not os.path.exists(filename):