
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 					lowercase__:



	"""simple docstring"""




	def __init__(			self    :     Dict			,				SCREAMING_SNAKE_CASE_    :     str			,				SCREAMING_SNAKE_CASE_    :     str=1_3			,				SCREAMING_SNAKE_CASE_    :     Optional[Any]=7			,				SCREAMING_SNAKE_CASE_    :     Dict=True			,				SCREAMING_SNAKE_CASE_    :     Tuple=True			,				SCREAMING_SNAKE_CASE_    :     Optional[Any]=True			,				SCREAMING_SNAKE_CASE_    :     Tuple=True			,				SCREAMING_SNAKE_CASE_    :     Tuple=9_9			,				SCREAMING_SNAKE_CASE_    :     List[str]=3_2			,				SCREAMING_SNAKE_CASE_    :     int=2			,				SCREAMING_SNAKE_CASE_    :     Tuple=4			,				SCREAMING_SNAKE_CASE_    :     Union[str, Any]=3_7			,				SCREAMING_SNAKE_CASE_    :     Union[str, Any]="gelu"			,				SCREAMING_SNAKE_CASE_    :     Union[str, Any]=0.1			,				SCREAMING_SNAKE_CASE_    :     Union[str, Any]=0.1			,				SCREAMING_SNAKE_CASE_    :     Optional[int]=5_1_2			,				SCREAMING_SNAKE_CASE_    :     str=1_6			,				SCREAMING_SNAKE_CASE_    :     Union[str, Any]=2			,				SCREAMING_SNAKE_CASE_    :     List[Any]=0.02			,				SCREAMING_SNAKE_CASE_    :     List[Any]=False			,				SCREAMING_SNAKE_CASE_    :     List[Any]=True			,				SCREAMING_SNAKE_CASE_    :     Union[str, Any]="None"			,				SCREAMING_SNAKE_CASE_    :     Optional[Any]=3			,				SCREAMING_SNAKE_CASE_    :     List[Any]=4			,				SCREAMING_SNAKE_CASE_    :     str=None			,				)			->	str:
					lowercase_	    =   parent
					lowercase_	    =   batch_size
					lowercase_	    =   seq_length
					lowercase_	    =   is_training
					lowercase_	    =   use_input_mask
					lowercase_	    =   use_token_type_ids
					lowercase_	    =   use_labels
					lowercase_	    =   vocab_size
					lowercase_	    =   hidden_size
					lowercase_	    =   num_hidden_layers
					lowercase_	    =   num_attention_heads
					lowercase_	    =   intermediate_size
					lowercase_	    =   hidden_act
					lowercase_	    =   hidden_dropout_prob
					lowercase_	    =   attention_probs_dropout_prob
					lowercase_	    =   max_position_embeddings
					lowercase_	    =   type_vocab_size
					lowercase_	    =   type_sequence_label_size
					lowercase_	    =   initializer_range
					lowercase_	    =   num_labels
					lowercase_	    =   num_choices
					lowercase_	    =   relative_attention
					lowercase_	    =   position_biased_input
					lowercase_	    =   pos_att_type
					lowercase_	    =   scope
	def 		_lowercase    (			self    :     List[Any]			)			->	List[Any]:
					lowercase_	    =   ids_tensor([self.batch_size, self.seq_length]			,				self.vocab_size			)

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

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

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

					lowercase_	    =   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=SCREAMING_SNAKE_CASE_			,				)

					return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels
	def 		_lowercase    (			self    :     str			,				SCREAMING_SNAKE_CASE_    :     Any			,				SCREAMING_SNAKE_CASE_    :     Optional[int]			,				SCREAMING_SNAKE_CASE_    :     str			,				SCREAMING_SNAKE_CASE_    :     Tuple			,				SCREAMING_SNAKE_CASE_    :     Dict			,				SCREAMING_SNAKE_CASE_    :     Dict			,				SCREAMING_SNAKE_CASE_    :     List[Any]			)			->	List[Any]:
					lowercase_	    =   TFDebertaVaModel(config=SCREAMING_SNAKE_CASE_			)
					lowercase_	    =   {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}

					lowercase_	    =   [input_ids, input_mask]
					lowercase_	    =   model(SCREAMING_SNAKE_CASE_			)

					lowercase_	    =   model(SCREAMING_SNAKE_CASE_			)

					self.parent.assertEqual(result.last_hidden_state.shape			,				(self.batch_size, self.seq_length, self.hidden_size)			)
	def 		_lowercase    (			self    :     Tuple			,				SCREAMING_SNAKE_CASE_    :     Optional[Any]			,				SCREAMING_SNAKE_CASE_    :     str			,				SCREAMING_SNAKE_CASE_    :     Any			,				SCREAMING_SNAKE_CASE_    :     int			,				SCREAMING_SNAKE_CASE_    :     Dict			,				SCREAMING_SNAKE_CASE_    :     Any			,				SCREAMING_SNAKE_CASE_    :     Any			)			->	Union[str, Any]:
					lowercase_	    =   TFDebertaVaForMaskedLM(config=SCREAMING_SNAKE_CASE_			)
					lowercase_	    =   {
					    '''input_ids''': input_ids,
					    '''attention_mask''': input_mask,
					    '''token_type_ids''': token_type_ids,
					}
					lowercase_	    =   model(SCREAMING_SNAKE_CASE_			)
					self.parent.assertEqual(result.logits.shape			,				(self.batch_size, self.seq_length, self.vocab_size)			)
	def 		_lowercase    (			self    :     Optional[int]			,				SCREAMING_SNAKE_CASE_    :     Tuple			,				SCREAMING_SNAKE_CASE_    :     int			,				SCREAMING_SNAKE_CASE_    :     Tuple			,				SCREAMING_SNAKE_CASE_    :     str			,				SCREAMING_SNAKE_CASE_    :     List[Any]			,				SCREAMING_SNAKE_CASE_    :     Union[str, Any]			,				SCREAMING_SNAKE_CASE_    :     Union[str, Any]			)			->	List[str]:
					lowercase_	    =   self.num_labels
					lowercase_	    =   TFDebertaVaForSequenceClassification(config=SCREAMING_SNAKE_CASE_			)
					lowercase_	    =   {
					    '''input_ids''': input_ids,
					    '''attention_mask''': input_mask,
					    '''token_type_ids''': token_type_ids,
					}

					lowercase_	    =   model(SCREAMING_SNAKE_CASE_			)
					self.parent.assertEqual(result.logits.shape			,				(self.batch_size, self.num_labels)			)
	def 		_lowercase    (			self    :     Optional[int]			,				SCREAMING_SNAKE_CASE_    :     Tuple			,				SCREAMING_SNAKE_CASE_    :     List[Any]			,				SCREAMING_SNAKE_CASE_    :     List[Any]			,				SCREAMING_SNAKE_CASE_    :     Union[str, Any]			,				SCREAMING_SNAKE_CASE_    :     str			,				SCREAMING_SNAKE_CASE_    :     Any			,				SCREAMING_SNAKE_CASE_    :     Optional[int]			)			->	Optional[Any]:
					lowercase_	    =   self.num_labels
					lowercase_	    =   TFDebertaVaForTokenClassification(config=SCREAMING_SNAKE_CASE_			)
					lowercase_	    =   {
					    '''input_ids''': input_ids,
					    '''attention_mask''': input_mask,
					    '''token_type_ids''': token_type_ids,
					}
					lowercase_	    =   model(SCREAMING_SNAKE_CASE_			)
					self.parent.assertEqual(result.logits.shape			,				(self.batch_size, self.seq_length, self.num_labels)			)
	def 		_lowercase    (			self    :     Union[str, Any]			,				SCREAMING_SNAKE_CASE_    :     List[str]			,				SCREAMING_SNAKE_CASE_    :     List[Any]			,				SCREAMING_SNAKE_CASE_    :     int			,				SCREAMING_SNAKE_CASE_    :     Optional[Any]			,				SCREAMING_SNAKE_CASE_    :     List[Any]			,				SCREAMING_SNAKE_CASE_    :     List[Any]			,				SCREAMING_SNAKE_CASE_    :     Optional[int]			)			->	str:
					lowercase_	    =   TFDebertaVaForQuestionAnswering(config=SCREAMING_SNAKE_CASE_			)
					lowercase_	    =   {
					    '''input_ids''': input_ids,
					    '''attention_mask''': input_mask,
					    '''token_type_ids''': token_type_ids,
					}

					lowercase_	    =   model(SCREAMING_SNAKE_CASE_			)
					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    :     List[str]			)			->	Optional[int]:
					lowercase_	    =   self.prepare_config_and_inputs()
					(
					    (
					    lowercase_
					)    ,      (
					    lowercase_
					)    ,      (
					    lowercase_
					)    ,      (
					    lowercase_
					)    ,      (
					    lowercase_
					)    ,      (
					    lowercase_
					)    ,      (
					    lowercase_
					)    ,      
					)	    =   config_and_inputs
					lowercase_	    =   {'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': input_mask}
					return config, inputs_dict

