



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     :Union[str, Any]			       ={
    'debug': logging.DEBUG,
    'info': logging.INFO,
    'warning': logging.WARNING,
    'error': logging.ERROR,
    'critical': logging.CRITICAL,
}

__snake_case     :List[Any]			       =logging.WARNING






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

							'''simple docstring'''






							A      						=    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  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'''






							A      						=    _get_library_root_logger()
							library_root_logger.setLevel(_get_default_logging_level()				)






def  lowerCamelCase_	(      )       ->							None:

							'''simple docstring'''






							A      						=    _get_library_root_logger()
							library_root_logger.setLevel(logging.NOTSET				)






def  lowerCamelCase_	(      lowerCAmelCase__	:	Optional[str] = None				)       ->							logging.Logger:

							'''simple docstring'''






							if name is None:
														A      						=    _get_library_name()
							return logging.getLogger(lowerCAmelCase__				)






def  lowerCamelCase_	(      )       ->							int:

							'''simple docstring'''






							return _get_library_root_logger().getEffectiveLevel()






def  lowerCamelCase_	(      lowerCAmelCase__	:	int				)       ->							None:

							'''simple docstring'''






							_get_library_root_logger().setLevel(lowerCAmelCase__				)






def  lowerCamelCase_	(      )       ->							List[Any]:

							'''simple docstring'''






							return set_verbosity(lowerCAmelCase__				)






def  lowerCamelCase_	(      )       ->							List[Any]:

							'''simple docstring'''






							return set_verbosity(lowerCAmelCase__				)






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

							'''simple docstring'''






							return set_verbosity(lowerCAmelCase__				)






def  lowerCamelCase_	(      )       ->							Optional[int]:

							'''simple docstring'''






							return set_verbosity(lowerCAmelCase__				)






def  lowerCamelCase_	(      )       ->							None:

							'''simple docstring'''






							A      						=    False






def  lowerCamelCase_	(      )       ->							None:

							'''simple docstring'''






							A      						=    True


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



class        lowerCAmelCase__					:


				def __init__(							self      :  Optional[int]						, *__UpperCamelCase      :  Tuple						, **__UpperCamelCase      :  List[Any]       )		->     Any:  # pylint: disable=unused-argument
											A      						=    args[0] if args else None


				def __iter__(							self      :  List[Any]       )		->     str:
											return iter(self._iterator       )


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

											def empty_fn(*__UpperCamelCase      :  Optional[Any]						, **__UpperCamelCase      :  int       ):  # pylint: disable=unused-argument
																		return

											return empty_fn


				def __enter__(							self      :  Any       )		->     Optional[Any]:
											return self


				def __exit__(							self      :  Tuple						, __UpperCamelCase      :  List[str]						, __UpperCamelCase      :  Optional[int]						, __UpperCamelCase      :  Any       )		->     str:
											return





__snake_case     :Tuple			       =True



class        lowerCAmelCase__					:


				def __call__(							self      :  List[Any]						, *__UpperCamelCase      :  List[Any]						, __UpperCamelCase      :  Tuple=False						, **__UpperCamelCase      :  str       )		->     Union[str, Any]:
											if _tqdm_active and not disable:
																		return tqdm_lib.tqdm(*__UpperCamelCase						, **__UpperCamelCase       )
											else:
																		return EmptyTqdm(*__UpperCamelCase						, **__UpperCamelCase       )


				def __UpperCamelCase						(							self      :  List[Any]						, *__UpperCamelCase      :  Tuple						, **__UpperCamelCase      :  int       )		->     Optional[int]:
											A      						=    None
											if _tqdm_active:
																		return tqdm_lib.tqdm.set_lock(*__UpperCamelCase						, **__UpperCamelCase       )


				def __UpperCamelCase						(							self      :  int       )		->     Tuple:
											if _tqdm_active:
																		return tqdm_lib.tqdm.get_lock()





__snake_case     :int			       =_tqdm_cls()






def  lowerCamelCase_	(      )       ->							bool:

							'''simple docstring'''






							global _tqdm_active
							return bool(_tqdm_active				)






def  lowerCamelCase_	(      )       ->							Tuple:

							'''simple docstring'''






							global _tqdm_active
							A      						=    True






def  lowerCamelCase_	(      )       ->							Dict:

							'''simple docstring'''






							global _tqdm_active
							A      						=    False




import re






def  lowerCamelCase_	(      lowerCAmelCase__	:	str				)       ->							str:

							'''simple docstring'''






							if len(re.findall('[ATCG]'			,	lowerCAmelCase__				)				) != len(lowerCAmelCase__				):
														raise ValueError('Invalid Strand'				)

							return dna.translate(dna.maketrans('ATCG'			,	'TAGC'				)				)


if __name__ == "__main__":
				import doctest

				doctest.testmod()