"""simple docstring"""
import copy
import json
import os
import tempfile

from transformers import is_torch_available

from .test_configuration_utils import config_common_kwargs



class 					lowerCAmelCase_      (     lowerCAmelCase   ):



				"""simple docstring"""

				def __init__(			self						,      lowerCAmelCase						,      lowerCAmelCase=None						,      lowerCAmelCase=True						,      lowerCAmelCase=None						,      **lowerCAmelCase      ):






										"""simple docstring"""

										snake_case        =     parent
										snake_case        =     config_class
										snake_case        =     has_text_modality
										snake_case        =     kwargs
										snake_case        =     common_properties

				def 						snake_case	(			self      ):






										"""simple docstring"""

										snake_case        =     self.config_class(**self.inputs_dict      )
										snake_case        =     (
										    ['hidden_size', 'num_attention_heads', 'num_hidden_layers']
										    if self.common_properties is None
										    else self.common_properties
										)

										# Add common fields for text models
										if self.has_text_modality:
																common_properties.extend(['vocab_size']      )

										# Test that config has the common properties as getters
										for prop in common_properties:
																self.parent.assertTrue(hasattr(lowerCAmelCase						,      lowerCAmelCase      )						,      msg=F"""`{prop}` does not exist"""      )

										# Test that config has the common properties as setter
										for idx, name in enumerate(lowerCAmelCase      ):
																try:
																						setattr(lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase      )
																						self.parent.assertEqual(
																						    getattr(lowerCAmelCase						,      lowerCAmelCase      )						,      lowerCAmelCase						,      msg=F"""`{name} value {idx} expected, but was {getattr(lowerCAmelCase						,      lowerCAmelCase      )}"""      )
																except NotImplementedError:
																						# Some models might not be able to implement setters for common_properties
																						# In that case, a NotImplementedError is raised
																						pass

        # Test if config class can be called with Config(prop_name=..)
										for idx, name in enumerate(lowerCAmelCase      ):
																try:
																						snake_case        =     self.config_class(**{name: idx}      )
																						self.parent.assertEqual(
																						    getattr(lowerCAmelCase						,      lowerCAmelCase      )						,      lowerCAmelCase						,      msg=F"""`{name} value {idx} expected, but was {getattr(lowerCAmelCase						,      lowerCAmelCase      )}"""      )
																except NotImplementedError:
																						# Some models might not be able to implement setters for common_properties
																						# In that case, a NotImplementedError is raised
																						pass

				def 						snake_case	(			self      ):






										"""simple docstring"""

										snake_case        =     self.config_class(**self.inputs_dict      )
										snake_case        =     json.loads(config.to_json_string()      )
										for key, value in self.inputs_dict.items():
																self.parent.assertEqual(obj[key]						,      lowerCAmelCase      )

				def 						snake_case	(			self      ):






										"""simple docstring"""

										snake_case        =     self.config_class(**self.inputs_dict      )

										with tempfile.TemporaryDirectory() as tmpdirname:
																snake_case        =     os.path.join(lowerCAmelCase						,      'config.json'      )
																config_first.to_json_file(lowerCAmelCase      )
																snake_case        =     self.config_class.from_json_file(lowerCAmelCase      )

										self.parent.assertEqual(config_second.to_dict()						,      config_first.to_dict()      )

				def 						snake_case	(			self      ):






										"""simple docstring"""

										snake_case        =     self.config_class(**self.inputs_dict      )

										with tempfile.TemporaryDirectory() as tmpdirname:
																config_first.save_pretrained(lowerCAmelCase      )
																snake_case        =     self.config_class.from_pretrained(lowerCAmelCase      )

										self.parent.assertEqual(config_second.to_dict()						,      config_first.to_dict()      )

				def 						snake_case	(			self      ):






										"""simple docstring"""

										snake_case        =     self.config_class(**self.inputs_dict      )

										snake_case        =     'test'
										with tempfile.TemporaryDirectory() as tmpdirname:
																snake_case        =     os.path.join(lowerCAmelCase						,      lowerCAmelCase      )
																config_first.save_pretrained(lowerCAmelCase      )
																snake_case        =     self.config_class.from_pretrained(lowerCAmelCase						,      subfolder=lowerCAmelCase      )

										self.parent.assertEqual(config_second.to_dict()						,      config_first.to_dict()      )

				def 						snake_case	(			self      ):






										"""simple docstring"""

										snake_case        =     self.config_class(**self.inputs_dict						,      num_labels=5      )
										self.parent.assertEqual(len(config.idalabel      )						,      5      )
										self.parent.assertEqual(len(config.labelaid      )						,      5      )

										snake_case        =     3
										self.parent.assertEqual(len(config.idalabel      )						,      3      )
										self.parent.assertEqual(len(config.labelaid      )						,      3      )

				def 						snake_case	(			self      ):






										"""simple docstring"""

										if self.config_class.is_composition:
																return
										snake_case        =     self.config_class()
										self.parent.assertIsNotNone(lowerCAmelCase      )

				def 						snake_case	(			self      ):






										"""simple docstring"""

										snake_case        =     copy.deepcopy(lowerCAmelCase      )
										snake_case        =     self.config_class(**lowerCAmelCase      )
										snake_case        =     []
										for key, value in config_common_kwargs.items():
																if key == "torch_dtype":
																						if not is_torch_available():
																												continue
																						else:
																												import torch

																												if config.torch_dtype != torch.floataa:
																																		wrong_values.append(('torch_dtype', config.torch_dtype, torch.floataa)      )
																elif getattr(lowerCAmelCase						,      lowerCAmelCase      ) != value:
																						wrong_values.append((key, getattr(lowerCAmelCase						,      lowerCAmelCase      ), value)      )

										if len(lowerCAmelCase      ) > 0:
																snake_case        =     '\n'.join([F"""- {v[0]}: got {v[1]} instead of {v[2]}""" for v in wrong_values]      )
																raise ValueError(F"""The following keys were not properly set in the config:\n{errors}"""      )

				def 						snake_case	(			self      ):






										"""simple docstring"""

										self.create_and_test_config_common_properties()
										self.create_and_test_config_to_json_string()
										self.create_and_test_config_to_json_file()
										self.create_and_test_config_from_and_save_pretrained()
										self.create_and_test_config_from_and_save_pretrained_subfolder()
										self.create_and_test_config_with_num_labels()
										self.check_config_can_be_init_without_params()
										self.check_config_arguments_init()



