






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   __SCREAMING_SNAKE_CASE:
							def __init__(     self:      Dict       ,	UpperCamelCase:      Dict       ,	UpperCamelCase:      List[str]=13       ,	UpperCamelCase:      Optional[Any]=7       ,	UpperCamelCase:      Optional[Any]=True       ,	UpperCamelCase:      Dict=True       ,	UpperCamelCase:      int=True       ,	UpperCamelCase:      Tuple=True       ,	UpperCamelCase:      Union[str, Any]=99       ,	UpperCamelCase:      List[Any]=32       ,	UpperCamelCase:      List[Any]=2       ,	UpperCamelCase:      Dict=4       ,	UpperCamelCase:      Any=37       ,	UpperCamelCase:      List[Any]="gelu"       ,	UpperCamelCase:      Optional[int]=0.1       ,	UpperCamelCase:      Optional[int]=0.1       ,	UpperCamelCase:      Optional[int]=5_12       ,	UpperCamelCase:      Any=16       ,	UpperCamelCase:      Tuple=2       ,	UpperCamelCase:      List[str]=0.02       ,	UpperCamelCase:      Tuple=3       ,	UpperCamelCase:      Optional[Any]=4       ,	UpperCamelCase:      Tuple=None       ,	)		->		Any:
											snake_case__									=     parent
											snake_case__									=     13
											snake_case__									=     7
											snake_case__									=     True
											snake_case__									=     True
											snake_case__									=     True
											snake_case__									=     True
											snake_case__									=     99
											snake_case__									=     3_84
											snake_case__									=     2
											snake_case__									=     4
											snake_case__									=     37
											snake_case__									=     'gelu'
											snake_case__									=     0.1
											snake_case__									=     0.1
											snake_case__									=     5_12
											snake_case__									=     16
											snake_case__									=     2
											snake_case__									=     0.02
											snake_case__									=     3
											snake_case__									=     4
											snake_case__									=     1_28
											snake_case__									=     2
											snake_case__									=     9
											snake_case__									=     1
											snake_case__									=     None
							def lowerCAmelCase_ (     self:      List[Any]						)		->		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 lowerCAmelCase_ (     self:      Tuple       ,	UpperCamelCase:      Optional[int]       ,	UpperCamelCase:      Optional[int]       ,	UpperCamelCase:      Union[str, Any]       ,	UpperCamelCase:      Optional[int]       ,	UpperCamelCase:      List[Any]       ,	UpperCamelCase:      Tuple       ,	UpperCamelCase:      List[str]						)		->		Union[str, Any]:
											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 lowerCAmelCase_ (     self:      Dict       ,	UpperCamelCase:      str       ,	UpperCamelCase:      Tuple       ,	UpperCamelCase:      int       ,	UpperCamelCase:      Any       ,	UpperCamelCase:      int       ,	UpperCamelCase:      Optional[int]       ,	UpperCamelCase:      Tuple						)		->		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 lowerCAmelCase_ (     self:      List[Any]       ,	UpperCamelCase:      int       ,	UpperCamelCase:      int       ,	UpperCamelCase:      str       ,	UpperCamelCase:      str       ,	UpperCamelCase:      str       ,	UpperCamelCase:      Optional[Any]       ,	UpperCamelCase:      Any						)		->		Union[str, Any]:
											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 lowerCAmelCase_ (     self:      List[Any]       ,	UpperCamelCase:      Tuple       ,	UpperCamelCase:      List[Any]       ,	UpperCamelCase:      Optional[int]       ,	UpperCamelCase:      Optional[Any]       ,	UpperCamelCase:      Dict       ,	UpperCamelCase:      Optional[Any]       ,	UpperCamelCase:      Optional[Any]						)		->		Optional[int]:
											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 lowerCAmelCase_ (     self:      Dict       ,	UpperCamelCase:      Union[str, Any]       ,	UpperCamelCase:      Union[str, Any]       ,	UpperCamelCase:      List[str]       ,	UpperCamelCase:      int       ,	UpperCamelCase:      List[str]       ,	UpperCamelCase:      Optional[int]       ,	UpperCamelCase:      Dict						)		->		Dict:
											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 lowerCAmelCase_ (     self:      List[Any]       ,	UpperCamelCase:      Any       ,	UpperCamelCase:      Tuple       ,	UpperCamelCase:      Tuple       ,	UpperCamelCase:      Optional[int]       ,	UpperCamelCase:      Any       ,	UpperCamelCase:      Union[str, Any]       ,	UpperCamelCase:      Tuple						)		->		Optional[int]:
											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 lowerCAmelCase_ (     self:      List[Any]						)		->		Union[str, 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   __SCREAMING_SNAKE_CASE(	a_    ,  a_    ,  unittest.TestCase	):
							_UpperCAmelCase     =       (
							    (
							        TFConvBertModel,
							        TFConvBertForMaskedLM,
							        TFConvBertForQuestionAnswering,
							        TFConvBertForSequenceClassification,
							        TFConvBertForTokenClassification,
							        TFConvBertForMultipleChoice,
							    )
							    if is_tf_available()
							    else ()
							)
							_UpperCAmelCase     =       (
							    {
							        "feature-extraction": TFConvBertModel,
							        "fill-mask": TFConvBertForMaskedLM,
							        "question-answering": TFConvBertForQuestionAnswering,
							        "text-classification": TFConvBertForSequenceClassification,
							        "token-classification": TFConvBertForTokenClassification,
							        "zero-shot": TFConvBertForSequenceClassification,
							    }
							    if is_tf_available()
							    else {}
							)
							_UpperCAmelCase     =       False
							_UpperCAmelCase     =       False
							_UpperCAmelCase     =       False
							def lowerCAmelCase_ (     self:      Optional[Any]						)		->		Tuple:
											snake_case__									=     TFConvBertModelTester(self						)
											snake_case__									=     ConfigTester(self       ,	config_class=UpperCamelCase       ,	hidden_size=37						)
							def lowerCAmelCase_ (     self:      Optional[Any]						)		->		Optional[Any]:
											self.config_tester.run_common_tests()
							def lowerCAmelCase_ (     self:      List[Any]						)		->		Tuple:
											snake_case__									=     self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_model(*UpperCamelCase						)
							def lowerCAmelCase_ (     self:      List[str]						)		->		Union[str, Any]:
											snake_case__									=     self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_masked_lm(*UpperCamelCase						)
							def lowerCAmelCase_ (     self:      str						)		->		Optional[int]:
											snake_case__									=     self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_multiple_choice(*UpperCamelCase						)
							def lowerCAmelCase_ (     self:      Union[str, Any]						)		->		str:
											snake_case__									=     self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_question_answering(*UpperCamelCase						)
							def lowerCAmelCase_ (     self:      Dict						)		->		Optional[Any]:
											snake_case__									=     self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_sequence_classification(*UpperCamelCase						)
							def lowerCAmelCase_ (     self:      Optional[int]						)		->		Any:
											snake_case__									=     self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_token_classification(*UpperCamelCase						)
							@slow
							def lowerCAmelCase_ (     self:      List[str]						)		->		int:
											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 lowerCAmelCase_ (     self:      str						)		->		List[str]:
											snake_case__									=     TFConvBertModel.from_pretrained('YituTech/conv-bert-base'						)
											self.assertIsNotNone(UpperCamelCase						)


							def lowerCAmelCase_ (     self:      List[Any]						)		->		Optional[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[str]						):
															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:      Tuple						):
															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   __SCREAMING_SNAKE_CASE(	unittest.TestCase	):
							@slow
							def lowerCAmelCase_ (     self:      Union[str, Any]						)		->		Any:
											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_68]
											self.assertEqual(output.shape       ,	UpperCamelCase						)

											snake_case__									=     tf.constant(
											    [
											        [
											            [-0.03_475_493, -0.4_686_034, -0.30_638_832],
											            [0.22_637_248, -0.26_988_646, -0.7_423_424],
											            [0.10_324_868, -0.45_013_508, -0.58_280_784],
											        ]
											    ]						)
											tf.debugging.assert_near(output[:, :3, :3]       ,	UpperCamelCase       ,	atol=1e-4						)












