





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 	lowerCAmelCase_					(			)	->						List[str]:







  """simple docstring"""





  lowerCamelCase__: Optional[Any]         =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 	lowerCAmelCase_					(			)	->						str:







  """simple docstring"""





  return __name__.split("."						)[0]





def 	lowerCAmelCase_					(			)	->						logging.Logger:







  """simple docstring"""





  return logging.getLogger(_get_library_name()						)





def 	lowerCAmelCase_					(			)	->						None:







  """simple docstring"""





  global _default_handler

  with _lock:
    if _default_handler:
      # This library has already configured the library root logger.
      return
    lowerCamelCase__: Dict         =logging.StreamHandler()  # Set sys.stderr as stream.
    lowerCamelCase__: str         =sys.stderr.flush

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





def 	lowerCAmelCase_					(			)	->						None:







  """simple docstring"""





  global _default_handler

  with _lock:
    if not _default_handler:
      return

    lowerCamelCase__: Optional[Any]         =_get_library_root_logger()
    library_root_logger.removeHandler(_default_handler						)
    library_root_logger.setLevel(logging.NOTSET						)
    lowerCamelCase__: Dict         =None





def 	lowerCAmelCase_					(			)	->						List[Any]:







  """simple docstring"""





  return log_levels





def 	lowerCAmelCase_					(			__a = None						)	->						logging.Logger:







  """simple docstring"""





  if name is None:
    lowerCamelCase__: Any         =_get_library_name()

  _configure_library_root_logger()
  return logging.getLogger(__a						)





def 	lowerCAmelCase_					(			)	->						int:







  """simple docstring"""





  _configure_library_root_logger()
  return _get_library_root_logger().getEffectiveLevel()





def 	lowerCAmelCase_					(			__a						)	->						None:







  """simple docstring"""





  _configure_library_root_logger()
  _get_library_root_logger().setLevel(__a						)





def 	lowerCAmelCase_					(			)	->						Optional[int]:







  """simple docstring"""





  return set_verbosity(__a						)





def 	lowerCAmelCase_					(			)	->						Dict:







  """simple docstring"""





  return set_verbosity(__a						)





def 	lowerCAmelCase_					(			)	->						Optional[Any]:







  """simple docstring"""





  return set_verbosity(__a						)





def 	lowerCAmelCase_					(			)	->						Any:







  """simple docstring"""





  return set_verbosity(__a						)





def 	lowerCAmelCase_					(			)	->						None:







  """simple docstring"""





  _configure_library_root_logger()

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





def 	lowerCAmelCase_					(			)	->						None:







  """simple docstring"""





  _configure_library_root_logger()

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





def 	lowerCAmelCase_					(			__a						)	->						None:







  """simple docstring"""





  _configure_library_root_logger()

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





def 	lowerCAmelCase_					(			__a						)	->						None:







  """simple docstring"""





  _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 	lowerCAmelCase_					(			)	->						None:







  """simple docstring"""





  _configure_library_root_logger()
  lowerCamelCase__: Union[str, Any]         =False





def 	lowerCAmelCase_					(			)	->						None:







  """simple docstring"""





  _configure_library_root_logger()
  lowerCamelCase__: Optional[Any]         =True





def 	lowerCAmelCase_					(			)	->						None:







  """simple docstring"""





  lowerCamelCase__: str         =_get_library_root_logger().handlers

  for handler in handlers:
    lowerCamelCase__: Union[str, Any]         =logging.Formatter("[%(levelname)s|%(filename)s:%(lineno)s] %(asctime)s >> %(message)s"						)
    handler.setFormatter(__a						)





def 	lowerCAmelCase_					(			)	->						None:







  """simple docstring"""





  lowerCamelCase__: Optional[int]         =_get_library_root_logger().handlers

  for handler in handlers:
    handler.setFormatter(__a						)





