



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


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

snake_case   					=				logging.WARNING




def 			snake_case		(		)						->				Optional[int]:
  _snake_case   	=      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 			snake_case		(		)						->				str:
  return __name__.split('''.'''	)[0]




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




def 			snake_case		(		)						->				None:
  # Apply our default configuration to the library root logger.
  _snake_case   	=      _get_library_root_logger()
  library_root_logger.setLevel(_get_default_logging_level()	)




def 			snake_case		(		)						->				None:
  _snake_case   	=      _get_library_root_logger()
  library_root_logger.setLevel(logging.NOTSET	)




def 			snake_case		(		lowerCAmelCase_ = None	)						->				logging.Logger:
  if name is None:
    _snake_case   	=      _get_library_name()
  return logging.getLogger(lowerCAmelCase_	)




def 			snake_case		(		)						->				int:
  return _get_library_root_logger().getEffectiveLevel()




def 			snake_case		(		lowerCAmelCase_	)						->				None:
  _get_library_root_logger().setLevel(lowerCAmelCase_	)




def 			snake_case		(		)						->				Tuple:
  return set_verbosity(lowerCAmelCase_	)




def 			snake_case		(		)						->				str:
  return set_verbosity(lowerCAmelCase_	)




def 			snake_case		(		)						->				Union[str, Any]:
  return set_verbosity(lowerCAmelCase_	)




def 			snake_case		(		)						->				Any:
  return set_verbosity(lowerCAmelCase_	)




def 			snake_case		(		)						->				None:
  _snake_case   	=      False




def 			snake_case		(		)						->				None:
  _snake_case   	=      True


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



class     UpperCAmelCase    :



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



     """simple docstring"""
     _snake_case   	=      args[0] if args else None



   def __iter__(       self    :	Dict				):



     """simple docstring"""
     return iter(self._iterator				)



   def __getattr__(       self    :	Optional[int]							,       __lowerCamelCase    :	Tuple				):



     """simple docstring"""

     def empty_fn(*__lowerCamelCase    :	Any							,       **__lowerCamelCase    :	Union[str, Any]				):  # pylint: disable=unused-argument
       return

     return empty_fn



   def __enter__(       self    :	int				):



     """simple docstring"""
     return self





   def __exit__(       self    :	Union[str, Any]							,       __lowerCamelCase    :	List[Any]							,       __lowerCamelCase    :	List[Any]							,       __lowerCamelCase    :	Dict				):



     """simple docstring"""
     return

snake_case   					=				True



class     UpperCAmelCase    :



   def __call__(       self    :	Union[str, Any]							,       *__lowerCamelCase    :	Dict							,       __lowerCamelCase    :	List[Any]=False							,       **__lowerCamelCase    :	Union[str, Any]				):



     """simple docstring"""
     if _tqdm_active and not disable:
       return tqdm_lib.tqdm(*__lowerCamelCase							,       **__lowerCamelCase				)
     else:
       return EmptyTqdm(*__lowerCamelCase							,       **__lowerCamelCase				)



   def    __UpperCAmelCase    (       self    :	Dict							,       *__lowerCamelCase    :	Any							,       **__lowerCamelCase    :	Union[str, Any]				):



     """simple docstring"""
     _snake_case   	=      None
     if _tqdm_active:
       return tqdm_lib.tqdm.set_lock(*__lowerCamelCase							,       **__lowerCamelCase				)





   def    __UpperCAmelCase    (       self    :	Optional[int]				):



     """simple docstring"""
     if _tqdm_active:
       return tqdm_lib.tqdm.get_lock()

snake_case   					=				_tqdm_cls()




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




def 			snake_case		(		)						->				Dict:
  global _tqdm_active
  _snake_case   	=      True







def 			snake_case		(		)						->				List[Any]:
  global _tqdm_active
  _snake_case   	=      False










"""simple docstring"""






def 			snake_case		(		lowerCAmelCase_  ,						lowerCAmelCase_	)						->				int:
  return 1 if input_a == input_a else 0




def 			snake_case		(		)						->				None:
  assert xnor_gate(0  ,						0	) == 1
  assert xnor_gate(0  ,						1	) == 0
  assert xnor_gate(1  ,						0	) == 0
  assert xnor_gate(1  ,						1	) == 1


if __name__ == "__main__":
     print(xnor_gate(0, 0))
     print(xnor_gate(0, 1))
     print(xnor_gate(1, 0))
     print(xnor_gate(1, 1))