import doctest
import logging
import os
import unittest
from pathlib import Path
from typing import List, Union

import transformers
from transformers.testing_utils import require_tf, require_torch, slow


__UpperCamelCase					:		Optional[Any]	  =						logging.getLogger()


@unittest.skip("Temporarily disable the doc tests."	)
@require_torch
@require_tf
@slow
class   __SCREAMING_SNAKE_CASE(	unittest.TestCase	):
							def lowerCAmelCase_ (     self:      Dict       ,	UpperCamelCase:      Path       ,	UpperCamelCase:      Union[str, None] = None       ,	UpperCamelCase:      Union[List[str], None] = None       ,	UpperCamelCase:      Union[str, List[str], None] = None       ,	UpperCamelCase:      bool = True       ,	)		->		int:
											snake_case__									=     [file for file in os.listdir(UpperCamelCase						) if os.path.isfile(os.path.join(UpperCamelCase       ,	UpperCamelCase						)						)]

											if identifier is not None:
															snake_case__									=     [file for file in files if identifier in file]

											if n_identifier is not None:
															if isinstance(UpperCamelCase       ,	UpperCamelCase						):
																			for n_ in n_identifier:
																							snake_case__									=     [file for file in files if n_ not in file]
															else:
																			snake_case__									=     [file for file in files if n_identifier not in file]

											snake_case__									=     ignore_files or []
											ignore_files.append('__init__.py'						)
											snake_case__									=     [file for file in files if file not in ignore_files]

											for file in files:
															# Open all files
															print('Testing'       ,	UpperCamelCase						)

															if only_modules:
																			snake_case__									=     file.split('.'						)[0]
																			try:
																							snake_case__									=     getattr(UpperCamelCase       ,	UpperCamelCase						)
																							snake_case__									=     doctest.DocTestSuite(UpperCamelCase						)
																							snake_case__									=     unittest.TextTestRunner().run(UpperCamelCase						)
																							self.assertIs(len(result.failures						)       ,	0						)
																			except AttributeError:
																							logger.info(F'''{module_identifier} is not a module.'''						)
															else:
																			snake_case__									=     doctest.testfile(str('..' / directory / file						)       ,	optionflags=doctest.ELLIPSIS						)
																			self.assertIs(result.failed       ,	0						)
							def lowerCAmelCase_ (     self:      Tuple						)		->		int:
											snake_case__									=     Path('src/transformers'						)
											snake_case__									=     'modeling'
											snake_case__									=     [
											    'modeling_ctrl.py',
											    'modeling_tf_ctrl.py',
											]
											self.analyze_directory(UpperCamelCase       ,	identifier=UpperCamelCase       ,	ignore_files=UpperCamelCase						)
							def lowerCAmelCase_ (     self:      Optional[int]						)		->		str:
											snake_case__									=     Path('src/transformers'						)
											snake_case__									=     'tokenization'
											self.analyze_directory(UpperCamelCase       ,	identifier=UpperCamelCase						)
							def lowerCAmelCase_ (     self:      Optional[Any]						)		->		int:
											snake_case__									=     Path('src/transformers'						)
											snake_case__									=     'configuration'
											self.analyze_directory(UpperCamelCase       ,	identifier=UpperCamelCase						)
							def lowerCAmelCase_ (     self:      Dict						)		->		List[Any]:
											snake_case__									=     Path('src/transformers'						)
											snake_case__									=     ['configuration', 'modeling', 'tokenization']
											self.analyze_directory(UpperCamelCase       ,	n_identifier=UpperCamelCase						)


							def lowerCAmelCase_ (     self:      Tuple						)		->		Union[str, Any]:
											snake_case__									=     Path('docs/source'						)
											snake_case__									=     ['favicon.ico']
											self.analyze_directory(UpperCamelCase       ,	ignore_files=UpperCamelCase       ,	only_modules=UpperCamelCase						)