def 	lowerCAmelCase_					(			self      ,       *__a      ,       **__a						)	->						int:







  """simple docstring"""





  lowerCamelCase__: List[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 	lowerCAmelCase_					(			self      ,       *__a      ,       **__a						)	->						str:







  """simple docstring"""





  self.warning(*__a      ,       **__a						)


__A							   =							warning_once



class   _SCREAMING_SNAKE_CASE		:







 '''simple docstring'''

 def __init__(self							:  Dict			,					*UpperCAmelCase_							:  Tuple			,					**UpperCAmelCase_							:  Union[str, Any])			->Any:  # pylint: disable=unused-argument



   '''simple docstring'''



   lowerCamelCase__: Tuple         =args[0] if args else None

 def __iter__(self							:  Any)			->List[str]:



   '''simple docstring'''



   return iter(self._iterator)

 def __getattr__(self							:  Optional[Any]			,					UpperCAmelCase_							:  List[str])			->Dict:



   '''simple docstring'''



   def empty_fn(*UpperCAmelCase_							:  Any			,					**UpperCAmelCase_							:  List[Any]):  # pylint: disable=unused-argument
     return

   return empty_fn

 def __enter__(self							:  Union[str, Any])			->List[Any]:



   '''simple docstring'''



   return self







 def __exit__(self							:  List[str]			,					UpperCAmelCase_							:  List[str]			,					UpperCAmelCase_							:  Optional[int]			,					UpperCAmelCase_							:  Any)			->Dict:



   '''simple docstring'''



   return



class   _SCREAMING_SNAKE_CASE		:







 '''simple docstring'''

 def __call__(self							:  Dict			,					*UpperCAmelCase_							:  Union[str, Any]			,					**UpperCAmelCase_							:  List[Any])			->List[str]:



   '''simple docstring'''



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

 def 				SCREAMING_SNAKE_CASE_   (self							:  Optional[int]			,					*UpperCAmelCase_							:  Union[str, Any]			,					**UpperCAmelCase_							:  int)			->Tuple:



   '''simple docstring'''



   lowerCamelCase__: Tuple         =None
   if _tqdm_active:
     return tqdm_lib.tqdm.set_lock(*UpperCAmelCase_			,					**UpperCAmelCase_)







 def 				SCREAMING_SNAKE_CASE_   (self							:  Optional[int])			->Tuple:



   '''simple docstring'''



   if _tqdm_active:
     return tqdm_lib.tqdm.get_lock()



__A							   =							_tqdm_cls()





def 	lowerCAmelCase_					(			)	->						bool:







  """simple docstring"""





  global _tqdm_active
  return bool(_tqdm_active						)





def 	lowerCAmelCase_					(			)	->						List[Any]:







  """simple docstring"""





  global _tqdm_active
  lowerCamelCase__: str         =True
  hf_hub_utils.enable_progress_bars()






def 	lowerCAmelCase_					(			)	->						Optional[int]:







  """simple docstring"""





  global _tqdm_active
  lowerCamelCase__: Dict         =False
  hf_hub_utils.disable_progress_bars()









lowerCamelCase__       		=  8.3_1_4_4_5_9_8






def 	UpperCamelCase	(							snake_case__  : float						,snake_case__  : float	):




     '''simple docstring'''






     if temperature < 0:
          raise Exception("""Temperature cannot be less than 0 K"""	)
     if molar_mass <= 0:
          raise Exception("""Molar mass cannot be less than or equal to 0 kg/mol"""	)
     else:
          return (3 * UNIVERSAL_GAS_CONSTANT * temperature / molar_mass) ** 0.5


if __name__ == "__main__":
     import doctest

     # run doctest
     doctest.testmod()

     # example
     lowerCamelCase__       		=  300
     lowerCamelCase__       		=  28
     lowerCamelCase__       		=  rms_speed_of_molecule(temperature, molar_mass)
     print(f'''Vrms of Nitrogen gas at 300 K is {vrms} m/s''')


