



'''simple docstring'''

import warnings

from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding

class       __magic_name__		(       _UpperCamelCase  ):
							lowerCAmelCase			:       Optional[int]  							=   ['image_processor', 'tokenizer']
							lowerCAmelCase			:       Optional[Any]  							=   'CLIPImageProcessor'
							lowerCAmelCase			:       Union[str, Any]  							=   ('CLIPTokenizer', 'CLIPTokenizerFast')







							def __init__(				self   :			Optional[Any]      ,_UpperCAmelCase   :			Union[str, Any]=None      ,_UpperCAmelCase   :			Optional[Any]=None      ,**_UpperCAmelCase   :			List[Any]						):
									_a	: Dict								=				None
									if "feature_extractor" in kwargs:
											warnings.warn(
											    'The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`'
											    ' instead.'      ,_UpperCAmelCase      ,)
											_a	: Dict								=				kwargs.pop('feature_extractor'						)

									_a	: Optional[Any]								=				image_processor if image_processor is not None else feature_extractor
									if image_processor is None:
											raise ValueError('You need to specify an `image_processor`.'						)
									if tokenizer is None:
											raise ValueError('You need to specify a `tokenizer`.'						)

									super().__init__(_UpperCAmelCase      ,_UpperCAmelCase						)







							def __call__(				self   :			str      ,_UpperCAmelCase   :			int=None      ,_UpperCAmelCase   :			Optional[int]=None      ,_UpperCAmelCase   :			Optional[Any]=None      ,**_UpperCAmelCase   :			int						):

									if text is None and images is None:
											raise ValueError('You have to specify either text or images. Both cannot be none.'						)

									if text is not None:
											_a	: Optional[int]								=				self.tokenizer(_UpperCAmelCase      ,return_tensors=_UpperCAmelCase      ,**_UpperCAmelCase						)

									if images is not None:
											_a	: Any								=				self.image_processor(_UpperCAmelCase      ,return_tensors=_UpperCAmelCase      ,**_UpperCAmelCase						)

									if text is not None and images is not None:
											_a	: str								=				image_features.pixel_values
											return encoding
									elif text is not None:
											return encoding
									else:
											return BatchEncoding(data=dict(**_UpperCAmelCase						)      ,tensor_type=_UpperCAmelCase						)







							def 				__lowercase     (				self   :			Dict      ,*_UpperCAmelCase   :			List[str]      ,**_UpperCAmelCase   :			Optional[int]						):
									return self.tokenizer.batch_decode(*_UpperCAmelCase      ,**_UpperCAmelCase						)







							def 				__lowercase     (				self   :			Tuple      ,*_UpperCAmelCase   :			Optional[int]      ,**_UpperCAmelCase   :			Dict						):
									return self.tokenizer.decode(*_UpperCAmelCase      ,**_UpperCAmelCase						)







							@property
							def 				__lowercase     (				self   :			Dict						):
									_a	: Optional[Any]								=				self.tokenizer.model_input_names
									_a	: Dict								=				self.image_processor.model_input_names
									return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names						)						)







							@property
							def 				__lowercase     (				self   :			List[Any]						):
									warnings.warn(
									    '`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead.'      ,_UpperCAmelCase      ,)
									return self.image_processor_class







							@property
							def 				__lowercase     (				self   :			Any						):
									warnings.warn(
									    '`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead.'      ,_UpperCAmelCase      ,)
									return self.image_processor









'''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.""")