@require_tf
class 					lowercase__(							UpperCAmelCase					,		UpperCAmelCase					,		unittest.TestCase				):



	"""simple docstring"""




	a     :str       	=      (
	    (
	        TFDebertaVaModel,
	        TFDebertaVaForMaskedLM,
	        TFDebertaVaForQuestionAnswering,
	        TFDebertaVaForSequenceClassification,
	        TFDebertaVaForTokenClassification,
	    )
	    if is_tf_available()
	    else ()
	)
	a     :int       	=      (
	    {
	        'feature-extraction': TFDebertaVaModel,
	        'fill-mask': TFDebertaVaForMaskedLM,
	        'question-answering': TFDebertaVaForQuestionAnswering,
	        'text-classification': TFDebertaVaForSequenceClassification,
	        'token-classification': TFDebertaVaForTokenClassification,
	        'zero-shot': TFDebertaVaForSequenceClassification,
	    }
	    if is_tf_available()
	    else {}
	)

	a     :int       	=      False
	a     :Any       	=      False
	def 		_lowercase    (			self    :     Dict			)			->	str:
					lowercase_	    =   TFDebertaVaModelTester(self			)
					lowercase_	    =   ConfigTester(self			,				config_class=SCREAMING_SNAKE_CASE_			,				hidden_size=3_7			)
	def 		_lowercase    (			self    :     Tuple			)			->	Dict:
					self.config_tester.run_common_tests()
	def 		_lowercase    (			self    :     Union[str, Any]			)			->	int:
					lowercase_	    =   self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE_			)
	def 		_lowercase    (			self    :     Dict			)			->	List[Any]:
					lowercase_	    =   self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_masked_lm(*SCREAMING_SNAKE_CASE_			)
	def 		_lowercase    (			self    :     Optional[Any]			)			->	Optional[int]:
					lowercase_	    =   self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_question_answering(*SCREAMING_SNAKE_CASE_			)
	def 		_lowercase    (			self    :     Any			)			->	str:
					lowercase_	    =   self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_sequence_classification(*SCREAMING_SNAKE_CASE_			)
	def 		_lowercase    (			self    :     Union[str, Any]			)			->	Optional[Any]:
					lowercase_	    =   self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_token_classification(*SCREAMING_SNAKE_CASE_			)




	@slow
	def 		_lowercase    (			self    :     Tuple			)			->	Dict:
					lowercase_	    =   TFDebertaVaModel.from_pretrained('''kamalkraj/deberta-v2-xlarge'''			)
					self.assertIsNotNone(SCREAMING_SNAKE_CASE_			)