"""simple docstring"""
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_      :



				"""simple docstring"""

				def __init__(			self						,      lowerCAmelCase						,      lowerCAmelCase=13						,      lowerCAmelCase=7						,      lowerCAmelCase=True						,      lowerCAmelCase=True						,      lowerCAmelCase=True						,      lowerCAmelCase=True						,      lowerCAmelCase=99						,      lowerCAmelCase=32						,      lowerCAmelCase=2						,      lowerCAmelCase=4						,      lowerCAmelCase=37						,      lowerCAmelCase="gelu"						,      lowerCAmelCase=0.1						,      lowerCAmelCase=0.1						,      lowerCAmelCase=5_12						,      lowerCAmelCase=16						,      lowerCAmelCase=2						,      lowerCAmelCase=0.02						,      lowerCAmelCase=False						,      lowerCAmelCase=True						,      lowerCAmelCase="None"						,      lowerCAmelCase=3						,      lowerCAmelCase=4						,      lowerCAmelCase=None						,      ):






										"""simple docstring"""

										snake_case        =     parent
										snake_case        =     batch_size
										snake_case        =     seq_length
										snake_case        =     is_training
										snake_case        =     use_input_mask
										snake_case        =     use_token_type_ids
										snake_case        =     use_labels
										snake_case        =     vocab_size
										snake_case        =     hidden_size
										snake_case        =     num_hidden_layers
										snake_case        =     num_attention_heads
										snake_case        =     intermediate_size
										snake_case        =     hidden_act
										snake_case        =     hidden_dropout_prob
										snake_case        =     attention_probs_dropout_prob
										snake_case        =     max_position_embeddings
										snake_case        =     type_vocab_size
										snake_case        =     type_sequence_label_size
										snake_case        =     initializer_range
										snake_case        =     num_labels
										snake_case        =     num_choices
										snake_case        =     relative_attention
										snake_case        =     position_biased_input
										snake_case        =     pos_att_type
										snake_case        =     scope

				def 						snake_case	(			self      ):






										"""simple docstring"""

										snake_case        =     ids_tensor([self.batch_size, self.seq_length]						,      self.vocab_size      )

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

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

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

										snake_case        =     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=lowerCAmelCase						,      )

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

				def 						snake_case	(			self						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase      ):






										"""simple docstring"""

										snake_case        =     TFDebertaVaModel(config=lowerCAmelCase      )
										snake_case        =     {'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}

										snake_case        =     [input_ids, input_mask]
										snake_case        =     model(lowerCAmelCase      )

										snake_case        =     model(lowerCAmelCase      )

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

				def 						snake_case	(			self						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase      ):






										"""simple docstring"""

										snake_case        =     TFDebertaVaForMaskedLM(config=lowerCAmelCase      )
										snake_case        =     {
										    'input_ids': input_ids,
										    'attention_mask': input_mask,
										    'token_type_ids': token_type_ids,
										}
										snake_case        =     model(lowerCAmelCase      )
										self.parent.assertEqual(result.logits.shape						,      (self.batch_size, self.seq_length, self.vocab_size)      )

				def 						snake_case	(			self						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase      ):






										"""simple docstring"""

										snake_case        =     self.num_labels
										snake_case        =     TFDebertaVaForSequenceClassification(config=lowerCAmelCase      )
										snake_case        =     {
										    'input_ids': input_ids,
										    'attention_mask': input_mask,
										    'token_type_ids': token_type_ids,
										}

										snake_case        =     model(lowerCAmelCase      )
										self.parent.assertEqual(result.logits.shape						,      (self.batch_size, self.num_labels)      )

				def 						snake_case	(			self						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase      ):






										"""simple docstring"""

										snake_case        =     self.num_labels
										snake_case        =     TFDebertaVaForTokenClassification(config=lowerCAmelCase      )
										snake_case        =     {
										    'input_ids': input_ids,
										    'attention_mask': input_mask,
										    'token_type_ids': token_type_ids,
										}
										snake_case        =     model(lowerCAmelCase      )
										self.parent.assertEqual(result.logits.shape						,      (self.batch_size, self.seq_length, self.num_labels)      )

				def 						snake_case	(			self						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase      ):






										"""simple docstring"""

										snake_case        =     TFDebertaVaForQuestionAnswering(config=lowerCAmelCase      )
										snake_case        =     {
										    'input_ids': input_ids,
										    'attention_mask': input_mask,
										    'token_type_ids': token_type_ids,
										}

										snake_case        =     model(lowerCAmelCase      )
										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 						snake_case	(			self      ):






										"""simple docstring"""

										snake_case        =     self.prepare_config_and_inputs()
										(
										    (
										    snake_case
										)   ,(
										    snake_case
										)   ,(
										    snake_case
										)   ,(
										    snake_case
										)   ,(
										    snake_case
										)   ,(
										    snake_case
										)   ,(
										    snake_case
										)   ,
										)        =     config_and_inputs
										snake_case        =     {'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask}
										return config, inputs_dict





@require_tf
class 					lowerCAmelCase_      (     lowerCAmelCase       ,      lowerCAmelCase       ,      unittest.TestCase   ):



				"""simple docstring"""
				_lowerCAmelCase       :      Optional[int]     					=  (
				    (
				        TFDebertaVaModel,
				        TFDebertaVaForMaskedLM,
				        TFDebertaVaForQuestionAnswering,
				        TFDebertaVaForSequenceClassification,
				        TFDebertaVaForTokenClassification,
				    )
				    if is_tf_available()
				    else ()
				)
				_lowerCAmelCase       :      Any     					=  (
				    {
				        """feature-extraction""": TFDebertaVaModel,
				        """fill-mask""": TFDebertaVaForMaskedLM,
				        """question-answering""": TFDebertaVaForQuestionAnswering,
				        """text-classification""": TFDebertaVaForSequenceClassification,
				        """token-classification""": TFDebertaVaForTokenClassification,
				        """zero-shot""": TFDebertaVaForSequenceClassification,
				    }
				    if is_tf_available()
				    else {}
				)

				_lowerCAmelCase       :      Optional[Any]     					=  False
				_lowerCAmelCase       :      List[Any]     					=  False

				def 						snake_case	(			self      ):






										"""simple docstring"""

										snake_case        =     TFDebertaVaModelTester(self      )
										snake_case        =     ConfigTester(self						,      config_class=lowerCAmelCase						,      hidden_size=37      )

				def 						snake_case	(			self      ):






										"""simple docstring"""

										self.config_tester.run_common_tests()

				def 						snake_case	(			self      ):






										"""simple docstring"""

										snake_case        =     self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*lowerCAmelCase      )

				def 						snake_case	(			self      ):






										"""simple docstring"""

										snake_case        =     self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_masked_lm(*lowerCAmelCase      )

				def 						snake_case	(			self      ):






										"""simple docstring"""

										snake_case        =     self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_question_answering(*lowerCAmelCase      )

				def 						snake_case	(			self      ):






										"""simple docstring"""

										snake_case        =     self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_sequence_classification(*lowerCAmelCase      )

				def 						snake_case	(			self      ):






										"""simple docstring"""

										snake_case        =     self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_token_classification(*lowerCAmelCase      )

				@slow
				def 						snake_case	(			self      ):






										"""simple docstring"""

										snake_case        =     TFDebertaVaModel.from_pretrained('kamalkraj/deberta-v2-xlarge'      )
										self.assertIsNotNone(lowerCAmelCase      )





@require_tf
class 					lowerCAmelCase_      (     unittest.TestCase   ):



				"""simple docstring"""

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






										"""simple docstring"""

										pass

				@slow
				def 						snake_case	(			self      ):






										"""simple docstring"""

										snake_case        =     TFDebertaVaModel.from_pretrained('kamalkraj/deberta-v2-xlarge'      )
										snake_case        =     tf.constant([[0, 3_14_14, 2_32, 3_28, 7_40, 11_40, 1_26_95, 69, 4_60_78, 15_88, 2]]      )
										snake_case        =     tf.constant([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]      )
										snake_case        =     model(lowerCAmelCase						,      attention_mask=lowerCAmelCase      )[0]

										snake_case        =     tf.constant(
										    [[[0.23_56, 0.19_48, 0.03_69], [-0.10_63, 0.35_86, -0.51_52], [-0.63_99, -0.02_59, -0.25_25]]]      )
										tf.debugging.assert_near(output[:, 1:4, 1:4]						,      lowerCAmelCase						,      atol=1E-4      )


