





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 	A_       :
	def __init__(    self							,					_A							,					_A=1_3							,					_A=7							,					_A=True							,					_A=True							,					_A=True							,					_A=True							,					_A=9_9							,					_A=3_2							,					_A=2							,					_A=4							,					_A=3_7							,					_A="gelu"							,					_A=0.1							,					_A=0.1							,					_A=5_1_2							,					_A=1_6							,					_A=2							,					_A=0.02							,					_A=False							,					_A=True							,					_A="None"							,					_A=3							,					_A=4							,					_A=None							,					):






				'''simple docstring'''







				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      _lowercase				(    self		):






				'''simple docstring'''







				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      _lowercase				(    self							,					_A							,					_A							,					_A							,					_A							,					_A							,					_A							,					_A		):






				'''simple docstring'''







				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      _lowercase				(    self							,					_A							,					_A							,					_A							,					_A							,					_A							,					_A							,					_A		):






				'''simple docstring'''







				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      _lowercase				(    self							,					_A							,					_A							,					_A							,					_A							,					_A							,					_A							,					_A		):






				'''simple docstring'''







				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      _lowercase				(    self							,					_A							,					_A							,					_A							,					_A							,					_A							,					_A							,					_A		):






				'''simple docstring'''







				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      _lowercase				(    self							,					_A							,					_A							,					_A							,					_A							,					_A							,					_A							,					_A		):






				'''simple docstring'''







				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      _lowercase				(    self		):






				'''simple docstring'''







				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 	A_       (a_     ,							a_     ,							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      _lowercase				(    self		):






				'''simple docstring'''







				UpperCAmelCase   		=				TFDebertaVaModelTester(self		)
				UpperCAmelCase   		=				ConfigTester(self							,					config_class=_A							,					hidden_size=3_7		)
	def      _lowercase				(    self		):






				'''simple docstring'''







				self.config_tester.run_common_tests()
	def      _lowercase				(    self		):






				'''simple docstring'''







				UpperCAmelCase   		=				self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_model(*_A		)
	def      _lowercase				(    self		):






				'''simple docstring'''







				UpperCAmelCase   		=				self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_for_masked_lm(*_A		)
	def      _lowercase				(    self		):






				'''simple docstring'''







				UpperCAmelCase   		=				self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_for_question_answering(*_A		)
	def      _lowercase				(    self		):






				'''simple docstring'''







				UpperCAmelCase   		=				self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_for_sequence_classification(*_A		)
	def      _lowercase				(    self		):






				'''simple docstring'''







				UpperCAmelCase   		=				self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_for_token_classification(*_A		)







	@slow
	def      _lowercase				(    self		):






				'''simple docstring'''







				UpperCAmelCase   		=				TFDebertaVaModel.from_pretrained('''kamalkraj/deberta-v2-xlarge'''		)
				self.assertIsNotNone(_A		)

@require_tf
class 	A_       (unittest.TestCase			):
	@unittest.skip(reason='''Model not available yet'''		)
	def      _lowercase				(    self		):






				'''simple docstring'''







				pass







	@slow
	def      _lowercase				(    self		):






				'''simple docstring'''







				UpperCAmelCase   		=				TFDebertaVaModel.from_pretrained('''kamalkraj/deberta-v2-xlarge'''		)
				UpperCAmelCase   		=				tf.constant([[0, 3_1_4_1_4, 2_3_2, 3_2_8, 7_4_0, 1_1_4_0, 1_2_6_9_5, 6_9, 4_6_0_7_8, 1_5_8_8, 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.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]							,					_A							,					atol=1E-4		)










from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_sentencepiece_available,
    is_speech_available,
    is_tf_available,
    is_torch_available,
)


__A				:    Union[str, Any]       =   {
    "configuration_speech_to_text": ["SPEECH_TO_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP", "Speech2TextConfig"],
    "processing_speech_to_text": ["Speech2TextProcessor"],
}

try:
				if not is_sentencepiece_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				__A				:    List[Any]       =   ["Speech2TextTokenizer"]

try:
				if not is_speech_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				__A				:    List[Any]       =   ["Speech2TextFeatureExtractor"]

try:
				if not is_tf_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				__A				:    int       =   [
				    "TF_SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST",
				    "TFSpeech2TextForConditionalGeneration",
				    "TFSpeech2TextModel",
				    "TFSpeech2TextPreTrainedModel",
				]

try:
				if not is_torch_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				__A				:    Tuple       =   [
				    "SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST",
				    "Speech2TextForConditionalGeneration",
				    "Speech2TextModel",
				    "Speech2TextPreTrainedModel",
				]


if TYPE_CHECKING:
				from .configuration_speech_to_text import SPEECH_TO_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP, SpeechaTextConfig
				from .processing_speech_to_text import SpeechaTextProcessor

				try:
								if not is_sentencepiece_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .tokenization_speech_to_text import SpeechaTextTokenizer

				try:
								if not is_speech_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .feature_extraction_speech_to_text import SpeechaTextFeatureExtractor

				try:
								if not is_tf_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_tf_speech_to_text import (
								    TF_SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST,
								    TFSpeechaTextForConditionalGeneration,
								    TFSpeechaTextModel,
								    TFSpeechaTextPreTrainedModel,
								)

				try:
								if not is_torch_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_speech_to_text import (
								    SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST,
								    SpeechaTextForConditionalGeneration,
								    SpeechaTextModel,
								    SpeechaTextPreTrainedModel,
								)

else:
				import sys

				__A				:    Dict       =   _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)



