



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


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

__lowerCAmelCase		     =  logging.WARNING



def 	__lowerCamelCase	( )     -> List[str]:
		_a	: List[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 	__lowerCamelCase	( )     -> str:
		return __name__.split('.'    )[0]



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



def 	__lowerCamelCase	( )     -> None:
		# Apply our default configuration to the library root logger.
		_a	: List[Any]								=				_get_library_root_logger()
		library_root_logger.setLevel(_get_default_logging_level()    )



def 	__lowerCamelCase	( )     -> None:
		_a	: Any								=				_get_library_root_logger()
		library_root_logger.setLevel(logging.NOTSET    )



def 	__lowerCamelCase	( lowerCAmelCase_ = None    )     -> logging.Logger:
		if name is None:
				_a	: Optional[Any]								=				_get_library_name()
		return logging.getLogger(lowerCAmelCase_    )



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



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



def 	__lowerCamelCase	( )     -> int:
		return set_verbosity(lowerCAmelCase_    )



def 	__lowerCamelCase	( )     -> Optional[Any]:
		return set_verbosity(lowerCAmelCase_    )



def 	__lowerCamelCase	( )     -> Optional[Any]:
		return set_verbosity(lowerCAmelCase_    )



def 	__lowerCamelCase	( )     -> Optional[int]:
		return set_verbosity(lowerCAmelCase_    )



def 	__lowerCamelCase	( )     -> None:
		_a	: Dict								=				False



def 	__lowerCamelCase	( )     -> None:
		_a	: Optional[Any]								=				True


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

class       __magic_name__		:







							def __init__(				self   :			Tuple      ,*_UpperCAmelCase   :			List[str]      ,**_UpperCAmelCase   :			Any						):  # pylint: disable=unused-argument
									_a	: Optional[Any]								=				args[0] if args else None







							def __iter__(				self   :			Dict						):
									return iter(self._iterator						)







							def __getattr__(				self   :			Any      ,_UpperCAmelCase   :			Any						):

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

									return empty_fn







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







							def __exit__(				self   :			Optional[int]      ,_UpperCAmelCase   :			int      ,_UpperCAmelCase   :			Optional[Any]      ,_UpperCAmelCase   :			int						):
									return
__lowerCAmelCase		     =  True

class       __magic_name__		:







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







							def 				__lowercase     (				self   :			Optional[int]      ,*_UpperCAmelCase   :			int      ,**_UpperCAmelCase   :			Optional[int]						):
									_a	: List[Any]								=				None
									if _tqdm_active:
											return tqdm_lib.tqdm.set_lock(*_UpperCAmelCase      ,**_UpperCAmelCase						)







							def 				__lowercase     (				self   :			Optional[Any]						):
									if _tqdm_active:
											return tqdm_lib.tqdm.get_lock()
__lowerCAmelCase		     =  _tqdm_cls()



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



def 	__lowerCamelCase	( )     -> str:
		global _tqdm_active
		_a	: Union[str, Any]								=				True



def 	__lowerCamelCase	( )     -> List[Any]:
		global _tqdm_active
		_a	: Union[str, Any]								=				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.""")




