


'''simple docstring'''

from typing import Optional, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature
from ...image_transforms import get_image_size, pad, rescale, to_channel_dimension_format
from ...image_utils import ChannelDimension, ImageInput, make_list_of_images, to_numpy_array, valid_images
from ...utils import TensorType, logging


lowerCAmelCase				:Optional[Any]        =      logging.get_logger(__name__)
class _lowerCamelCase	(						lowercase__							):



		'''simple docstring'''







		A_     :      Optional[int]				   =    ["""pixel_values"""]







		def __init__( self		:						int  ,					_A		:						bool = True  ,					_A		:						Union[int, float] = 1 / 255  ,					_A		:						bool = True  ,					_A		:						int = 8  ,					**_A		:						List[str]  ,					)  ->			None:
			super().__init__(**_A      )

			__magic_name__	:   Optional[int]					     =					do_rescale
			__magic_name__	:   str					     =					rescale_factor
			__magic_name__	:   int					     =					do_pad
			__magic_name__	:   List[Any]					     =					pad_size







		def        __lowerCAmelCase		( self		:						List[Any]  ,					_A		:						np.ndarray  ,					_A		:						float  ,					_A		:						Optional[Union[str, ChannelDimension]] = None  ,					**_A		:						str      )  ->			np.ndarray:
			return rescale(_A  ,					scale=_A  ,					data_format=_A  ,					**_A      )







		def        __lowerCAmelCase		( self		:						Tuple  ,					_A		:						np.ndarray  ,					_A		:						int  ,					_A		:						Optional[Union[str, ChannelDimension]] = None      )  ->			Dict:
			__magic_name__	:   int					     =					get_image_size(_A      )
			__magic_name__	:   Optional[Any]					     =					(old_height // size + 1) * size - old_height
			__magic_name__	:   int					     =					(old_width // size + 1) * size - old_width

			return pad(_A  ,					((0, pad_height), (0, pad_width))  ,					mode='symmetric'  ,					data_format=_A      )







		def        __lowerCAmelCase		( self		:						Optional[Any]  ,					_A		:						ImageInput  ,					_A		:						Optional[bool] = None  ,					_A		:						Optional[float] = None  ,					_A		:						Optional[bool] = None  ,					_A		:						Optional[int] = None  ,					_A		:						Optional[Union[str, TensorType]] = None  ,					_A		:						Union[str, ChannelDimension] = ChannelDimension.FIRST  ,					**_A		:						List[Any]  ,					)  ->			Any:
			__magic_name__	:   Optional[Any]					     =					do_rescale if do_rescale is not None else self.do_rescale
			__magic_name__	:   List[Any]					     =					rescale_factor if rescale_factor is not None else self.rescale_factor
			__magic_name__	:   Dict					     =					do_pad if do_pad is not None else self.do_pad
			__magic_name__	:   Any					     =					pad_size if pad_size is not None else self.pad_size

			__magic_name__	:   List[str]					     =					make_list_of_images(_A      )

			if not valid_images(_A      ):
				raise ValueError(
				    'Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, '
				    'torch.Tensor, tf.Tensor or jax.ndarray.'      )

			if do_rescale and rescale_factor is None:
				raise ValueError('Rescale factor must be specified if do_rescale is True.'      )

			# All transformations expect numpy arrays.
			__magic_name__	:   str					     =					[to_numpy_array(_A      ) for image in images]

			if do_rescale:
				__magic_name__	:   Optional[int]					     =					[self.rescale(image=_A  ,					scale=_A      ) for image in images]

			if do_pad:
				__magic_name__	:   Optional[Any]					     =					[self.pad(_A  ,					size=_A      ) for image in images]

			__magic_name__	:   Union[str, Any]					     =					[to_channel_dimension_format(_A  ,					_A      ) for image in images]

			__magic_name__	:   List[Any]					     =					{'pixel_values': images}
			return BatchFeature(data=_A  ,					tensor_type=_A      )



'''simple docstring'''

def lowerCamelCase      (      lowerCAmelCase    :     str		):





	"""simple docstring"""







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

	__magic_name__	:   int					     =					sorted(string.lower()		)
	return len(lowerCAmelCase		) == len(set(lowerCAmelCase		)		)


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

							lowerCAmelCase				:List[Any]        =      is_isogram(input_str)
							print(F'{input_str} is {"an" if isogram else "not an"} isogram.')