@require_tf
class 					lowercase__(							unittest.TestCase				):



	"""simple docstring"""




	@unittest.skip(reason='''Model not available yet'''			)
	def 		_lowercase    (			self    :     Optional[Any]			)			->	Union[str, Any]:
					pass




	@slow
	def 		_lowercase    (			self    :     List[Any]			)			->	Dict:
					lowercase_	    =   TFDebertaVaModel.from_pretrained('''kamalkraj/deberta-v2-xlarge'''			)
					lowercase_	    =   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]]			)
					lowercase_	    =   tf.constant([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]			)
					lowercase_	    =   model(SCREAMING_SNAKE_CASE_			,				attention_mask=SCREAMING_SNAKE_CASE_			)[0]

					lowercase_	    =   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]			,				SCREAMING_SNAKE_CASE_			,				atol=1e-4			)










'''simple docstring'''







from __future__ import annotations

import unittest

import numpy as np

from transformers import BlipTextConfig
from transformers.testing_utils import require_tf, slow
from transformers.utils import is_tf_available

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


if is_tf_available():
    import tensorflow as tf

    from transformers import TFBlipTextModel
    from transformers.models.blip.modeling_tf_blip import TF_BLIP_PRETRAINED_MODEL_ARCHIVE_LIST

class 	_snake_case:






 def __init__(self       :  Any    ,		a       :  str    ,		a       :  Union[str, Any]=12    ,		a       :  List[str]=7    ,		a       :  Dict=True    ,		a       :  Tuple=True    ,		a       :  Any=True    ,		a       :  Optional[Any]=99    ,		a       :  Optional[Any]=32    ,		a       :  Tuple=32    ,		a       :  List[Any]=2    ,		a       :  str=4    ,		a       :  Dict=37    ,		a       :  Optional[Any]=0.1    ,		a       :  List[Any]=0.1    ,		a       :  Dict=5_12    ,		a       :  List[Any]=0.02    ,		a       :  Any=0    ,		a       :  Optional[int]=None    ,		)       ->   List[Any]:






    """simple docstring"""


    A__       =     parent
    A__       =     batch_size
    A__       =     seq_length
    A__       =     is_training
    A__       =     use_input_mask
    A__       =     use_labels
    A__       =     vocab_size
    A__       =     hidden_size
    A__       =     projection_dim
    A__       =     num_hidden_layers
    A__       =     num_attention_heads
    A__       =     intermediate_size
    A__       =     dropout
    A__       =     attention_dropout
    A__       =     max_position_embeddings
    A__       =     initializer_range
    A__       =     scope
    A__       =     bos_token_id






 def 						_UpperCamelCase (self       :  Union[str, Any]    )       ->   List[Any]:






    """simple docstring"""


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

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

    if input_mask is not None:
       A__       =     input_mask.numpy()
       A__  ,			A__       =     input_mask.shape
       A__       =     np.random.randint(1    ,		seq_length - 1    ,		size=(batch_size,)    )
       for batch_idx, start_index in enumerate(a    ):
          A__       =     1
          A__       =     0

    A__       =     self.get_config()

    return config, input_ids, tf.convert_to_tensor(a    )






 def 						_UpperCamelCase (self       :  Tuple    )       ->   Union[str, Any]:






    """simple docstring"""


    return BlipTextConfig(
        vocab_size=self.vocab_size    ,		hidden_size=self.hidden_size    ,		projection_dim=self.projection_dim    ,		num_hidden_layers=self.num_hidden_layers    ,		num_attention_heads=self.num_attention_heads    ,		intermediate_size=self.intermediate_size    ,		dropout=self.dropout    ,		attention_dropout=self.attention_dropout    ,		max_position_embeddings=self.max_position_embeddings    ,		initializer_range=self.initializer_range    ,		bos_token_id=self.bos_token_id    ,		)






 def 						_UpperCamelCase (self       :  Optional[int]    ,		a       :  Any    ,		a       :  List[Any]    ,		a       :  Union[str, Any]    )       ->   Any:






    """simple docstring"""


    A__       =     TFBlipTextModel(config=a    )
    A__       =     model(a    ,		attention_mask=a    ,		training=a    )
    A__       =     model(a    ,		training=a    )
    self.parent.assertEqual(result.last_hidden_state.shape    ,		(self.batch_size, self.seq_length, self.hidden_size)    )
    self.parent.assertEqual(result.pooler_output.shape    ,		(self.batch_size, self.hidden_size)    )






 def 						_UpperCamelCase (self       :  str    )       ->   List[Any]:






    """simple docstring"""


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




