


'''simple docstring'''
import functools
import logging
import os
import sys
import threading
from logging import (
    CRITICAL,  # NOQA
    DEBUG,  # NOQA
    ERROR,  # NOQA
    FATAL,  # NOQA
    INFO,  # NOQA
    NOTSET,  # NOQA
    WARN,  # NOQA
    WARNING,  # NOQA
)
from typing import Optional

import huggingface_hub.utils as hf_hub_utils
from tqdm import auto as tqdm_lib


UpperCamelCase__          = threading.Lock()
UpperCamelCase__          = None

UpperCamelCase__          = {
    '''debug''': logging.DEBUG,
    '''info''': logging.INFO,
    '''warning''': logging.WARNING,
    '''error''': logging.ERROR,
    '''critical''': logging.CRITICAL,
}

UpperCamelCase__          = logging.WARNING

UpperCamelCase__          = True





def    a__			(   )       ->      List[Any]:
    UpperCAmelCase__     :						Optional[Any]						=							os.getenv('''TRANSFORMERS_VERBOSITY'''    ,   lowerCAmelCase__		)
    if env_level_str:
        if env_level_str in log_levels:
            return log_levels[env_level_str]
        else:
            logging.getLogger().warning(
                F"""Unknown option TRANSFORMERS_VERBOSITY={env_level_str}, """
                F"""has to be one of: { ", ".join(log_levels.keys()		) }"""		)
    return _default_log_level





def    a__			(   )       ->      str:
    return __name__.split('''.'''		)[0]





def    a__			(   )       ->      logging.Logger:
    return logging.getLogger(_get_library_name()		)





def    a__			(   )       ->      None:
    global _default_handler

    with _lock:
        if _default_handler:
            # This library has already configured the library root logger.
            return
        UpperCAmelCase__     :						str						=							logging.StreamHandler()  # Set sys.stderr as stream.
        UpperCAmelCase__     :						Union[str, Any]						=							sys.stderr.flush

        # Apply our default configuration to the library root logger.
        UpperCAmelCase__     :						List[Any]						=							_get_library_root_logger()
        library_root_logger.addHandler(_default_handler		)
        library_root_logger.setLevel(_get_default_logging_level()		)
        UpperCAmelCase__     :						List[Any]						=							False





def    a__			(   )       ->      None:
    global _default_handler

    with _lock:
        if not _default_handler:
            return

        UpperCAmelCase__     :						Union[str, Any]						=							_get_library_root_logger()
        library_root_logger.removeHandler(_default_handler		)
        library_root_logger.setLevel(logging.NOTSET		)
        UpperCAmelCase__     :						Dict						=							None





def    a__			(   )       ->      Dict:
    return log_levels





def    a__			(   lowerCAmelCase__ = None		)       ->      logging.Logger:

    if name is None:
        UpperCAmelCase__     :						List[Any]						=							_get_library_name()

    _configure_library_root_logger()
    return logging.getLogger(lowerCAmelCase__		)





def    a__			(   )       ->      int:
    _configure_library_root_logger()
    return _get_library_root_logger().getEffectiveLevel()





def    a__			(   lowerCAmelCase__		)       ->      None:
    _configure_library_root_logger()
    _get_library_root_logger().setLevel(lowerCAmelCase__		)





def    a__			(   )       ->      Tuple:
    return set_verbosity(lowerCAmelCase__		)





def    a__			(   )       ->      Union[str, Any]:
    return set_verbosity(lowerCAmelCase__		)





def    a__			(   )       ->      List[str]:
    return set_verbosity(lowerCAmelCase__		)





def    a__			(   )       ->      int:
    return set_verbosity(lowerCAmelCase__		)





def    a__			(   )       ->      None:
    _configure_library_root_logger()

    assert _default_handler is not None
    _get_library_root_logger().removeHandler(_default_handler		)





def    a__			(   )       ->      None:
    _configure_library_root_logger()

    assert _default_handler is not None
    _get_library_root_logger().addHandler(_default_handler		)





def    a__			(   lowerCAmelCase__		)       ->      None:
    _configure_library_root_logger()

    assert handler is not None
    _get_library_root_logger().addHandler(lowerCAmelCase__		)





def    a__			(   lowerCAmelCase__		)       ->      None:
    _configure_library_root_logger()

    assert handler is not None and handler not in _get_library_root_logger().handlers
    _get_library_root_logger().removeHandler(lowerCAmelCase__		)





def    a__			(   )       ->      None:
    _configure_library_root_logger()
    UpperCAmelCase__     :						List[Any]						=							False





def    a__			(   )       ->      None:
    _configure_library_root_logger()
    UpperCAmelCase__     :						str						=							True





