





"""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


A	     =					threading.Lock()
A	     =					None

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

A	     =					logging.WARNING

A	     =					True

def       __A (     )						->						List[str]:
				__a	:  Optional[int]         =					os.getenv('''TRANSFORMERS_VERBOSITY'''				,    a_)
				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
								__a	:  Optional[Any]         =					logging.StreamHandler()  # Set sys.stderr as stream.
								__a	:  Optional[Any]         =					sys.stderr.flush

								# Apply our default configuration to the library root logger.
								__a	:  str         =					_get_library_root_logger()
								library_root_logger.addHandler(_default_handler)
								library_root_logger.setLevel(_get_default_logging_level())
								__a	:  Optional[int]         =					False

def       __A (     )						->						None:
				global _default_handler

				with _lock:
								if not _default_handler:
												return

								__a	:  List[str]         =					_get_library_root_logger()
								library_root_logger.removeHandler(_default_handler)
								library_root_logger.setLevel(logging.NOTSET)
								__a	:  Any         =					None

def       __A (     )						->						Union[str, Any]:
				return log_levels

def       __A (     a_  :Optional[str] = None)						->						logging.Logger:

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

				_configure_library_root_logger()
				return logging.getLogger(a_)

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

def       __A (     a_  :int)						->						None:
				_configure_library_root_logger()
				_get_library_root_logger().setLevel(a_)

def       __A (     )						->						List[Any]:
				return set_verbosity(a_)

def       __A (     )						->						List[Any]:
				return set_verbosity(a_)

def       __A (     )						->						Union[str, Any]:
				return set_verbosity(a_)

def       __A (     )						->						Optional[Any]:
				return set_verbosity(a_)

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 (     a_  :logging.Handler)						->						None:
				_configure_library_root_logger()

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

def       __A (     a_  :logging.Handler)						->						None:
				_configure_library_root_logger()

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

def       __A (     )						->						None:
				_configure_library_root_logger()
				__a	:  Union[str, Any]         =					False

def       __A (     )						->						None:
				_configure_library_root_logger()
				__a	:  List[str]         =					True

def       __A (     )						->						None:
				__a	:  Optional[int]         =					_get_library_root_logger().handlers

				for handler in handlers:
								__a	:  Optional[Any]         =					logging.Formatter('''[%(levelname)s|%(filename)s:%(lineno)s] %(asctime)s >> %(message)s''')
								handler.setFormatter(a_)

def       __A (     )						->						None:
				__a	:  List[Any]         =					_get_library_root_logger().handlers

				for handler in handlers:
								handler.setFormatter(a_)

def       __A (     self  :Dict				,    *a_  :int				,    **a_  :List[str])						->						List[str]:
				__a	:  Any         =					os.getenv('''TRANSFORMERS_NO_ADVISORY_WARNINGS'''				,    a_)
				if no_advisory_warnings:
								return
				self.warning(*a_				,    **a_)


A	     =					warning_advice

@functools.lru_cache(a_)
def       __A (     self  :Dict				,    *a_  :Tuple				,    **a_  :Union[str, Any])						->						List[Any]:
				self.warning(*a_				,    **a_)


A	     =					warning_once




class 			__lowercase     :







					'''simple docstring'''




					def __init__(  self		,     *_UpperCAmelCase		,     **_UpperCAmelCase       ):  # pylint: disable=unused-argument
									__a	:  List[Any]         =					args[0] if args else None







					def __iter__(  self       ):
									return iter(self._iterator       )







					def __getattr__(  self		,     _UpperCAmelCase       ):

									def empty_fn(*_UpperCAmelCase		,     **_UpperCAmelCase       ):  # pylint: disable=unused-argument
													return

									return empty_fn







					def __enter__(  self       ):
									return self







					def __exit__(  self		,     _UpperCAmelCase		,     _UpperCAmelCase		,     _UpperCAmelCase       ):
									return






class 			__lowercase     :







					'''simple docstring'''




					def __call__(  self		,     *_UpperCAmelCase		,     **_UpperCAmelCase       ):
									if _tqdm_active:
													return tqdm_lib.tqdm(*_UpperCAmelCase		,     **_UpperCAmelCase       )
									else:
													return EmptyTqdm(*_UpperCAmelCase		,     **_UpperCAmelCase       )







					def 	_lowerCamelCase						(  self		,     *_UpperCAmelCase		,     **_UpperCAmelCase       ):
									__a	:  Optional[Any]         =					None
									if _tqdm_active:
													return tqdm_lib.tqdm.set_lock(*_UpperCAmelCase		,     **_UpperCAmelCase       )







					def 	_lowerCamelCase						(  self       ):
									if _tqdm_active:
													return tqdm_lib.tqdm.get_lock()






A	     =					_tqdm_cls()

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

def       __A (     )						->						str:
				global _tqdm_active
				__a	:  int         =					True
				hf_hub_utils.enable_progress_bars()






def       __A (     )						->						Tuple:
				global _tqdm_active
				__a	:  Optional[Any]         =					False
				hf_hub_utils.disable_progress_bars()






"""simple docstring"""






def       __A (     a_  :int				,    a_  :int)						->						str:
				if a < 0 or b < 0:
								raise ValueError('''the value of both inputs must be positive''')

				__a	:  Union[str, Any]         =					str(bin(a_))[2:]  # remove the leading "0b"
				__a	:  Union[str, Any]         =					str(bin(a_))[2:]  # remove the leading "0b"

				__a	:  Optional[Any]         =					max(len(a_)				,    len(a_))

				return "0b" + "".join(
				    str(int(char_a != char_b))
				    for char_a, char_b in zip(a_binary.zfill(a_)				,    b_binary.zfill(a_)))


if __name__ == "__main__":
		import doctest

		doctest.testmod()