from __future__ import annotations

import unittest

from transformers import DebertaVaConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
					import tensorflow as tf

					from transformers import (
					    TFDebertaVaForMaskedLM,
					    TFDebertaVaForQuestionAnswering,
					    TFDebertaVaForSequenceClassification,
					    TFDebertaVaForTokenClassification,
					    TFDebertaVaModel,
					)
class     lowerCAmelCase_     :







							def __init__(   self      :     Dict ,			_A      :     Optional[Any] ,			_A      :     Dict=13 ,			_A      :     int=7 ,			_A      :     List[str]=True ,			_A      :     Optional[int]=True ,			_A      :     Union[str, Any]=True ,			_A      :     Optional[Any]=True ,			_A      :     List[Any]=99 ,			_A      :     Any=32 ,			_A      :     Union[str, Any]=2 ,			_A      :     Optional[int]=4 ,			_A      :     int=37 ,			_A      :     Any="gelu" ,			_A      :     int=0.1 ,			_A      :     Dict=0.1 ,			_A      :     Any=512 ,			_A      :     List[Any]=16 ,			_A      :     Tuple=2 ,			_A      :     List[Any]=0.02 ,			_A      :     List[Any]=False ,			_A      :     int=True ,			_A      :     Union[str, Any]="None" ,			_A      :     Optional[Any]=3 ,			_A      :     Dict=4 ,			_A      :     Any=None ,			):
												_UpperCamelCase			     =     parent
												_UpperCamelCase			     =     batch_size
												_UpperCamelCase			     =     seq_length
												_UpperCamelCase			     =     is_training
												_UpperCamelCase			     =     use_input_mask
												_UpperCamelCase			     =     use_token_type_ids
												_UpperCamelCase			     =     use_labels
												_UpperCamelCase			     =     vocab_size
												_UpperCamelCase			     =     hidden_size
												_UpperCamelCase			     =     num_hidden_layers
												_UpperCamelCase			     =     num_attention_heads
												_UpperCamelCase			     =     intermediate_size
												_UpperCamelCase			     =     hidden_act
												_UpperCamelCase			     =     hidden_dropout_prob
												_UpperCamelCase			     =     attention_probs_dropout_prob
												_UpperCamelCase			     =     max_position_embeddings
												_UpperCamelCase			     =     type_vocab_size
												_UpperCamelCase			     =     type_sequence_label_size
												_UpperCamelCase			     =     initializer_range
												_UpperCamelCase			     =     num_labels
												_UpperCamelCase			     =     num_choices
												_UpperCamelCase			     =     relative_attention
												_UpperCamelCase			     =     position_biased_input
												_UpperCamelCase			     =     pos_att_type
												_UpperCamelCase			     =     scope







							def  UpperCamelCase_						(   self      :     Dict		):
												_UpperCamelCase			     =     ids_tensor([self.batch_size, self.seq_length] ,			self.vocab_size		)

												_UpperCamelCase			     =     None
												if self.use_input_mask:
																	_UpperCamelCase			     =     random_attention_mask([self.batch_size, self.seq_length]		)

												_UpperCamelCase			     =     None
												if self.use_token_type_ids:
																	_UpperCamelCase			     =     ids_tensor([self.batch_size, self.seq_length] ,			self.type_vocab_size		)

												_UpperCamelCase			     =     None
												_UpperCamelCase			     =     None
												_UpperCamelCase			     =     None
												if self.use_labels:
																	_UpperCamelCase			     =     ids_tensor([self.batch_size] ,			self.type_sequence_label_size		)
																	_UpperCamelCase			     =     ids_tensor([self.batch_size, self.seq_length] ,			self.num_labels		)

												_UpperCamelCase			     =     DebertaVaConfig(
												    vocab_size=self.vocab_size ,			hidden_size=self.hidden_size ,			num_hidden_layers=self.num_hidden_layers ,			num_attention_heads=self.num_attention_heads ,			intermediate_size=self.intermediate_size ,			hidden_act=self.hidden_act ,			hidden_dropout_prob=self.hidden_dropout_prob ,			attention_probs_dropout_prob=self.attention_probs_dropout_prob ,			max_position_embeddings=self.max_position_embeddings ,			type_vocab_size=self.type_vocab_size ,			relative_attention=self.relative_attention ,			position_biased_input=self.position_biased_input ,			initializer_range=self.initializer_range ,			return_dict=_A ,			)

												return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels







							def  UpperCamelCase_						(   self      :     List[str] ,			_A      :     Optional[Any] ,			_A      :     Tuple ,			_A      :     Optional[Any] ,			_A      :     str ,			_A      :     str ,			_A      :     Optional[Any] ,			_A      :     Dict		):
												_UpperCamelCase			     =     TFDebertaVaModel(config=_A		)
												_UpperCamelCase			     =     {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}

												_UpperCamelCase			     =     [input_ids, input_mask]
												_UpperCamelCase			     =     model(_A		)

												_UpperCamelCase			     =     model(_A		)

												self.parent.assertEqual(result.last_hidden_state.shape ,			(self.batch_size, self.seq_length, self.hidden_size)		)







							def  UpperCamelCase_						(   self      :     Optional[Any] ,			_A      :     int ,			_A      :     List[str] ,			_A      :     str ,			_A      :     Tuple ,			_A      :     List[Any] ,			_A      :     Dict ,			_A      :     Union[str, Any]		):
												_UpperCamelCase			     =     TFDebertaVaForMaskedLM(config=_A		)
												_UpperCamelCase			     =     {
												    '''input_ids''': input_ids,
												    '''attention_mask''': input_mask,
												    '''token_type_ids''': token_type_ids,
												}
												_UpperCamelCase			     =     model(_A		)
												self.parent.assertEqual(result.logits.shape ,			(self.batch_size, self.seq_length, self.vocab_size)		)







							def  UpperCamelCase_						(   self      :     int ,			_A      :     str ,			_A      :     str ,			_A      :     Union[str, Any] ,			_A      :     int ,			_A      :     Optional[Any] ,			_A      :     str ,			_A      :     Dict		):
												_UpperCamelCase			     =     self.num_labels
												_UpperCamelCase			     =     TFDebertaVaForSequenceClassification(config=_A		)
												_UpperCamelCase			     =     {
												    '''input_ids''': input_ids,
												    '''attention_mask''': input_mask,
												    '''token_type_ids''': token_type_ids,
												}

												_UpperCamelCase			     =     model(_A		)
												self.parent.assertEqual(result.logits.shape ,			(self.batch_size, self.num_labels)		)







							def  UpperCamelCase_						(   self      :     List[Any] ,			_A      :     List[str] ,			_A      :     Tuple ,			_A      :     int ,			_A      :     int ,			_A      :     Tuple ,			_A      :     Tuple ,			_A      :     int		):
												_UpperCamelCase			     =     self.num_labels
												_UpperCamelCase			     =     TFDebertaVaForTokenClassification(config=_A		)
												_UpperCamelCase			     =     {
												    '''input_ids''': input_ids,
												    '''attention_mask''': input_mask,
												    '''token_type_ids''': token_type_ids,
												}
												_UpperCamelCase			     =     model(_A		)
												self.parent.assertEqual(result.logits.shape ,			(self.batch_size, self.seq_length, self.num_labels)		)







							def  UpperCamelCase_						(   self      :     Dict ,			_A      :     Any ,			_A      :     Union[str, Any] ,			_A      :     List[str] ,			_A      :     Dict ,			_A      :     Tuple ,			_A      :     Any ,			_A      :     Union[str, Any]		):
												_UpperCamelCase			     =     TFDebertaVaForQuestionAnswering(config=_A		)
												_UpperCamelCase			     =     {
												    '''input_ids''': input_ids,
												    '''attention_mask''': input_mask,
												    '''token_type_ids''': token_type_ids,
												}

												_UpperCamelCase			     =     model(_A		)
												self.parent.assertEqual(result.start_logits.shape ,			(self.batch_size, self.seq_length)		)
												self.parent.assertEqual(result.end_logits.shape ,			(self.batch_size, self.seq_length)		)







							def  UpperCamelCase_						(   self      :     Union[str, Any]		):
												_UpperCamelCase			     =     self.prepare_config_and_inputs()
												(
												    (
												    _UpperCamelCase
												)     ,    (
												    _UpperCamelCase
												)     ,    (
												    _UpperCamelCase
												)     ,    (
												    _UpperCamelCase
												)     ,    (
												    _UpperCamelCase
												)     ,    (
												    _UpperCamelCase
												)     ,    (
												    _UpperCamelCase
												)     ,    
												)			     =     config_and_inputs
												_UpperCamelCase			     =     {'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': input_mask}
												return config, inputs_dict