def    a__			(   )       ->      None:
    UpperCAmelCase__     :						List[str]						=							_get_library_root_logger().handlers

    for handler in handlers:
        UpperCAmelCase__     :						str						=							logging.Formatter('''[%(levelname)s|%(filename)s:%(lineno)s] %(asctime)s >> %(message)s'''		)
        handler.setFormatter(lowerCAmelCase__		)





def    a__			(   )       ->      None:
    UpperCAmelCase__     :						Optional[Any]						=							_get_library_root_logger().handlers

    for handler in handlers:
        handler.setFormatter(lowerCAmelCase__		)





def    a__			(   self    ,   *lowerCAmelCase__    ,   **lowerCAmelCase__		)       ->      List[str]:
    UpperCAmelCase__     :						Optional[Any]						=							os.getenv('''TRANSFORMERS_NO_ADVISORY_WARNINGS'''    ,   lowerCAmelCase__		)
    if no_advisory_warnings:
        return
    self.warning(*lowerCAmelCase__    ,   **lowerCAmelCase__		)


UpperCamelCase__          = warning_advice





@functools.lru_cache(lowerCAmelCase__		)
def    a__			(   self    ,   *lowerCAmelCase__    ,   **lowerCAmelCase__		)       ->      Optional[Any]:
    self.warning(*lowerCAmelCase__    ,   **lowerCAmelCase__		)


UpperCamelCase__          = warning_once




class      lowerCamelCase_  :






      def __init__(   self							:       Union[str, Any]		,		*_A							:       Optional[int]		,		**_A							:       str					):  # pylint: disable=unused-argument


          '''simple docstring'''


          UpperCAmelCase__     :						Dict						=							args[0] if args else None






      def __iter__(   self							:       List[Any]					):


          '''simple docstring'''


          return iter(self._iterator					)






      def __getattr__(   self							:       Dict		,		_A							:       Union[str, Any]					):


          '''simple docstring'''


          def empty_fn(*_A							:       int		,		**_A							:       str					):  # pylint: disable=unused-argument
              return

          return empty_fn






      def __enter__(   self							:       Dict					):


          '''simple docstring'''


          return self






      def __exit__(   self							:       Any		,		_A							:       Union[str, Any]		,		_A							:       int		,		_A							:       str					):


          '''simple docstring'''


          return




class      lowerCamelCase_  :






      def __call__(   self							:       List[Any]		,		*_A							:       int		,		**_A							:       List[str]					):


          '''simple docstring'''


          if _tqdm_active:
              return tqdm_lib.tqdm(*_A		,		**_A					)
          else:
              return EmptyTqdm(*_A		,		**_A					)






      def lowercase_				(   self							:       Tuple		,		*_A							:       Dict		,		**_A							:       Optional[Any]					):


          '''simple docstring'''


          UpperCAmelCase__     :						Optional[int]						=							None
          if _tqdm_active:
              return tqdm_lib.tqdm.set_lock(*_A		,		**_A					)






      def lowercase_				(   self							:       Any					):


          '''simple docstring'''


          if _tqdm_active:
              return tqdm_lib.tqdm.get_lock()

UpperCamelCase__          = _tqdm_cls()





def    a__			(   )       ->      bool:
    global _tqdm_active
    return bool(_tqdm_active		)





def    a__			(   )       ->      List[str]:
    global _tqdm_active
    UpperCAmelCase__     :						int						=							True
    hf_hub_utils.enable_progress_bars()







def    a__			(   )       ->      List[str]:
    global _tqdm_active
    UpperCAmelCase__     :						Optional[Any]						=							False
    hf_hub_utils.disable_progress_bars()






'''simple docstring'''


from collections.abc import Generator
from math import sin
def 						snake_case_       (UpperCamelCase			:    bytes ):





							'''simple docstring'''


							if len(UpperCamelCase ) != 32:
														raise ValueError('''Input must be of length 32''' )

							_a      	=							B''''''
							for i in [3, 2, 1, 0]:
														little_endian += string_aa[8 * i : 8 * i + 8]
							return little_endian
def 						snake_case_       (UpperCamelCase			:    int ):





							'''simple docstring'''


							if i < 0:
														raise ValueError('''Input must be non-negative''' )

							_a      	=							format(UpperCamelCase					,		'''08x''' )[-8:]
							_a      	=							B''''''
							for i in [3, 2, 1, 0]:
														little_endian_hex += hex_rep[2 * i : 2 * i + 2].encode('''utf-8''' )
							return little_endian_hex
def 						snake_case_       (UpperCamelCase			:    bytes ):





							'''simple docstring'''


							_a      	=							B''''''
							for char in message:
														bit_string += format(UpperCamelCase					,		'''08b''' ).encode('''utf-8''' )
							_a      	=							format(len(UpperCamelCase )					,		'''064b''' ).encode('''utf-8''' )

							# Pad bit_string to a multiple of 512 chars
							bit_string += b"1"
							while len(UpperCamelCase ) % 512 != 448:
														bit_string += b"0"
							bit_string += to_little_endian(start_len[32:] ) + to_little_endian(start_len[:32] )

							return bit_string
