



'''simple docstring'''

from collections import OrderedDict
from typing import Mapping

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


__lowerCAmelCase		     =  logging.get_logger(__name__)

__lowerCAmelCase		     =  {
    '''microsoft/beit-base-patch16-224-pt22k''': (
        '''https://huggingface.co/microsoft/beit-base-patch16-224-pt22k/resolve/main/config.json'''
    ),
    # See all BEiT models at https://huggingface.co/models?filter=beit
}

class       __magic_name__		(       _UpperCamelCase  ):
							lowerCAmelCase			:       int  							=   'beit'







							def __init__(				self   :			int      ,_UpperCAmelCase   :			int=8192      ,_UpperCAmelCase   :			Any=768      ,_UpperCAmelCase   :			Dict=12      ,_UpperCAmelCase   :			List[str]=12      ,_UpperCAmelCase   :			Any=3072      ,_UpperCAmelCase   :			List[str]="gelu"      ,_UpperCAmelCase   :			Optional[Any]=0.0      ,_UpperCAmelCase   :			str=0.0      ,_UpperCAmelCase   :			Tuple=0.02      ,_UpperCAmelCase   :			List[str]=1E-12      ,_UpperCAmelCase   :			Union[str, Any]=224      ,_UpperCAmelCase   :			List[Any]=16      ,_UpperCAmelCase   :			str=3      ,_UpperCAmelCase   :			Tuple=False      ,_UpperCAmelCase   :			Optional[Any]=False      ,_UpperCAmelCase   :			int=False      ,_UpperCAmelCase   :			int=False      ,_UpperCAmelCase   :			Optional[int]=0.1      ,_UpperCAmelCase   :			str=0.1      ,_UpperCAmelCase   :			Optional[int]=True      ,_UpperCAmelCase   :			List[Any]=[3, 5, 7, 11]      ,_UpperCAmelCase   :			Optional[int]=[1, 2, 3, 6]      ,_UpperCAmelCase   :			Union[str, Any]=True      ,_UpperCAmelCase   :			Optional[int]=0.4      ,_UpperCAmelCase   :			int=256      ,_UpperCAmelCase   :			Optional[int]=1      ,_UpperCAmelCase   :			str=False      ,_UpperCAmelCase   :			List[Any]=255      ,**_UpperCAmelCase   :			str      ,):
									super().__init__(**_UpperCAmelCase						)

									_a	: Tuple								=				vocab_size
									_a	: Union[str, Any]								=				hidden_size
									_a	: Tuple								=				num_hidden_layers
									_a	: Dict								=				num_attention_heads
									_a	: Tuple								=				intermediate_size
									_a	: str								=				hidden_act
									_a	: int								=				hidden_dropout_prob
									_a	: Optional[int]								=				attention_probs_dropout_prob
									_a	: int								=				initializer_range
									_a	: Optional[int]								=				layer_norm_eps

									_a	: Any								=				image_size
									_a	: Tuple								=				patch_size
									_a	: Tuple								=				num_channels
									_a	: Dict								=				use_mask_token
									_a	: Any								=				use_absolute_position_embeddings
									_a	: Optional[Any]								=				use_relative_position_bias
									_a	: str								=				use_shared_relative_position_bias
									_a	: int								=				layer_scale_init_value
									_a	: List[Any]								=				drop_path_rate
									_a	: List[str]								=				use_mean_pooling
									# decode head attributes (semantic segmentation)
									_a	: Union[str, Any]								=				out_indices
									_a	: Optional[Any]								=				pool_scales
									# auxiliary head attributes (semantic segmentation)
									_a	: str								=				use_auxiliary_head
									_a	: Dict								=				auxiliary_loss_weight
									_a	: Tuple								=				auxiliary_channels
									_a	: List[str]								=				auxiliary_num_convs
									_a	: Union[str, Any]								=				auxiliary_concat_input
									_a	: Optional[int]								=				semantic_loss_ignore_index

class       __magic_name__		(       _UpperCamelCase  ):
							lowerCAmelCase			:       Optional[int]  							=   version.parse('1.11'  )







							@property
							def 				__lowercase     (				self   :			Optional[int]						):
									return OrderedDict(
									    [
									        ('pixel_values', {0: 'batch', 1: 'num_channels', 2: 'height', 3: 'width'}),
									    ]						)







							@property
							def 				__lowercase     (				self   :			Optional[Any]						):
									return 1E-4









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




