






import copy
import random

from transformers import CLIPTokenizer


class 			SCREAMING_SNAKE_CASE      (      _lowerCAmelCase       ):
     '''simple docstring'''


     def __init__(					self							:						Tuple       ,			*UpperCAmelCase_							:						Optional[int]       ,			**UpperCAmelCase_							:						Optional[Any]   ):
       super().__init__(*UpperCAmelCase_       ,			**UpperCAmelCase_   )
       SCREAMING_SNAKE_CASE							:   Union[str, Any]						    =     {}


     def 					_A							(					self							:						Tuple       ,			UpperCAmelCase_							:						Union[str, Any]       ,			*UpperCAmelCase_							:						Tuple       ,			**UpperCAmelCase_							:						Any   ):
       SCREAMING_SNAKE_CASE							:   List[Any]						    =     super().add_tokens(UpperCAmelCase_       ,			*UpperCAmelCase_       ,			**UpperCAmelCase_   )
       if num_added_tokens == 0:
         raise ValueError(
             f'''The tokenizer already contains the token {placeholder_token}. Please pass a different'''
             " `placeholder_token` that is not already in the tokenizer."   )


     def 					_A							(					self							:						List[str]       ,			UpperCAmelCase_							:						Dict       ,			*UpperCAmelCase_							:						int       ,			UpperCAmelCase_							:						int=1       ,			**UpperCAmelCase_							:						Tuple   ):
       SCREAMING_SNAKE_CASE							:   str						    =     []
       if num_vec_per_token == 1:
         self.try_adding_tokens(UpperCAmelCase_       ,			*UpperCAmelCase_       ,			**UpperCAmelCase_   )
         output.append(UpperCAmelCase_   )
       else:
         SCREAMING_SNAKE_CASE							:   Tuple						    =     []
         for i in range(UpperCAmelCase_   ):
           SCREAMING_SNAKE_CASE							:   List[Any]						    =     placeholder_token + f'''_{i}'''
           self.try_adding_tokens(UpperCAmelCase_       ,			*UpperCAmelCase_       ,			**UpperCAmelCase_   )
           output.append(UpperCAmelCase_   )
        # handle cases where there is a new placeholder token that contains the current placeholder token but is larger
       for token in self.token_map:
         if token in placeholder_token:
           raise ValueError(
               f'''The tokenizer already has placeholder token {token} that can get confused with'''
               f''' {placeholder_token}keep placeholder tokens independent'''   )
       SCREAMING_SNAKE_CASE							:   Any						    =     output


     def 					_A							(					self							:						Tuple       ,			UpperCAmelCase_							:						str       ,			UpperCAmelCase_							:						Tuple=False       ,			UpperCAmelCase_							:						Union[str, Any]=1.0   ):
       if isinstance(UpperCAmelCase_       ,			UpperCAmelCase_   ):
         SCREAMING_SNAKE_CASE							:   Dict						    =     []
         for i in range(len(UpperCAmelCase_   )   ):
           output.append(self.replace_placeholder_tokens_in_text(text[i]       ,			vector_shuffle=UpperCAmelCase_   )   )
         return output
       for placeholder_token in self.token_map:
         if placeholder_token in text:
           SCREAMING_SNAKE_CASE							:   Tuple						    =     self.token_map[placeholder_token]
           SCREAMING_SNAKE_CASE							:   Union[str, Any]						    =     tokens[: 1 + int(len(UpperCAmelCase_   ) * prop_tokens_to_load   )]
           if vector_shuffle:
             SCREAMING_SNAKE_CASE							:   List[str]						    =     copy.copy(UpperCAmelCase_   )
             random.shuffle(UpperCAmelCase_   )
           SCREAMING_SNAKE_CASE							:   int						    =     text.replace(UpperCAmelCase_       ,			" ".join(UpperCAmelCase_   )   )
       return text


     def __call__(					self							:						Optional[Any]       ,			UpperCAmelCase_							:						str       ,			*UpperCAmelCase_							:						str       ,			UpperCAmelCase_							:						int=False       ,			UpperCAmelCase_							:						Union[str, Any]=1.0       ,			**UpperCAmelCase_							:						Optional[Any]   ):
       return super().__call__(
           self.replace_placeholder_tokens_in_text(
               UpperCAmelCase_       ,			vector_shuffle=UpperCAmelCase_       ,			prop_tokens_to_load=UpperCAmelCase_   )       ,			*UpperCAmelCase_       ,			**UpperCAmelCase_       ,			)






     def 					_A							(					self							:						Optional[int]       ,			UpperCAmelCase_							:						Optional[int]       ,			*UpperCAmelCase_							:						Optional[Any]       ,			UpperCAmelCase_							:						Union[str, Any]=False       ,			UpperCAmelCase_							:						Tuple=1.0       ,			**UpperCAmelCase_							:						Optional[Any]   ):
       return super().encode(
           self.replace_placeholder_tokens_in_text(
               UpperCAmelCase_       ,			vector_shuffle=UpperCAmelCase_       ,			prop_tokens_to_load=UpperCAmelCase_   )       ,			*UpperCAmelCase_       ,			**UpperCAmelCase_       ,			)














'''simple docstring'''



def  __UpperCAmelCase						(					SCREAMING_SNAKE_CASE__:						str     )	->      bool:

   """simple docstring"""
   if not all(x.isalpha() for x in string     ):
      raise ValueError('String must only contain alphabetic characters.'     )

   __a					  =     sorted(string.lower()     )
   return len(SCREAMING_SNAKE_CASE__     ) == len(set(SCREAMING_SNAKE_CASE__     )     )


if __name__ == "__main__":
 __UpperCamelCase   :							int         =   input("""Enter a string """).strip()

 __UpperCamelCase   :							Tuple         =   is_isogram(input_str)
 print(f"""{input_str} is {"an" if isogram else "not an"} isogram.""")