def 						snake_case_       (UpperCamelCase			:    bytes ):





							'''simple docstring'''


							if len(UpperCamelCase ) % 512 != 0:
														raise ValueError('''Input must have length that\'s a multiple of 512''' )

							for pos in range(0					,		len(UpperCamelCase )					,		512 ):
														_a      	=							bit_string[pos : pos + 512]
														_a      	=							[]
														for i in range(0					,		512					,		32 ):
																					block_words.append(int(to_little_endian(block[i : i + 32] )					,		2 ) )
														yield block_words
def 						snake_case_       (UpperCamelCase			:    int ):





							'''simple docstring'''


							if i < 0:
														raise ValueError('''Input must be non-negative''' )

							_a      	=							format(UpperCamelCase					,		'''032b''' )
							_a      	=							''''''
							for c in i_str:
														new_str += "1" if c == "0" else "0"
							return int(UpperCamelCase					,		2 )
def 						snake_case_       (UpperCamelCase			:    int					,		UpperCamelCase			:    int ):





							'''simple docstring'''


							return (a + b) % 2**32
def 						snake_case_       (UpperCamelCase			:    int					,		UpperCamelCase			:    int ):





							'''simple docstring'''


							if i < 0:
														raise ValueError('''Input must be non-negative''' )
							if shift < 0:
														raise ValueError('''Shift must be non-negative''' )
							return ((i << shift) ^ (i >> (32 - shift))) % 2**32
def 						snake_case_       (UpperCamelCase			:    bytes ):





							'''simple docstring'''


							_a      	=							preprocess(UpperCamelCase )

							_a      	=							[int(2**32 * abs(sin(i + 1 ) ) ) for i in range(64 )]

							# Starting states
							_a      	=							0X67452301
							_a      	=							0Xefcdab89
							_a      	=							0X98badcfe
							_a      	=							0X10325476

							_a      	=							[
							    7,
							    12,
							    17,
							    22,
							    7,
							    12,
							    17,
							    22,
							    7,
							    12,
							    17,
							    22,
							    7,
							    12,
							    17,
							    22,
							    5,
							    9,
							    14,
							    20,
							    5,
							    9,
							    14,
							    20,
							    5,
							    9,
							    14,
							    20,
							    5,
							    9,
							    14,
							    20,
							    4,
							    11,
							    16,
							    23,
							    4,
							    11,
							    16,
							    23,
							    4,
							    11,
							    16,
							    23,
							    4,
							    11,
							    16,
							    23,
							    6,
							    10,
							    15,
							    21,
							    6,
							    10,
							    15,
							    21,
							    6,
							    10,
							    15,
							    21,
							    6,
							    10,
							    15,
							    21,
							]

							# Process bit string in chunks, each with 16 32-char words
							for block_words in get_block_words(UpperCamelCase ):
														_a      	=							aa
														_a      	=							ba
														_a      	=							ca
														_a      	=							da

														# Hash current chunk
														for i in range(64 ):
																					if i <= 15:
																												# f = (b & c) | (not_32(b) & d)     # Alternate definition for f
																												_a      	=							d ^ (b & (c ^ d))
																												_a      	=							i
																					elif i <= 31:
																												# f = (d & b) | (not_32(d) & c)     # Alternate definition for f
																												_a      	=							c ^ (d & (b ^ c))
																												_a      	=							(5 * i + 1) % 16
																					elif i <= 47:
																												_a      	=							b ^ c ^ d
																												_a      	=							(3 * i + 5) % 16
																					else:
																												_a      	=							c ^ (b | not_aa(UpperCamelCase ))
																												_a      	=							(7 * i) % 16
																					_a      	=							(f + a + added_consts[i] + block_words[g]) % 2**32
																					_a      	=							d
																					_a      	=							c
																					_a      	=							b
																					_a      	=							sum_aa(UpperCamelCase					,		left_rotate_aa(UpperCamelCase					,		shift_amounts[i] ) )

														# Add hashed chunk to running total
														_a      	=							sum_aa(UpperCamelCase					,		UpperCamelCase )
														_a      	=							sum_aa(UpperCamelCase					,		UpperCamelCase )
														_a      	=							sum_aa(UpperCamelCase					,		UpperCamelCase )
														_a      	=							sum_aa(UpperCamelCase					,		UpperCamelCase )

							_a      	=							reformat_hex(UpperCamelCase ) + reformat_hex(UpperCamelCase ) + reformat_hex(UpperCamelCase ) + reformat_hex(UpperCamelCase )
							return digest


if __name__ == "__main__":
				import doctest

				doctest.testmod()

