

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







			'''simple docstring'''

			def __init__(	self					:							Tuple				,  _UpperCamelCase					:							Optional[int]				,  _UpperCamelCase					:							Union[str, Any]=1_3				,  _UpperCamelCase					:							Dict=7				,  _UpperCamelCase					:							List[str]=True				,  _UpperCamelCase					:							Any=True				,  _UpperCamelCase					:							Union[str, Any]=True				,  _UpperCamelCase					:							List[Any]=True				,  _UpperCamelCase					:							str=9_9				,  _UpperCamelCase					:							str=3_2				,  _UpperCamelCase					:							Union[str, Any]=2				,  _UpperCamelCase					:							Optional[Any]=4				,  _UpperCamelCase					:							Any=3_7				,  _UpperCamelCase					:							Tuple="gelu"				,  _UpperCamelCase					:							Optional[Any]=0.1				,  _UpperCamelCase					:							List[Any]=0.1				,  _UpperCamelCase					:							Union[str, Any]=5_1_2				,  _UpperCamelCase					:							Optional[int]=1_6				,  _UpperCamelCase					:							Tuple=2				,  _UpperCamelCase					:							Optional[Any]=0.02				,  _UpperCamelCase					:							Union[str, Any]=3				,  _UpperCamelCase					:							Optional[Any]=4				,  _UpperCamelCase					:							List[str]=None				,  ) ->Tuple:
									snake_case_  =      parent
									snake_case_  =      1_3
									snake_case_  =      7
									snake_case_  =      True
									snake_case_  =      True
									snake_case_  =      True
									snake_case_  =      True
									snake_case_  =      9_9
									snake_case_  =      3_8_4
									snake_case_  =      2
									snake_case_  =      4
									snake_case_  =      3_7
									snake_case_  =      '''gelu'''
									snake_case_  =      0.1
									snake_case_  =      0.1
									snake_case_  =      5_1_2
									snake_case_  =      1_6
									snake_case_  =      2
									snake_case_  =      0.02
									snake_case_  =      3
									snake_case_  =      4
									snake_case_  =      1_2_8
									snake_case_  =      2
									snake_case_  =      9
									snake_case_  =      1
									snake_case_  =      None







			def 							snake_case__(	self					:							Optional[Any]				) ->Optional[int]:
									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_  =      ids_tensor([self.batch_size]				,  self.num_choices				)

									snake_case_  =      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=_UpperCamelCase				,  )

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







			def 							snake_case__(	self					:							Optional[int]				,  _UpperCamelCase					:							Any				,  _UpperCamelCase					:							Union[str, Any]				,  _UpperCamelCase					:							List[Any]				,  _UpperCamelCase					:							Any				,  _UpperCamelCase					:							Dict				,  _UpperCamelCase					:							Optional[Any]				,  _UpperCamelCase					:							int				) ->Optional[int]:
									snake_case_  =      TFConvBertModel(config=_UpperCamelCase				)
									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(_UpperCamelCase				)

									snake_case_  =      model(_UpperCamelCase				)

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







			def 							snake_case__(	self					:							str				,  _UpperCamelCase					:							List[Any]				,  _UpperCamelCase					:							Optional[Any]				,  _UpperCamelCase					:							Tuple				,  _UpperCamelCase					:							str				,  _UpperCamelCase					:							Optional[int]				,  _UpperCamelCase					:							Tuple				,  _UpperCamelCase					:							Union[str, Any]				) ->Optional[int]:
									snake_case_  =      TFConvBertForMaskedLM(config=_UpperCamelCase				)
									snake_case_  =      {
									    '''input_ids''': input_ids,
									    '''attention_mask''': input_mask,
									    '''token_type_ids''': token_type_ids,
									}
									snake_case_  =      model(_UpperCamelCase				)
									self.parent.assertEqual(result.logits.shape				,  (self.batch_size, self.seq_length, self.vocab_size)				)







			def 							snake_case__(	self					:							Tuple				,  _UpperCamelCase					:							Any				,  _UpperCamelCase					:							Tuple				,  _UpperCamelCase					:							Union[str, Any]				,  _UpperCamelCase					:							int				,  _UpperCamelCase					:							str				,  _UpperCamelCase					:							int				,  _UpperCamelCase					:							List[Any]				) ->Dict:
									snake_case_  =      self.num_labels
									snake_case_  =      TFConvBertForSequenceClassification(config=_UpperCamelCase				)
									snake_case_  =      {
									    '''input_ids''': input_ids,
									    '''attention_mask''': input_mask,
									    '''token_type_ids''': token_type_ids,
									}

									snake_case_  =      model(_UpperCamelCase				)
									self.parent.assertEqual(result.logits.shape				,  (self.batch_size, self.num_labels)				)







			def 							snake_case__(	self					:							List[Any]				,  _UpperCamelCase					:							Dict				,  _UpperCamelCase					:							Optional[int]				,  _UpperCamelCase					:							int				,  _UpperCamelCase					:							int				,  _UpperCamelCase					:							List[Any]				,  _UpperCamelCase					:							int				,  _UpperCamelCase					:							List[Any]				) ->str:
									snake_case_  =      self.num_choices
									snake_case_  =      TFConvBertForMultipleChoice(config=_UpperCamelCase				)
									snake_case_  =      tf.tile(tf.expand_dims(_UpperCamelCase				,  1				)				,  (1, self.num_choices, 1)				)
									snake_case_  =      tf.tile(tf.expand_dims(_UpperCamelCase				,  1				)				,  (1, self.num_choices, 1)				)
									snake_case_  =      tf.tile(tf.expand_dims(_UpperCamelCase				,  1				)				,  (1, self.num_choices, 1)				)
									snake_case_  =      {
									    '''input_ids''': multiple_choice_inputs_ids,
									    '''attention_mask''': multiple_choice_input_mask,
									    '''token_type_ids''': multiple_choice_token_type_ids,
									}
									snake_case_  =      model(_UpperCamelCase				)
									self.parent.assertEqual(result.logits.shape				,  (self.batch_size, self.num_choices)				)







			def 							snake_case__(	self					:							Any				,  _UpperCamelCase					:							int				,  _UpperCamelCase					:							Optional[int]				,  _UpperCamelCase					:							Optional[int]				,  _UpperCamelCase					:							Optional[Any]				,  _UpperCamelCase					:							List[Any]				,  _UpperCamelCase					:							Dict				,  _UpperCamelCase					:							Optional[int]				) ->str:
									snake_case_  =      self.num_labels
									snake_case_  =      TFConvBertForTokenClassification(config=_UpperCamelCase				)
									snake_case_  =      {
									    '''input_ids''': input_ids,
									    '''attention_mask''': input_mask,
									    '''token_type_ids''': token_type_ids,
									}
									snake_case_  =      model(_UpperCamelCase				)
									self.parent.assertEqual(result.logits.shape				,  (self.batch_size, self.seq_length, self.num_labels)				)







			def 							snake_case__(	self					:							Optional[Any]				,  _UpperCamelCase					:							Tuple				,  _UpperCamelCase					:							Dict				,  _UpperCamelCase					:							Dict				,  _UpperCamelCase					:							List[Any]				,  _UpperCamelCase					:							str				,  _UpperCamelCase					:							Optional[int]				,  _UpperCamelCase					:							Optional[Any]				) ->Tuple:
									snake_case_  =      TFConvBertForQuestionAnswering(config=_UpperCamelCase				)
									snake_case_  =      {
									    '''input_ids''': input_ids,
									    '''attention_mask''': input_mask,
									    '''token_type_ids''': token_type_ids,
									}

									snake_case_  =      model(_UpperCamelCase				)
									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					:							List[str]				) ->List[Any]:
									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       snake_case_  (						__A      ,			__A      ,			unittest.TestCase   ):







			'''simple docstring'''

			SCREAMING_SNAKE_CASE	:  int		     =							(
			    (
			        TFConvBertModel,
			        TFConvBertForMaskedLM,
			        TFConvBertForQuestionAnswering,
			        TFConvBertForSequenceClassification,
			        TFConvBertForTokenClassification,
			        TFConvBertForMultipleChoice,
			    )
			    if is_tf_available()
			    else ()
			)
			SCREAMING_SNAKE_CASE	:  Dict		     =							(
			    {
			        "feature-extraction": TFConvBertModel,
			        "fill-mask": TFConvBertForMaskedLM,
			        "question-answering": TFConvBertForQuestionAnswering,
			        "text-classification": TFConvBertForSequenceClassification,
			        "token-classification": TFConvBertForTokenClassification,
			        "zero-shot": TFConvBertForSequenceClassification,
			    }
			    if is_tf_available()
			    else {}
			)
			SCREAMING_SNAKE_CASE	:  Dict		     =							False
			SCREAMING_SNAKE_CASE	:  Union[str, Any]		     =							False
			SCREAMING_SNAKE_CASE	:  int		     =							False







			def 							snake_case__(	self					:							str				) ->Union[str, Any]:
									snake_case_  =      TFConvBertModelTester(self				)
									snake_case_  =      ConfigTester(self				,  config_class=_UpperCamelCase				,  hidden_size=3_7				)







			def 							snake_case__(	self					:							List[str]				) ->Optional[Any]:
									self.config_tester.run_common_tests()







			def 							snake_case__(	self					:							str				) ->Optional[Any]:
									snake_case_  =      self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*_UpperCamelCase				)







			def 							snake_case__(	self					:							Optional[Any]				) ->List[str]:
									snake_case_  =      self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_masked_lm(*_UpperCamelCase				)







			def 							snake_case__(	self					:							str				) ->Dict:
									snake_case_  =      self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_multiple_choice(*_UpperCamelCase				)







			def 							snake_case__(	self					:							int				) ->str:
									snake_case_  =      self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_question_answering(*_UpperCamelCase				)







			def 							snake_case__(	self					:							Optional[int]				) ->str:
									snake_case_  =      self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_sequence_classification(*_UpperCamelCase				)







			def 							snake_case__(	self					:							str				) ->Union[str, Any]:
									snake_case_  =      self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_token_classification(*_UpperCamelCase				)







			@slow
			def 							snake_case__(	self					:							str				) ->str:
									snake_case_,       snake_case_  =      self.model_tester.prepare_config_and_inputs_for_common()
									snake_case_  =      True
									snake_case_  =      True

									if hasattr(_UpperCamelCase				,  '''use_cache'''				):
															snake_case_  =      True

									snake_case_  =      getattr(self.model_tester				,  '''encoder_seq_length'''				,  self.model_tester.seq_length				)
									snake_case_  =      getattr(self.model_tester				,  '''key_length'''				,  _UpperCamelCase				)

									for model_class in self.all_model_classes:
															snake_case_  =      self._prepare_for_class(_UpperCamelCase				,  _UpperCamelCase				)
															snake_case_  =      model_class(_UpperCamelCase				)
															snake_case_  =      len(model(_UpperCamelCase				)				)

															with tempfile.TemporaryDirectory() as tmpdirname:
																					model.save_pretrained(_UpperCamelCase				,  saved_model=_UpperCamelCase				)
																					snake_case_  =      os.path.join(_UpperCamelCase				,  '''saved_model'''				,  '''1'''				)
																					snake_case_  =      tf.keras.models.load_model(_UpperCamelCase				)
																					snake_case_  =      model(_UpperCamelCase				)

																					if self.is_encoder_decoder:
																											snake_case_  =      outputs['''encoder_hidden_states''']
																											snake_case_  =      outputs['''encoder_attentions''']
																					else:
																											snake_case_  =      outputs['''hidden_states''']
																											snake_case_  =      outputs['''attentions''']

																					self.assertEqual(len(_UpperCamelCase				)				,  _UpperCamelCase				)

																					snake_case_  =      getattr(
																					    self.model_tester				,  '''expected_num_hidden_layers'''				,  self.model_tester.num_hidden_layers + 1				)

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

																					self.assertEqual(len(_UpperCamelCase				)				,  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 							snake_case__(	self					:							Union[str, Any]				) ->Tuple:
									snake_case_  =      TFConvBertModel.from_pretrained('''YituTech/conv-bert-base'''				)
									self.assertIsNotNone(_UpperCamelCase				)







			def 							snake_case__(	self					:							List[str]				) ->Any:
									snake_case_,       snake_case_  =      self.model_tester.prepare_config_and_inputs_for_common()
									snake_case_  =      True
									snake_case_  =      getattr(self.model_tester				,  '''decoder_seq_length'''				,  self.model_tester.seq_length				)
									snake_case_  =      getattr(self.model_tester				,  '''encoder_seq_length'''				,  self.model_tester.seq_length				)
									snake_case_  =      getattr(self.model_tester				,  '''key_length'''				,  _UpperCamelCase				)
									snake_case_  =      getattr(self.model_tester				,  '''key_length'''				,  _UpperCamelCase				)

									def check_decoder_attentions_output(_UpperCamelCase					:							List[Any]				):
															snake_case_  =      len(_UpperCamelCase				)
															self.assertEqual(out_len % 2				,  0				)
															snake_case_  =      outputs.decoder_attentions
															self.assertEqual(len(_UpperCamelCase				)				,  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(_UpperCamelCase					:							Dict				):
															snake_case_  =      [
															    t.numpy() for t in (outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions)
															]
															self.assertEqual(len(_UpperCamelCase				)				,  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:
															snake_case_  =      True
															snake_case_  =      False
															snake_case_  =      model_class(_UpperCamelCase				)
															snake_case_  =      model(self._prepare_for_class(_UpperCamelCase				,  _UpperCamelCase				)				)
															snake_case_  =      len(_UpperCamelCase				)
															self.assertEqual(config.output_hidden_states				,  _UpperCamelCase				)
															check_encoder_attentions_output(_UpperCamelCase				)

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

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

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

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






@require_tf
class       snake_case_  (						unittest.TestCase   ):







			'''simple docstring'''

			@slow
			def 							snake_case__(	self					:							Any				) ->int:
									snake_case_  =      TFConvBertModel.from_pretrained('''YituTech/conv-bert-base'''				)
									snake_case_  =      tf.constant([[0, 1, 2, 3, 4, 5]]				)
									snake_case_  =      model(_UpperCamelCase				)[0]

									snake_case_  =      [1, 6, 7_6_8]
									self.assertEqual(output.shape				,  _UpperCamelCase				)

									snake_case_  =      tf.constant(
									    [
									        [
									            [-0.03475493, -0.4686034, -0.30638832],
									            [0.22637248, -0.26988646, -0.7423424],
									            [0.10324868, -0.45013508, -0.58280784],
									        ]
									    ]				)
									tf.debugging.assert_near(output[:, :3, :3]				,  _UpperCamelCase				,  atol=1e-4				)


import warnings

from diffusers import StableDiffusionInpaintPipeline as StableDiffusionInpaintPipeline  # noqa F401


warnings.warn(
    '''The `inpainting.py` script is outdated. Please use directly `from diffusers import'''
    ''' StableDiffusionInpaintPipeline` instead.'''
)





