'''simple docstring'''




import logging
import os
from logging import (
    CRITICAL,  # NOQA
    DEBUG,  # NOQA
    ERROR,  # NOQA
    FATAL,  # NOQA
    INFO,  # NOQA
    NOTSET,  # NOQA
    WARN,  # NOQA
    WARNING,  # NOQA
)
from typing import Optional

from tqdm import auto as tqdm_lib


_a   :	Any 							=   {
    "debug": logging.DEBUG,
    "info": logging.INFO,
    "warning": logging.WARNING,
    "error": logging.ERROR,
    "critical": logging.CRITICAL,
}

_a   :	Optional[int] 							=   logging.WARNING

def _lowercase	(      )					->       str:





       """simple docstring"""


       __UpperCAmelCase  :				Union[str, Any]       				=		os.getenv("DATASETS_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 DATASETS_VERBOSITY={env_level_str}, """
                         f"""has to be one of: { ', '.join(log_levels.keys()						) }"""						)
       return _default_log_level

def _lowercase	(      )					->       str:





       """simple docstring"""


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

def _lowercase	(      )					->       logging.Logger:





       """simple docstring"""


       return logging.getLogger(_get_library_name()						)

def _lowercase	(      )					->       None:





       """simple docstring"""


       __UpperCAmelCase  :				List[str]       				=		_get_library_root_logger()
       library_root_logger.setLevel(_get_default_logging_level()						)

def _lowercase	(      )					->       None:





       """simple docstring"""


       __UpperCAmelCase  :				Dict       				=		_get_library_root_logger()
       library_root_logger.setLevel(logging.NOTSET						)

def _lowercase	(      lowerCamelCase__ = None						)					->       logging.Logger:





       """simple docstring"""


       if name is None:
              __UpperCAmelCase  :				Union[str, Any]       				=		_get_library_name()
       return logging.getLogger(lowerCamelCase__						)

def _lowercase	(      )					->       int:





       """simple docstring"""


       return _get_library_root_logger().getEffectiveLevel()

def _lowercase	(      lowerCamelCase__						)					->       None:





       """simple docstring"""


       _get_library_root_logger().setLevel(lowerCamelCase__						)

def _lowercase	(      )					->       Union[str, Any]:





       """simple docstring"""


       return set_verbosity(lowerCamelCase__						)

def _lowercase	(      )					->       List[Any]:





       """simple docstring"""


       return set_verbosity(lowerCamelCase__						)

def _lowercase	(      )					->       Optional[int]:





       """simple docstring"""


       return set_verbosity(lowerCamelCase__						)

def _lowercase	(      )					->       Dict:





       """simple docstring"""


       return set_verbosity(lowerCamelCase__						)

def _lowercase	(      )					->       None:





       """simple docstring"""


       __UpperCAmelCase  :				Dict       				=		False

def _lowercase	(      )					->       None:





       """simple docstring"""


       __UpperCAmelCase  :				Optional[Any]       				=		True


# Configure the library root logger at the module level (singleton-like)
_configure_library_root_logger()






class 		__A       :






       def __init__(      self				,     *UpperCamelCase_				,     **UpperCamelCase_      ):  # pylint: disable=unused-argument
              __UpperCAmelCase  :				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





_a   :	Optional[Any] 							=   True






class 		__A       :






       def __call__(      self				,     *UpperCamelCase_				,     UpperCamelCase_=False				,     **UpperCamelCase_      ):
              if _tqdm_active and not disable:
                     return tqdm_lib.tqdm(*UpperCamelCase_				,     **UpperCamelCase_      )
              else:
                     return EmptyTqdm(*UpperCamelCase_				,     **UpperCamelCase_      )






       def 			_snake_case						(      self				,     *UpperCamelCase_				,     **UpperCamelCase_      ):
              __UpperCAmelCase  :				Dict       				=		None
              if _tqdm_active:
                     return tqdm_lib.tqdm.set_lock(*UpperCamelCase_				,     **UpperCamelCase_      )







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





_a   :	List[str] 							=   _tqdm_cls()

def _lowercase	(      )					->       bool:





       """simple docstring"""


       global _tqdm_active
       return bool(_tqdm_active						)

def _lowercase	(      )					->       List[Any]:





       """simple docstring"""


       global _tqdm_active
       __UpperCAmelCase  :				Dict       				=		True


def _lowercase	(      )					->       Any:





       """simple docstring"""


       global _tqdm_active
       __UpperCAmelCase  :				List[Any]       				=		False







'''simple docstring'''




def _lowercase	(      lowerCamelCase__							,    lowerCamelCase__						)					->       int:





       """simple docstring"""


       return number | (1 << position)

def _lowercase	(      lowerCamelCase__							,    lowerCamelCase__						)					->       int:





       """simple docstring"""


       return number & ~(1 << position)

def _lowercase	(      lowerCamelCase__							,    lowerCamelCase__						)					->       int:





       """simple docstring"""


       return number ^ (1 << position)

def _lowercase	(      lowerCamelCase__							,    lowerCamelCase__						)					->       bool:





       """simple docstring"""


       return ((number >> position) & 1) == 1

def _lowercase	(      lowerCamelCase__							,    lowerCamelCase__						)					->       int:





       """simple docstring"""


       return int((number & (1 << position)) != 0						)


if __name__ == "__main__":
   import doctest

   doctest.testmod()






