





from __future__ import annotations

import os
import tempfile
import unittest

from transformers import ConvBertConfig, 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 (
					    TFConvBertForMaskedLM,
					    TFConvBertForMultipleChoice,
					    TFConvBertForQuestionAnswering,
					    TFConvBertForSequenceClassification,
					    TFConvBertForTokenClassification,
					    TFConvBertModel,
					)


class   A      :
			'''simple docstring'''




			def __init__(      self       :   Optional[Any]							,     __lowerCAmelCase       :   Tuple							,     __lowerCAmelCase       :   Tuple=13							,     __lowerCAmelCase       :   Tuple=7							,     __lowerCAmelCase       :   List[Any]=True							,     __lowerCAmelCase       :   List[str]=True							,     __lowerCAmelCase       :   int=True							,     __lowerCAmelCase       :   Union[str, Any]=True							,     __lowerCAmelCase       :   Any=99							,     __lowerCAmelCase       :   List[str]=32							,     __lowerCAmelCase       :   str=2							,     __lowerCAmelCase       :   Tuple=4							,     __lowerCAmelCase       :   int=37							,     __lowerCAmelCase       :   Union[str, Any]="gelu"							,     __lowerCAmelCase       :   Union[str, Any]=0.1							,     __lowerCAmelCase       :   Any=0.1							,     __lowerCAmelCase       :   List[Any]=5_12							,     __lowerCAmelCase       :   str=16							,     __lowerCAmelCase       :   List[Any]=2							,     __lowerCAmelCase       :   str=0.0_2							,     __lowerCAmelCase       :   Dict=3							,     __lowerCAmelCase       :   Dict=4							,     __lowerCAmelCase       :   List[str]=None							,     )     ->     Dict:







					"""simple docstring"""






					A__  				=       parent
					A__  				=       13
					A__  				=       7
					A__  				=       True
					A__  				=       True
					A__  				=       True
					A__  				=       True
					A__  				=       99
					A__  				=       3_84
					A__  				=       2
					A__  				=       4
					A__  				=       37
					A__  				=       """gelu"""
					A__  				=       0.1
					A__  				=       0.1
					A__  				=       5_12
					A__  				=       16
					A__  				=       2
					A__  				=       0.0_2
					A__  				=       3
					A__  				=       4
					A__  				=       1_28
					A__  				=       2
					A__  				=       9
					A__  				=       1
					A__  				=       None






			def        a_	(      self       :   Tuple       )     ->     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]       )

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

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

					A__  				=       ConvBertConfig(
					    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							,     return_dict=__lowerCAmelCase							,     )

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






			def        a_	(      self       :   Tuple							,     __lowerCAmelCase       :   int							,     __lowerCAmelCase       :   Any							,     __lowerCAmelCase       :   Optional[int]							,     __lowerCAmelCase       :   List[str]							,     __lowerCAmelCase       :   List[str]							,     __lowerCAmelCase       :   Optional[Any]							,     __lowerCAmelCase       :   Tuple       )     ->     Dict:







					"""simple docstring"""






					A__  				=       TFConvBertModel(config=__lowerCAmelCase       )
					A__  				=       {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}

					A__  				=       [input_ids, input_mask]
					A__  				=       model(__lowerCAmelCase       )

					A__  				=       model(__lowerCAmelCase       )

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






			def        a_	(      self       :   str							,     __lowerCAmelCase       :   Dict							,     __lowerCAmelCase       :   List[str]							,     __lowerCAmelCase       :   Optional[int]							,     __lowerCAmelCase       :   Optional[Any]							,     __lowerCAmelCase       :   Dict							,     __lowerCAmelCase       :   str							,     __lowerCAmelCase       :   str       )     ->     int:







					"""simple docstring"""






					A__  				=       TFConvBertForMaskedLM(config=__lowerCAmelCase       )
					A__  				=       {
					    """input_ids""": input_ids,
					    """attention_mask""": input_mask,
					    """token_type_ids""": token_type_ids,
					}
					A__  				=       model(__lowerCAmelCase       )
					self.parent.assertEqual(result.logits.shape							,     (self.batch_size, self.seq_length, self.vocab_size)       )






			def        a_	(      self       :   int							,     __lowerCAmelCase       :   int							,     __lowerCAmelCase       :   str							,     __lowerCAmelCase       :   int							,     __lowerCAmelCase       :   int							,     __lowerCAmelCase       :   Union[str, Any]							,     __lowerCAmelCase       :   Tuple							,     __lowerCAmelCase       :   int       )     ->     Any:







					"""simple docstring"""






					A__  				=       self.num_labels
					A__  				=       TFConvBertForSequenceClassification(config=__lowerCAmelCase       )
					A__  				=       {
					    """input_ids""": input_ids,
					    """attention_mask""": input_mask,
					    """token_type_ids""": token_type_ids,
					}

					A__  				=       model(__lowerCAmelCase       )
					self.parent.assertEqual(result.logits.shape							,     (self.batch_size, self.num_labels)       )






			def        a_	(      self       :   Tuple							,     __lowerCAmelCase       :   List[str]							,     __lowerCAmelCase       :   List[Any]							,     __lowerCAmelCase       :   Union[str, Any]							,     __lowerCAmelCase       :   Any							,     __lowerCAmelCase       :   Any							,     __lowerCAmelCase       :   str							,     __lowerCAmelCase       :   List[str]       )     ->     Any:







					"""simple docstring"""






					A__  				=       self.num_choices
					A__  				=       TFConvBertForMultipleChoice(config=__lowerCAmelCase       )
					A__  				=       tf.tile(tf.expand_dims(__lowerCAmelCase							,     1       )							,     (1, self.num_choices, 1)       )
					A__  				=       tf.tile(tf.expand_dims(__lowerCAmelCase							,     1       )							,     (1, self.num_choices, 1)       )
					A__  				=       tf.tile(tf.expand_dims(__lowerCAmelCase							,     1       )							,     (1, self.num_choices, 1)       )
					A__  				=       {
					    """input_ids""": multiple_choice_inputs_ids,
					    """attention_mask""": multiple_choice_input_mask,
					    """token_type_ids""": multiple_choice_token_type_ids,
					}
					A__  				=       model(__lowerCAmelCase       )
					self.parent.assertEqual(result.logits.shape							,     (self.batch_size, self.num_choices)       )






			def        a_	(      self       :   List[Any]							,     __lowerCAmelCase       :   List[str]							,     __lowerCAmelCase       :   List[str]							,     __lowerCAmelCase       :   Optional[Any]							,     __lowerCAmelCase       :   List[str]							,     __lowerCAmelCase       :   List[str]							,     __lowerCAmelCase       :   Optional[Any]							,     __lowerCAmelCase       :   str       )     ->     List[Any]:







					"""simple docstring"""






					A__  				=       self.num_labels
					A__  				=       TFConvBertForTokenClassification(config=__lowerCAmelCase       )
					A__  				=       {
					    """input_ids""": input_ids,
					    """attention_mask""": input_mask,
					    """token_type_ids""": token_type_ids,
					}
					A__  				=       model(__lowerCAmelCase       )
					self.parent.assertEqual(result.logits.shape							,     (self.batch_size, self.seq_length, self.num_labels)       )






			def        a_	(      self       :   Optional[int]							,     __lowerCAmelCase       :   Dict							,     __lowerCAmelCase       :   Any							,     __lowerCAmelCase       :   Dict							,     __lowerCAmelCase       :   str							,     __lowerCAmelCase       :   Optional[int]							,     __lowerCAmelCase       :   int							,     __lowerCAmelCase       :   Any       )     ->     Tuple:







					"""simple docstring"""






					A__  				=       TFConvBertForQuestionAnswering(config=__lowerCAmelCase       )
					A__  				=       {
					    """input_ids""": input_ids,
					    """attention_mask""": input_mask,
					    """token_type_ids""": token_type_ids,
					}

					A__  				=       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        a_	(      self       :   Optional[int]       )     ->     Optional[int]:







					"""simple docstring"""






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