@require_tf
class     lowerCAmelCase_     (       __lowercase,  __lowercase,  unittest.TestCase ):
							UpperCAmelCase				   =     (
							    (
							        TFDebertaVaModel,
							        TFDebertaVaForMaskedLM,
							        TFDebertaVaForQuestionAnswering,
							        TFDebertaVaForSequenceClassification,
							        TFDebertaVaForTokenClassification,
							    )
							    if is_tf_available()
							    else ()
							)
							UpperCAmelCase				   =     (
							    {
							        "feature-extraction": TFDebertaVaModel,
							        "fill-mask": TFDebertaVaForMaskedLM,
							        "question-answering": TFDebertaVaForQuestionAnswering,
							        "text-classification": TFDebertaVaForSequenceClassification,
							        "token-classification": TFDebertaVaForTokenClassification,
							        "zero-shot": TFDebertaVaForSequenceClassification,
							    }
							    if is_tf_available()
							    else {}
							)

							UpperCAmelCase				   =     False
							UpperCAmelCase				   =     False







							def  UpperCamelCase_						(   self      :     Tuple		):
												_UpperCamelCase			     =     TFDebertaVaModelTester(self		)
												_UpperCamelCase			     =     ConfigTester(self ,			config_class=_A ,			hidden_size=37		)







							def  UpperCamelCase_						(   self      :     Dict		):
												self.config_tester.run_common_tests()







							def  UpperCamelCase_						(   self      :     Optional[Any]		):
												_UpperCamelCase			     =     self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_model(*_A		)







							def  UpperCamelCase_						(   self      :     Dict		):
												_UpperCamelCase			     =     self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_masked_lm(*_A		)







							def  UpperCamelCase_						(   self      :     Dict		):
												_UpperCamelCase			     =     self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_question_answering(*_A		)







							def  UpperCamelCase_						(   self      :     Tuple		):
												_UpperCamelCase			     =     self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_sequence_classification(*_A		)







							def  UpperCamelCase_						(   self      :     Optional[Any]		):
												_UpperCamelCase			     =     self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_token_classification(*_A		)







							@slow
							def  UpperCamelCase_						(   self      :     int		):
												_UpperCamelCase			     =     TFDebertaVaModel.from_pretrained('''kamalkraj/deberta-v2-xlarge'''		)
												self.assertIsNotNone(_A		)




@require_tf
class     lowerCAmelCase_     (       unittest.TestCase ):







							@unittest.skip(reason='''Model not available yet'''		)
							def  UpperCamelCase_						(   self      :     int		):
												pass







							@slow
							def  UpperCamelCase_						(   self      :     List[str]		):
												_UpperCamelCase			     =     TFDebertaVaModel.from_pretrained('''kamalkraj/deberta-v2-xlarge'''		)
												_UpperCamelCase			     =     tf.constant([[0, 3_1414, 232, 328, 740, 1140, 1_2695, 69, 4_6078, 1588, 2]]		)
												_UpperCamelCase			     =     tf.constant([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]		)
												_UpperCamelCase			     =     model(_A ,			attention_mask=_A		)[0]

												_UpperCamelCase			     =     tf.constant(
												    [[[0.2356, 0.1948, 0.0369], [-0.1063, 0.3586, -0.5152], [-0.6399, -0.0259, -0.2525]]]		)
												tf.debugging.assert_near(output[:, 1:4, 1:4] ,			_A ,			atol=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.""")




