






'''simple docstring'''

import unittest

from transformers import DebertaVaConfig, is_torch_available
from transformers.testing_utils import require_sentencepiece, require_tokenizers, require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
   import torch

   from transformers import (
       DebertaVaForMaskedLM,
       DebertaVaForMultipleChoice,
       DebertaVaForQuestionAnswering,
       DebertaVaForSequenceClassification,
       DebertaVaForTokenClassification,
       DebertaVaModel,
   )
   from transformers.models.deberta_va.modeling_deberta_va import DEBERTA_V2_PRETRAINED_MODEL_ARCHIVE_LIST







class 						SCREAMING_SNAKE_CASE						(   SCREAMING_SNAKE_CASE_	):




       def __init__(       self   :			Dict						,     A__   :			int						,     A__   :			Any=13						,     A__   :			Union[str, Any]=7						,     A__   :			int=True						,     A__   :			Optional[int]=True						,     A__   :			Union[str, Any]=True						,     A__   :			Dict=True						,     A__   :			Optional[Any]=99						,     A__   :			List[str]=32						,     A__   :			Union[str, Any]=5						,     A__   :			Optional[Any]=4						,     A__   :			Dict=37						,     A__   :			Dict="gelu"						,     A__   :			Optional[int]=0.1						,     A__   :			Tuple=0.1						,     A__   :			Dict=512						,     A__   :			Tuple=16						,     A__   :			List[str]=2						,     A__   :			Union[str, Any]=0.02						,     A__   :			List[Any]=False						,     A__   :			str=True						,     A__   :			List[Any]="None"						,     A__   :			Dict=3						,     A__   :			Union[str, Any]=4						,     A__   :			Union[str, Any]=None						,     ):


            """simple docstring"""







            __lowerCamelCase    :							Any					 =					parent
            __lowerCamelCase    :							List[Any]					 =					batch_size
            __lowerCamelCase    :							str					 =					seq_length
            __lowerCamelCase    :							Dict					 =					is_training
            __lowerCamelCase    :							str					 =					use_input_mask
            __lowerCamelCase    :							Any					 =					use_token_type_ids
            __lowerCamelCase    :							Dict					 =					use_labels
            __lowerCamelCase    :							str					 =					vocab_size
            __lowerCamelCase    :							Optional[Any]					 =					hidden_size
            __lowerCamelCase    :							Union[str, Any]					 =					num_hidden_layers
            __lowerCamelCase    :							Union[str, Any]					 =					num_attention_heads
            __lowerCamelCase    :							str					 =					intermediate_size
            __lowerCamelCase    :							Union[str, Any]					 =					hidden_act
            __lowerCamelCase    :							Tuple					 =					hidden_dropout_prob
            __lowerCamelCase    :							Union[str, Any]					 =					attention_probs_dropout_prob
            __lowerCamelCase    :							Optional[Any]					 =					max_position_embeddings
            __lowerCamelCase    :							Tuple					 =					type_vocab_size
            __lowerCamelCase    :							Dict					 =					type_sequence_label_size
            __lowerCamelCase    :							str					 =					initializer_range
            __lowerCamelCase    :							Tuple					 =					num_labels
            __lowerCamelCase    :							Optional[Any]					 =					num_choices
            __lowerCamelCase    :							Any					 =					relative_attention
            __lowerCamelCase    :							Any					 =					position_biased_input
            __lowerCamelCase    :							Dict					 =					pos_att_type
            __lowerCamelCase    :							Any					 =					scope




       def        a_       (       self   :			Dict       ):


            """simple docstring"""







            __lowerCamelCase    :							List[str]					 =					ids_tensor([self.batch_size, self.seq_length]						,     self.vocab_size       )

            __lowerCamelCase    :							Optional[Any]					 =					None
            if self.use_input_mask:
                 __lowerCamelCase    :							Optional[Any]					 =					ids_tensor([self.batch_size, self.seq_length]						,     vocab_size=2       )

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

            __lowerCamelCase    :							Any					 =					None
            __lowerCamelCase    :							Optional[int]					 =					None
            __lowerCamelCase    :							Tuple					 =					None
            if self.use_labels:
                 __lowerCamelCase    :							Union[str, Any]					 =					ids_tensor([self.batch_size]						,     self.type_sequence_label_size       )
                 __lowerCamelCase    :							Optional[Any]					 =					ids_tensor([self.batch_size, self.seq_length]						,     self.num_labels       )
                 __lowerCamelCase    :							str					 =					ids_tensor([self.batch_size]						,     self.num_choices       )

            __lowerCamelCase    :							List[str]					 =					self.get_config()

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




       def        a_       (       self   :			List[str]       ):


            """simple docstring"""







            return 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						,     initializer_range=self.initializer_range						,     relative_attention=self.relative_attention						,     position_biased_input=self.position_biased_input						,     pos_att_type=self.pos_att_type						,     )




       def        a_       (       self   :			Any						,     A__   :			Optional[Any]       ):


            """simple docstring"""







            self.parent.assertListEqual(list(result.loss.size()       )						,     []       )




       def        a_       (       self   :			List[str]						,     A__   :			Any						,     A__   :			List[str]						,     A__   :			List[Any]						,     A__   :			Dict						,     A__   :			Union[str, Any]						,     A__   :			Tuple						,     A__   :			List[Any]       ):


            """simple docstring"""







            __lowerCamelCase    :							str					 =					DebertaVaModel(config=_a       )
            model.to(_a       )
            model.eval()
            __lowerCamelCase    :							Optional[Any]					 =					model(_a						,     attention_mask=_a						,     token_type_ids=_a       )[0]
            __lowerCamelCase    :							List[Any]					 =					model(_a						,     token_type_ids=_a       )[0]
            __lowerCamelCase    :							int					 =					model(_a       )[0]

            self.parent.assertListEqual(list(sequence_output.size()       )						,     [self.batch_size, self.seq_length, self.hidden_size]       )




       def        a_       (       self   :			Union[str, Any]						,     A__   :			str						,     A__   :			Optional[int]						,     A__   :			Dict						,     A__   :			Optional[int]						,     A__   :			Dict						,     A__   :			Optional[Any]						,     A__   :			Optional[Any]       ):


            """simple docstring"""







            __lowerCamelCase    :							List[Any]					 =					DebertaVaForMaskedLM(config=_a       )
            model.to(_a       )
            model.eval()
            __lowerCamelCase    :							Optional[int]					 =					model(_a						,     attention_mask=_a						,     token_type_ids=_a						,     labels=_a       )

            self.parent.assertEqual(result.logits.shape						,     (self.batch_size, self.seq_length, self.vocab_size)       )




       def        a_       (       self   :			Optional[Any]						,     A__   :			List[str]						,     A__   :			str						,     A__   :			Any						,     A__   :			Dict						,     A__   :			Optional[Any]						,     A__   :			Optional[Any]						,     A__   :			str       ):


            """simple docstring"""







            __lowerCamelCase    :							List[str]					 =					self.num_labels
            __lowerCamelCase    :							List[str]					 =					DebertaVaForSequenceClassification(_a       )
            model.to(_a       )
            model.eval()
            __lowerCamelCase    :							Tuple					 =					model(_a						,     attention_mask=_a						,     token_type_ids=_a						,     labels=_a       )
            self.parent.assertListEqual(list(result.logits.size()       )						,     [self.batch_size, self.num_labels]       )
            self.check_loss_output(_a       )




       def        a_       (       self   :			int						,     A__   :			List[str]						,     A__   :			Union[str, Any]						,     A__   :			Any						,     A__   :			int						,     A__   :			Optional[int]						,     A__   :			Tuple						,     A__   :			Tuple       ):


            """simple docstring"""







            __lowerCamelCase    :							Union[str, Any]					 =					self.num_labels
            __lowerCamelCase    :							Union[str, Any]					 =					DebertaVaForTokenClassification(config=_a       )
            model.to(_a       )
            model.eval()
            __lowerCamelCase    :							str					 =					model(_a						,     attention_mask=_a						,     token_type_ids=_a						,     labels=_a       )
            self.parent.assertEqual(result.logits.shape						,     (self.batch_size, self.seq_length, self.num_labels)       )




       def        a_       (       self   :			Union[str, Any]						,     A__   :			Optional[int]						,     A__   :			List[Any]						,     A__   :			Optional[Any]						,     A__   :			List[str]						,     A__   :			Optional[int]						,     A__   :			Union[str, Any]						,     A__   :			Any       ):


            """simple docstring"""







            __lowerCamelCase    :							int					 =					DebertaVaForQuestionAnswering(config=_a       )
            model.to(_a       )
            model.eval()
            __lowerCamelCase    :							List[str]					 =					model(
                _a						,     attention_mask=_a						,     token_type_ids=_a						,     start_positions=_a						,     end_positions=_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        a_       (       self   :			Union[str, Any]						,     A__   :			Any						,     A__   :			List[str]						,     A__   :			str						,     A__   :			str						,     A__   :			List[Any]						,     A__   :			Tuple						,     A__   :			str       ):


            """simple docstring"""







            __lowerCamelCase    :							Union[str, Any]					 =					DebertaVaForMultipleChoice(config=_a       )
            model.to(_a       )
            model.eval()
            __lowerCamelCase    :							List[Any]					 =					input_ids.unsqueeze(1       ).expand(-1						,     self.num_choices						,     -1       ).contiguous()
            __lowerCamelCase    :							List[str]					 =					token_type_ids.unsqueeze(1       ).expand(-1						,     self.num_choices						,     -1       ).contiguous()
            __lowerCamelCase    :							Union[str, Any]					 =					input_mask.unsqueeze(1       ).expand(-1						,     self.num_choices						,     -1       ).contiguous()
            __lowerCamelCase    :							Optional[int]					 =					model(
                _a						,     attention_mask=_a						,     token_type_ids=_a						,     labels=_a						,     )
            self.parent.assertEqual(result.logits.shape						,     (self.batch_size, self.num_choices)       )




       def        a_       (       self   :			Any       ):


            """simple docstring"""







            __lowerCamelCase    :							Tuple					 =					self.prepare_config_and_inputs()
            (
                __lowerCamelCase
            )    :							Optional[int]					 =					config_and_inputs
            __lowerCamelCase    :							List[Any]					 =					{'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask}
            return config, inputs_dict







@require_torch
class 						SCREAMING_SNAKE_CASE						(   SCREAMING_SNAKE_CASE_     , SCREAMING_SNAKE_CASE_     , unittest.TestCase	):
       snake_case__     :  str 		=      (
           (
               DebertaVaModel,
               DebertaVaForMaskedLM,
               DebertaVaForSequenceClassification,
               DebertaVaForTokenClassification,
               DebertaVaForQuestionAnswering,
               DebertaVaForMultipleChoice,
           )
           if is_torch_available()
           else ()
       )
       snake_case__     :  Dict 		=      (
           {
               'feature-extraction': DebertaVaModel,
               'fill-mask': DebertaVaForMaskedLM,
               'question-answering': DebertaVaForQuestionAnswering,
               'text-classification': DebertaVaForSequenceClassification,
               'token-classification': DebertaVaForTokenClassification,
               'zero-shot': DebertaVaForSequenceClassification,
           }
           if is_torch_available()
           else {}
       )

       snake_case__     :  Any 		=      True
       snake_case__     :  Any 		=      False
       snake_case__     :  List[Any] 		=      False
       snake_case__     :  Any 		=      False
       snake_case__     :  List[str] 		=      False




       def        a_       (       self   :			Tuple       ):


            """simple docstring"""







            __lowerCamelCase    :							str					 =					DebertaVaModelTester(self       )
            __lowerCamelCase    :							Dict					 =					ConfigTester(self						,     config_class=_a						,     hidden_size=37       )




       def        a_       (       self   :			int       ):


            """simple docstring"""







            self.config_tester.run_common_tests()




       def        a_       (       self   :			Any       ):


            """simple docstring"""







            __lowerCamelCase    :							Any					 =					self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_deberta_model(*_a       )




       def        a_       (       self   :			Dict       ):


            """simple docstring"""







            __lowerCamelCase    :							List[str]					 =					self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_deberta_for_sequence_classification(*_a       )




       def        a_       (       self   :			Tuple       ):


            """simple docstring"""







            __lowerCamelCase    :							Tuple					 =					self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_deberta_for_masked_lm(*_a       )




       def        a_       (       self   :			Union[str, Any]       ):


            """simple docstring"""







            __lowerCamelCase    :							Union[str, Any]					 =					self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_deberta_for_question_answering(*_a       )




       def        a_       (       self   :			Union[str, Any]       ):


            """simple docstring"""







            __lowerCamelCase    :							int					 =					self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_deberta_for_token_classification(*_a       )




       def        a_       (       self   :			Optional[Any]       ):


            """simple docstring"""







            __lowerCamelCase    :							Tuple					 =					self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_deberta_for_multiple_choice(*_a       )




       @slow
       def        a_       (       self   :			Optional[int]       ):


            """simple docstring"""







            for model_name in DEBERTA_V2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                 __lowerCamelCase    :							Any					 =					DebertaVaModel.from_pretrained(_a       )
                 self.assertIsNotNone(_a       )







@require_torch
@require_sentencepiece
@require_tokenizers
class 						SCREAMING_SNAKE_CASE						(   unittest.TestCase	):




       @unittest.skip(reason="""Model not available yet"""       )
       def        a_       (       self   :			List[str]       ):


            """simple docstring"""







            pass




       @slow
       def        a_       (       self   :			List[str]       ):


            """simple docstring"""







            __lowerCamelCase    :							List[Any]					 =					DebertaVaModel.from_pretrained("""microsoft/deberta-v2-xlarge"""       )

            __lowerCamelCase    :							Optional[Any]					 =					torch.tensor([[0, 31414, 232, 328, 740, 1140, 12695, 69, 46078, 1588, 2]]       )
            __lowerCamelCase    :							List[str]					 =					torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]       )
            with torch.no_grad():
                 __lowerCamelCase    :							List[str]					 =					model(_a						,     attention_mask=_a       )[0]
            # compare the actual values for a slice.
            __lowerCamelCase    :							Tuple					 =					torch.tensor(
                [[[0.2356, 0.1948, 0.0369], [-0.1063, 0.3586, -0.5152], [-0.6399, -0.0259, -0.2525]]]       )
            self.assertTrue(torch.allclose(output[:, 1:4, 1:4]						,     _a						,     atol=1e-4       )						,     f"{output[:, 1:4, 1:4]}"       )