@require_tf
class   A      (SCREAMING_SNAKE_CASE       ,					SCREAMING_SNAKE_CASE       ,					unittest.TestCase   ):
			'''simple docstring'''




			__lowerCamelCase     :	Any          =   (
			    (
			        TFConvBertModel,
			        TFConvBertForMaskedLM,
			        TFConvBertForQuestionAnswering,
			        TFConvBertForSequenceClassification,
			        TFConvBertForTokenClassification,
			        TFConvBertForMultipleChoice,
			    )
			    if is_tf_available()
			    else ()
			)
			__lowerCamelCase     :	int          =   (
			    {
			        '''feature-extraction''': TFConvBertModel,
			        '''fill-mask''': TFConvBertForMaskedLM,
			        '''question-answering''': TFConvBertForQuestionAnswering,
			        '''text-classification''': TFConvBertForSequenceClassification,
			        '''token-classification''': TFConvBertForTokenClassification,
			        '''zero-shot''': TFConvBertForSequenceClassification,
			    }
			    if is_tf_available()
			    else {}
			)
			__lowerCamelCase     :	Tuple          =   False
			__lowerCamelCase     :	Optional[int]          =   False
			__lowerCamelCase     :	int          =   False






			def        a_	(      self       :   List[Any]       )     ->     Tuple:







					"""simple docstring"""






					A__  				=       TFConvBertModelTester(self       )
					A__  				=       ConfigTester(self							,     config_class=__lowerCAmelCase							,     hidden_size=37       )






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







					"""simple docstring"""






					self.config_tester.run_common_tests()






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







					"""simple docstring"""






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






			def        a_	(      self       :   List[Any]       )     ->     Tuple:







					"""simple docstring"""






					A__  				=       self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_masked_lm(*__lowerCAmelCase       )






			def        a_	(      self       :   Optional[int]       )     ->     int:







					"""simple docstring"""






					A__  				=       self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_multiple_choice(*__lowerCAmelCase       )






			def        a_	(      self       :   str       )     ->     Dict:







					"""simple docstring"""






					A__  				=       self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_question_answering(*__lowerCAmelCase       )






			def        a_	(      self       :   Dict       )     ->     int:







					"""simple docstring"""






					A__  				=       self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_sequence_classification(*__lowerCAmelCase       )






			def        a_	(      self       :   str       )     ->     Tuple:







					"""simple docstring"""






					A__  				=       self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_token_classification(*__lowerCAmelCase       )






			@slow
			def        a_	(      self       :   Any       )     ->     Union[str, Any]:







					"""simple docstring"""






					A__				,      A__  				=       self.model_tester.prepare_config_and_inputs_for_common()
					A__  				=       True
					A__  				=       True

					if hasattr(__lowerCAmelCase							,     """use_cache"""       ):
							A__  				=       True

					A__  				=       getattr(self.model_tester							,     """encoder_seq_length"""							,     self.model_tester.seq_length       )
					A__  				=       getattr(self.model_tester							,     """key_length"""							,     __lowerCAmelCase       )

					for model_class in self.all_model_classes:
							A__  				=       self._prepare_for_class(__lowerCAmelCase							,     __lowerCAmelCase       )
							A__  				=       model_class(__lowerCAmelCase       )
							A__  				=       len(model(__lowerCAmelCase       )       )

							with tempfile.TemporaryDirectory() as tmpdirname:
									model.save_pretrained(__lowerCAmelCase							,     saved_model=__lowerCAmelCase       )
									A__  				=       os.path.join(__lowerCAmelCase							,     """saved_model"""							,     """1"""       )
									A__  				=       tf.keras.models.load_model(__lowerCAmelCase       )
									A__  				=       model(__lowerCAmelCase       )

									if self.is_encoder_decoder:
											A__  				=       outputs["""encoder_hidden_states"""]
											A__  				=       outputs["""encoder_attentions"""]
									else:
											A__  				=       outputs["""hidden_states"""]
											A__  				=       outputs["""attentions"""]

									self.assertEqual(len(__lowerCAmelCase       )							,     __lowerCAmelCase       )

									A__  				=       getattr(
									    self.model_tester							,     """expected_num_hidden_layers"""							,     self.model_tester.num_hidden_layers + 1       )

									self.assertEqual(len(__lowerCAmelCase       )							,     __lowerCAmelCase       )
									self.assertListEqual(
									    list(output_hidden_states[0].shape[-2:]       )							,     [self.model_tester.seq_length, self.model_tester.hidden_size]							,     )

									self.assertEqual(len(__lowerCAmelCase       )							,     self.model_tester.num_hidden_layers       )
									self.assertListEqual(
									    list(output_attentions[0].shape[-3:]       )							,     [self.model_tester.num_attention_heads / 2, encoder_seq_length, encoder_key_length]							,     )






			@slow
			def        a_	(      self       :   Optional[Any]       )     ->     str:







					"""simple docstring"""






					A__  				=       TFConvBertModel.from_pretrained("""YituTech/conv-bert-base"""       )
					self.assertIsNotNone(__lowerCAmelCase       )







			def        a_	(      self       :   Any       )     ->     Optional[int]:







					"""simple docstring"""






					A__				,      A__  				=       self.model_tester.prepare_config_and_inputs_for_common()
					A__  				=       True
					A__  				=       getattr(self.model_tester							,     """decoder_seq_length"""							,     self.model_tester.seq_length       )
					A__  				=       getattr(self.model_tester							,     """encoder_seq_length"""							,     self.model_tester.seq_length       )
					A__  				=       getattr(self.model_tester							,     """key_length"""							,     __lowerCAmelCase       )
					A__  				=       getattr(self.model_tester							,     """key_length"""							,     __lowerCAmelCase       )

					def check_decoder_attentions_output(__lowerCAmelCase       :   Optional[Any]       ):
							A__  				=       len(__lowerCAmelCase       )
							self.assertEqual(out_len % 2							,     0       )
							A__  				=       outputs.decoder_attentions
							self.assertEqual(len(__lowerCAmelCase       )							,     self.model_tester.num_hidden_layers       )
							self.assertListEqual(
							    list(decoder_attentions[0].shape[-3:]       )							,     [self.model_tester.num_attention_heads / 2, decoder_seq_length, decoder_key_length]							,     )

					def check_encoder_attentions_output(__lowerCAmelCase       :   Optional[Any]       ):
							A__  				=       [
							    t.numpy() for t in (outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions)
							]
							self.assertEqual(len(__lowerCAmelCase       )							,     self.model_tester.num_hidden_layers       )
							self.assertListEqual(
							    list(attentions[0].shape[-3:]       )							,     [self.model_tester.num_attention_heads / 2, encoder_seq_length, encoder_key_length]							,     )

					for model_class in self.all_model_classes:
							A__  				=       True
							A__  				=       False
							A__  				=       model_class(__lowerCAmelCase       )
							A__  				=       model(self._prepare_for_class(__lowerCAmelCase							,     __lowerCAmelCase       )       )
							A__  				=       len(__lowerCAmelCase       )
							self.assertEqual(config.output_hidden_states							,     __lowerCAmelCase       )
							check_encoder_attentions_output(__lowerCAmelCase       )

							if self.is_encoder_decoder:
									A__  				=       model_class(__lowerCAmelCase       )
									A__  				=       model(self._prepare_for_class(__lowerCAmelCase							,     __lowerCAmelCase       )       )
									self.assertEqual(config.output_hidden_states							,     __lowerCAmelCase       )
									check_decoder_attentions_output(__lowerCAmelCase       )

							# Check that output attentions can also be changed via the config
							del inputs_dict["output_attentions"]
							A__  				=       True
							A__  				=       model_class(__lowerCAmelCase       )
							A__  				=       model(self._prepare_for_class(__lowerCAmelCase							,     __lowerCAmelCase       )       )
							self.assertEqual(config.output_hidden_states							,     __lowerCAmelCase       )
							check_encoder_attentions_output(__lowerCAmelCase       )

							# Check attention is always last and order is fine
							A__  				=       True
							A__  				=       True
							A__  				=       model_class(__lowerCAmelCase       )
							A__  				=       model(self._prepare_for_class(__lowerCAmelCase							,     __lowerCAmelCase       )       )

							self.assertEqual(out_len + (2 if self.is_encoder_decoder else 1)							,     len(__lowerCAmelCase       )       )
							self.assertEqual(model.config.output_hidden_states							,     __lowerCAmelCase       )
							check_encoder_attentions_output(__lowerCAmelCase       )


