





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


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

lowercase__		:     Dict			=							logging.WARNING







def    a__							(							)						->						int:





     """simple docstring"""

     _UpperCamelCase							       =			os.getenv('''DATASETS_VERBOSITY''',   lowercase )
     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    a__							(							)						->						str:





     """simple docstring"""

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







def    a__							(							)						->						logging.Logger:





     """simple docstring"""

     return logging.getLogger(_get_library_name() )







def    a__							(							)						->						None:





     """simple docstring"""

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







def    a__							(							)						->						None:





     """simple docstring"""

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







def    a__							(							lowercase   :	Optional[str] = None )						->						logging.Logger:





     """simple docstring"""

     if name is None:
          _UpperCamelCase							       =			_get_library_name()
     return logging.getLogger(lowercase )







def    a__							(							)						->						int:





     """simple docstring"""

     return _get_library_root_logger().getEffectiveLevel()







def    a__							(							lowercase   :	int )						->						None:





     """simple docstring"""

     _get_library_root_logger().setLevel(lowercase )







def    a__							(							)						->						Tuple:





     """simple docstring"""

     return set_verbosity(lowercase )







def    a__							(							)						->						Optional[int]:





     """simple docstring"""

     return set_verbosity(lowercase )







def    a__							(							)						->						Tuple:





     """simple docstring"""

     return set_verbosity(lowercase )







def    a__							(							)						->						int:





     """simple docstring"""

     return set_verbosity(lowercase )







def    a__							(							)						->						None:





     """simple docstring"""

     _UpperCamelCase							       =			False







def    a__							(							)						->						None:





     """simple docstring"""

     _UpperCamelCase							       =			True


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






       """simple docstring"""





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

            '''simple docstring'''




            _UpperCamelCase							       =			args[0] if args else None





       def __iter__(				self  :						str	)       ->	Optional[int]:

            '''simple docstring'''




            return iter(self._iterator	)





       def __getattr__(				self  :						Any			,					lowerCAmelCase__  :						Union[str, Any]	)       ->	Any:

            '''simple docstring'''




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

            return empty_fn





       def __enter__(				self  :						Tuple	)       ->	Any:

            '''simple docstring'''




            return self







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

            '''simple docstring'''




            return

lowercase__		:     str			=							True
class 							__lowerCAmelCase	:






       """simple docstring"""





       def __call__(				self  :						str			,					*lowerCAmelCase__  :						List[str]			,					lowerCAmelCase__  :						Optional[Any]=False			,					**lowerCAmelCase__  :						Optional[Any]	)       ->	List[Any]:

            '''simple docstring'''




            if _tqdm_active and not disable:
                 return tqdm_lib.tqdm(*lowerCAmelCase__			,					**lowerCAmelCase__	)
            else:
                 return EmptyTqdm(*lowerCAmelCase__			,					**lowerCAmelCase__	)





       def snake_case__		(				self  :						str			,					*lowerCAmelCase__  :						List[str]			,					**lowerCAmelCase__  :						Tuple	)       ->	int:

            '''simple docstring'''




            _UpperCamelCase							       =			None
            if _tqdm_active:
                 return tqdm_lib.tqdm.set_lock(*lowerCAmelCase__			,					**lowerCAmelCase__	)







       def snake_case__		(				self  :						int	)       ->	Union[str, Any]:

            '''simple docstring'''




            if _tqdm_active:
                 return tqdm_lib.tqdm.get_lock()

lowercase__		:     List[Any]			=							_tqdm_cls()







def    a__							(							)						->						bool:





     """simple docstring"""

     global _tqdm_active
     return bool(_tqdm_active )







def    a__							(							)						->						Tuple:





     """simple docstring"""

     global _tqdm_active
     _UpperCamelCase							       =			True







def    a__							(							)						->						Optional[Any]:





     """simple docstring"""

     global _tqdm_active
     _UpperCamelCase							       =			False








'''simple docstring'''

def 	__lowerCamelCase	( lowerCAmelCase_    )     -> bool:
		if not all(x.isalpha() for x in string    ):
				raise ValueError('String must only contain alphabetic characters.'    )

		_a	: Tuple								=				sorted(string.lower()    )
		return len(lowerCAmelCase_    ) == len(set(lowerCAmelCase_    )    )


if __name__ == "__main__":
							__lowerCAmelCase		     =  input('''Enter a string ''').strip()

							__lowerCAmelCase		     =  is_isogram(input_str)
							print(f"""{input_str} is {'an' if isogram else 'not an'} isogram.""")