@require_tf
class 	_snake_case(			UpperCAmelCase       , unittest.TestCase      ):
 __snake_case:							Optional[int]						=					(TFBlipTextModel,) if is_tf_available() else ()
 __snake_case:							Union[str, Any]						=					False
 __snake_case:							Any						=					False
 __snake_case:							Union[str, Any]						=					False






 def 						_UpperCamelCase (self       :  Optional[Any]    )       ->   List[Any]:






    """simple docstring"""


    A__       =     BlipTextModelTester(self    )
    A__       =     ConfigTester(self    ,		config_class=a    ,		hidden_size=37    )






 def 						_UpperCamelCase (self       :  Tuple    )       ->   str:






    """simple docstring"""


    self.config_tester.run_common_tests()






 def 						_UpperCamelCase (self       :  Any    )       ->   Dict:






    """simple docstring"""


    A__       =     self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_model(*a    )






 def 						_UpperCamelCase (self       :  Dict    )       ->   Dict:






    """simple docstring"""


    pass






 def 						_UpperCamelCase (self       :  str    )       ->   int:






    """simple docstring"""


    pass






 @unittest.skip(reason='Blip does not use inputs_embeds'    )
 def 						_UpperCamelCase (self       :  Union[str, Any]    )       ->   str:






    """simple docstring"""


    pass






 @unittest.skip(reason='BlipTextModel has no base class and is not available in MODEL_MAPPING'    )
 def 						_UpperCamelCase (self       :  int    )       ->   List[Any]:






    """simple docstring"""


    pass






 @unittest.skip(reason='BlipTextModel has no base class and is not available in MODEL_MAPPING'    )
 def 						_UpperCamelCase (self       :  int    )       ->   Optional[Any]:






    """simple docstring"""


    pass






 @slow
 def 						_UpperCamelCase (self       :  int    )       ->   Optional[Any]:






    """simple docstring"""


    for model_name in TF_BLIP_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
       A__       =     TFBlipTextModel.from_pretrained(a    )
       self.assertIsNotNone(a    )






 def 						_UpperCamelCase (self       :  str    ,		a       :  Optional[int]=True    )       ->   List[Any]:






    """simple docstring"""


    super().test_pt_tf_model_equivalence(allow_missing_keys=a    )