@require_tf
class   A      (unittest.TestCase   ):
			'''simple docstring'''




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







					"""simple docstring"""






					A__  				=       TFConvBertModel.from_pretrained("""YituTech/conv-bert-base"""       )
					A__  				=       tf.constant([[0, 1, 2, 3, 4, 5]]       )
					A__  				=       model(__lowerCAmelCase       )[0]

					A__  				=       [1, 6, 7_68]
					self.assertEqual(output.shape							,     __lowerCAmelCase       )

					A__  				=       tf.constant(
					    [
					        [
					            [-0.0_3_4_7_5_4_9_3, -0.4_6_8_6_0_3_4, -0.3_0_6_3_8_8_3_2],
					            [0.2_2_6_3_7_2_4_8, -0.2_6_9_8_8_6_4_6, -0.7_4_2_3_4_2_4],
					            [0.1_0_3_2_4_8_6_8, -0.4_5_0_1_3_5_0_8, -0.5_8_2_8_0_7_8_4],
					        ]
					    ]       )
					tf.debugging.assert_near(output[:, :3, :3]							,     __lowerCAmelCase							,     atol=1e-4       )










from typing import TYPE_CHECKING

from ...utils import _LazyModule


A   : Optional[Any]			=				{'''processing_wav2vec2_with_lm''': ['''Wav2Vec2ProcessorWithLM''']}


if TYPE_CHECKING:
					from .processing_wavaveca_with_lm import WavaVecaProcessorWithLM
else:
					import sys

					A   : List[str]			=				_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)