'''simple docstring'''





# Algorithm for the pigeonhole sorting



def 			a_	(				_lowerCAmelCase			) -> List[str]:
  __lowerCamelCase			:			int       			=					min(_lowerCAmelCase			)  # min() finds the minimum value
  __lowerCamelCase			:			List[Any]       			=					max(_lowerCAmelCase			)  # max() finds the maximum value

  __lowerCamelCase			:			List[Any]       			=					max_val - min_val + 1  # size is difference of max and min values plus one

  # list of pigeonholes of size equal to the variable size
  __lowerCamelCase			:			List[Any]       			=					[0] * size

  # Populate the pigeonholes.
  for x in a:
    assert isinstance(_lowerCAmelCase			,_lowerCAmelCase			), "integers only please"
    holes[x - min_val] += 1

  # Putting the elements back into the array in an order.
  __lowerCamelCase			:			Tuple       			=					0
  for count in range(_lowerCAmelCase			):
    while holes[count] > 0:
      holes[count] -= 1
      __lowerCamelCase			:			List[Any]       			=					count + min_val
      i += 1

def 			a_	(				) -> str:
  __lowerCamelCase			:			Optional[Any]       			=					[8, 3, 2, 7, 4, 6, 8]
  pigeonhole_sort(_lowerCAmelCase			)
  print('Sorted order is:'			,' '.join(_lowerCAmelCase			)			)


if __name__ == "__main__":
   main()






