
'''simple docstring'''





import unittest

from transformers import ElectraConfig, is_torch_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
						import torch

						from transformers import (
						    MODEL_FOR_PRETRAINING_MAPPING,
						    ElectraForCausalLM,
						    ElectraForMaskedLM,
						    ElectraForMultipleChoice,
						    ElectraForPreTraining,
						    ElectraForQuestionAnswering,
						    ElectraForSequenceClassification,
						    ElectraForTokenClassification,
						    ElectraModel,
						)
						from transformers.models.electra.modeling_electra import ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST

class     a :




				def __init__(				self						:					Any,     SCREAMING_SNAKE_CASE_						:					Optional[Any],     SCREAMING_SNAKE_CASE_						:					str=13,     SCREAMING_SNAKE_CASE_						:					Tuple=7,     SCREAMING_SNAKE_CASE_						:					Optional[int]=True,     SCREAMING_SNAKE_CASE_						:					Dict=True,     SCREAMING_SNAKE_CASE_						:					List[Any]=True,     SCREAMING_SNAKE_CASE_						:					Union[str, Any]=True,     SCREAMING_SNAKE_CASE_						:					Any=99,     SCREAMING_SNAKE_CASE_						:					Tuple=32,     SCREAMING_SNAKE_CASE_						:					Tuple=5,     SCREAMING_SNAKE_CASE_						:					List[Any]=4,     SCREAMING_SNAKE_CASE_						:					Dict=37,     SCREAMING_SNAKE_CASE_						:					Union[str, Any]="gelu",     SCREAMING_SNAKE_CASE_						:					Optional[int]=0.1,     SCREAMING_SNAKE_CASE_						:					int=0.1,     SCREAMING_SNAKE_CASE_						:					Optional[int]=5_12,     SCREAMING_SNAKE_CASE_						:					List[str]=16,     SCREAMING_SNAKE_CASE_						:					int=2,     SCREAMING_SNAKE_CASE_						:					Dict=0.02,     SCREAMING_SNAKE_CASE_						:					Optional[int]=3,     SCREAMING_SNAKE_CASE_						:					Optional[int]=4,     SCREAMING_SNAKE_CASE_						:					Optional[int]=None,     ):
										snake_case							:  Dict			=     parent
										snake_case							:  int			=     batch_size
										snake_case							:  int			=     seq_length
										snake_case							:  List[str]			=     is_training
										snake_case							:  List[str]			=     use_input_mask
										snake_case							:  Tuple			=     use_token_type_ids
										snake_case							:  Optional[int]			=     use_labels
										snake_case							:  Tuple			=     vocab_size
										snake_case							:  Optional[Any]			=     hidden_size
										snake_case							:  Dict			=     num_hidden_layers
										snake_case							:  Tuple			=     num_attention_heads
										snake_case							:  Any			=     intermediate_size
										snake_case							:  Union[str, Any]			=     hidden_act
										snake_case							:  List[str]			=     hidden_dropout_prob
										snake_case							:  Any			=     attention_probs_dropout_prob
										snake_case							:  Dict			=     max_position_embeddings
										snake_case							:  int			=     type_vocab_size
										snake_case							:  Tuple			=     type_sequence_label_size
										snake_case							:  Optional[int]			=     initializer_range
										snake_case							:  Optional[Any]			=     num_labels
										snake_case							:  int			=     num_choices
										snake_case							:  Tuple			=     scope




				def 						__snake_case				(				self						:					List[Any]   ):
										snake_case							:  Tuple			=     ids_tensor([self.batch_size, self.seq_length],     self.vocab_size   )

										snake_case							:  Union[str, Any]			=     None
										if self.use_input_mask:
																snake_case							:  Dict			=     random_attention_mask([self.batch_size, self.seq_length]   )

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

										snake_case							:  Optional[Any]			=     None
										snake_case							:  Dict			=     None
										snake_case							:  Any			=     None
										if self.use_labels:
																snake_case							:  List[Any]			=     ids_tensor([self.batch_size],     self.type_sequence_label_size   )
																snake_case							:  Optional[int]			=     ids_tensor([self.batch_size, self.seq_length],     self.num_labels   )
																snake_case							:  Optional[Any]			=     ids_tensor([self.batch_size],     self.num_choices   )
																snake_case							:  List[str]			=     ids_tensor([self.batch_size, self.seq_length],     1   )

										snake_case							:  Union[str, Any]			=     self.get_config()

										return (
										    config,
										    input_ids,
										    token_type_ids,
										    input_mask,
										    sequence_labels,
										    token_labels,
										    choice_labels,
										    fake_token_labels,
										)




				def 						__snake_case				(				self						:					Union[str, Any]   ):
										return ElectraConfig(
										    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,     is_decoder=SCREAMING_SNAKE_CASE_,     initializer_range=self.initializer_range,     )




				def 						__snake_case				(				self						:					Any   ):
										(
										    (
										    snake_case
										),       (
										    snake_case
										),       (
										    snake_case
										),       (
										    snake_case
										),       (
										    snake_case
										),       (
										    snake_case
										),       (
										    snake_case
										),       (
										    snake_case
										),       
										)							:  Dict			=     self.prepare_config_and_inputs()

										snake_case							:  List[str]			=     True
										snake_case							:  Optional[Any]			=     floats_tensor([self.batch_size, self.seq_length, self.hidden_size]   )
										snake_case							:  Optional[int]			=     ids_tensor([self.batch_size, self.seq_length],     vocab_size=2   )

										return (
										    config,
										    input_ids,
										    token_type_ids,
										    input_mask,
										    sequence_labels,
										    token_labels,
										    choice_labels,
										    encoder_hidden_states,
										    encoder_attention_mask,
										)




				def 						__snake_case				(				self						:					Tuple,     SCREAMING_SNAKE_CASE_						:					int,     SCREAMING_SNAKE_CASE_						:					Any,     SCREAMING_SNAKE_CASE_						:					Any,     SCREAMING_SNAKE_CASE_						:					Optional[Any],     SCREAMING_SNAKE_CASE_						:					str,     SCREAMING_SNAKE_CASE_						:					Tuple,     SCREAMING_SNAKE_CASE_						:					List[str],     SCREAMING_SNAKE_CASE_						:					Optional[int],     ):
										snake_case							:  Any			=     ElectraModel(config=SCREAMING_SNAKE_CASE_   )
										model.to(SCREAMING_SNAKE_CASE_   )
										model.eval()
										snake_case							:  Optional[int]			=     model(SCREAMING_SNAKE_CASE_,     attention_mask=SCREAMING_SNAKE_CASE_,     token_type_ids=SCREAMING_SNAKE_CASE_   )
										snake_case							:  Dict			=     model(SCREAMING_SNAKE_CASE_,     token_type_ids=SCREAMING_SNAKE_CASE_   )
										snake_case							:  int			=     model(SCREAMING_SNAKE_CASE_   )
										self.parent.assertEqual(result.last_hidden_state.shape,     (self.batch_size, self.seq_length, self.hidden_size)   )




				def 						__snake_case				(				self						:					List[str],     SCREAMING_SNAKE_CASE_						:					str,     SCREAMING_SNAKE_CASE_						:					Dict,     SCREAMING_SNAKE_CASE_						:					Any,     SCREAMING_SNAKE_CASE_						:					Any,     SCREAMING_SNAKE_CASE_						:					List[Any],     SCREAMING_SNAKE_CASE_						:					str,     SCREAMING_SNAKE_CASE_						:					Union[str, Any],     SCREAMING_SNAKE_CASE_						:					str,     SCREAMING_SNAKE_CASE_						:					Optional[Any],     ):
										snake_case							:  List[Any]			=     True
										snake_case							:  int			=     ElectraModel(SCREAMING_SNAKE_CASE_   )
										model.to(SCREAMING_SNAKE_CASE_   )
										model.eval()
										snake_case							:  Union[str, Any]			=     model(
										    SCREAMING_SNAKE_CASE_,     attention_mask=SCREAMING_SNAKE_CASE_,     token_type_ids=SCREAMING_SNAKE_CASE_,     encoder_hidden_states=SCREAMING_SNAKE_CASE_,     encoder_attention_mask=SCREAMING_SNAKE_CASE_,     )
										snake_case							:  Optional[int]			=     model(
										    SCREAMING_SNAKE_CASE_,     attention_mask=SCREAMING_SNAKE_CASE_,     token_type_ids=SCREAMING_SNAKE_CASE_,     encoder_hidden_states=SCREAMING_SNAKE_CASE_,     )
										snake_case							:  List[Any]			=     model(SCREAMING_SNAKE_CASE_,     attention_mask=SCREAMING_SNAKE_CASE_,     token_type_ids=SCREAMING_SNAKE_CASE_   )
										self.parent.assertEqual(result.last_hidden_state.shape,     (self.batch_size, self.seq_length, self.hidden_size)   )




				def 						__snake_case				(				self						:					int,     SCREAMING_SNAKE_CASE_						:					List[Any],     SCREAMING_SNAKE_CASE_						:					Union[str, Any],     SCREAMING_SNAKE_CASE_						:					Any,     SCREAMING_SNAKE_CASE_						:					Dict,     SCREAMING_SNAKE_CASE_						:					Union[str, Any],     SCREAMING_SNAKE_CASE_						:					str,     SCREAMING_SNAKE_CASE_						:					List[Any],     SCREAMING_SNAKE_CASE_						:					Tuple,     ):
										snake_case							:  Dict			=     ElectraForMaskedLM(config=SCREAMING_SNAKE_CASE_   )
										model.to(SCREAMING_SNAKE_CASE_   )
										model.eval()
										snake_case							:  Union[str, Any]			=     model(SCREAMING_SNAKE_CASE_,     attention_mask=SCREAMING_SNAKE_CASE_,     token_type_ids=SCREAMING_SNAKE_CASE_,     labels=SCREAMING_SNAKE_CASE_   )
										self.parent.assertEqual(result.logits.shape,     (self.batch_size, self.seq_length, self.vocab_size)   )




				def 						__snake_case				(				self						:					Any,     SCREAMING_SNAKE_CASE_						:					Optional[Any],     SCREAMING_SNAKE_CASE_						:					Any,     SCREAMING_SNAKE_CASE_						:					str,     SCREAMING_SNAKE_CASE_						:					Optional[int],     SCREAMING_SNAKE_CASE_						:					int,     SCREAMING_SNAKE_CASE_						:					Union[str, Any],     SCREAMING_SNAKE_CASE_						:					Union[str, Any],     SCREAMING_SNAKE_CASE_						:					Dict,     SCREAMING_SNAKE_CASE_						:					Optional[Any],     ):
										snake_case							:  int			=     ElectraForCausalLM(config=SCREAMING_SNAKE_CASE_   )
										model.to(SCREAMING_SNAKE_CASE_   )
										model.eval()
										snake_case							:  Optional[int]			=     model(SCREAMING_SNAKE_CASE_,     attention_mask=SCREAMING_SNAKE_CASE_,     token_type_ids=SCREAMING_SNAKE_CASE_,     labels=SCREAMING_SNAKE_CASE_   )
										self.parent.assertEqual(result.logits.shape,     (self.batch_size, self.seq_length, self.vocab_size)   )




				def 						__snake_case				(				self						:					Optional[Any],     SCREAMING_SNAKE_CASE_						:					List[str],     SCREAMING_SNAKE_CASE_						:					Optional[int],     SCREAMING_SNAKE_CASE_						:					Optional[Any],     SCREAMING_SNAKE_CASE_						:					Any,     SCREAMING_SNAKE_CASE_						:					List[Any],     SCREAMING_SNAKE_CASE_						:					Dict,     SCREAMING_SNAKE_CASE_						:					str,     SCREAMING_SNAKE_CASE_						:					Any,     ):
										snake_case							:  Dict			=     self.num_labels
										snake_case							:  Dict			=     ElectraForTokenClassification(config=SCREAMING_SNAKE_CASE_   )
										model.to(SCREAMING_SNAKE_CASE_   )
										model.eval()
										snake_case							:  str			=     model(SCREAMING_SNAKE_CASE_,     attention_mask=SCREAMING_SNAKE_CASE_,     token_type_ids=SCREAMING_SNAKE_CASE_,     labels=SCREAMING_SNAKE_CASE_   )
										self.parent.assertEqual(result.logits.shape,     (self.batch_size, self.seq_length, self.num_labels)   )




				def 						__snake_case				(				self						:					str,     SCREAMING_SNAKE_CASE_						:					Union[str, Any],     SCREAMING_SNAKE_CASE_						:					Tuple,     SCREAMING_SNAKE_CASE_						:					Any,     SCREAMING_SNAKE_CASE_						:					int,     SCREAMING_SNAKE_CASE_						:					Tuple,     SCREAMING_SNAKE_CASE_						:					Dict,     SCREAMING_SNAKE_CASE_						:					Tuple,     SCREAMING_SNAKE_CASE_						:					Optional[Any],     ):
										snake_case							:  Dict			=     self.num_labels
										snake_case							:  int			=     ElectraForPreTraining(config=SCREAMING_SNAKE_CASE_   )
										model.to(SCREAMING_SNAKE_CASE_   )
										model.eval()
										snake_case							:  List[Any]			=     model(SCREAMING_SNAKE_CASE_,     attention_mask=SCREAMING_SNAKE_CASE_,     token_type_ids=SCREAMING_SNAKE_CASE_,     labels=SCREAMING_SNAKE_CASE_   )
										self.parent.assertEqual(result.logits.shape,     (self.batch_size, self.seq_length)   )




				def 						__snake_case				(				self						:					Optional[Any],     SCREAMING_SNAKE_CASE_						:					List[str],     SCREAMING_SNAKE_CASE_						:					Optional[Any],     SCREAMING_SNAKE_CASE_						:					List[Any],     SCREAMING_SNAKE_CASE_						:					Optional[int],     SCREAMING_SNAKE_CASE_						:					str,     SCREAMING_SNAKE_CASE_						:					str,     SCREAMING_SNAKE_CASE_						:					int,     SCREAMING_SNAKE_CASE_						:					List[str],     ):
										snake_case							:  Tuple			=     self.num_labels
										snake_case							:  List[str]			=     ElectraForSequenceClassification(SCREAMING_SNAKE_CASE_   )
										model.to(SCREAMING_SNAKE_CASE_   )
										model.eval()
										snake_case							:  Optional[Any]			=     model(SCREAMING_SNAKE_CASE_,     attention_mask=SCREAMING_SNAKE_CASE_,     token_type_ids=SCREAMING_SNAKE_CASE_,     labels=SCREAMING_SNAKE_CASE_   )
										self.parent.assertEqual(result.logits.shape,     (self.batch_size, self.num_labels)   )




				def 						__snake_case				(				self						:					Union[str, Any],     SCREAMING_SNAKE_CASE_						:					Union[str, Any],     SCREAMING_SNAKE_CASE_						:					int,     SCREAMING_SNAKE_CASE_						:					Optional[int],     SCREAMING_SNAKE_CASE_						:					Any,     SCREAMING_SNAKE_CASE_						:					List[str],     SCREAMING_SNAKE_CASE_						:					int,     SCREAMING_SNAKE_CASE_						:					List[str],     SCREAMING_SNAKE_CASE_						:					int,     ):
										snake_case							:  int			=     ElectraForQuestionAnswering(config=SCREAMING_SNAKE_CASE_   )
										model.to(SCREAMING_SNAKE_CASE_   )
										model.eval()
										snake_case							:  List[Any]			=     model(
										    SCREAMING_SNAKE_CASE_,     attention_mask=SCREAMING_SNAKE_CASE_,     token_type_ids=SCREAMING_SNAKE_CASE_,     start_positions=SCREAMING_SNAKE_CASE_,     end_positions=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 						__snake_case				(				self						:					str,     SCREAMING_SNAKE_CASE_						:					int,     SCREAMING_SNAKE_CASE_						:					List[Any],     SCREAMING_SNAKE_CASE_						:					Optional[Any],     SCREAMING_SNAKE_CASE_						:					Tuple,     SCREAMING_SNAKE_CASE_						:					str,     SCREAMING_SNAKE_CASE_						:					int,     SCREAMING_SNAKE_CASE_						:					Tuple,     SCREAMING_SNAKE_CASE_						:					Optional[int],     ):
										snake_case							:  str			=     self.num_choices
										snake_case							:  int			=     ElectraForMultipleChoice(config=SCREAMING_SNAKE_CASE_   )
										model.to(SCREAMING_SNAKE_CASE_   )
										model.eval()
										snake_case							:  List[str]			=     input_ids.unsqueeze(1   ).expand(-1,     self.num_choices,     -1   ).contiguous()
										snake_case							:  int			=     token_type_ids.unsqueeze(1   ).expand(-1,     self.num_choices,     -1   ).contiguous()
										snake_case							:  Tuple			=     input_mask.unsqueeze(1   ).expand(-1,     self.num_choices,     -1   ).contiguous()
										snake_case							:  str			=     model(
										    SCREAMING_SNAKE_CASE_,     attention_mask=SCREAMING_SNAKE_CASE_,     token_type_ids=SCREAMING_SNAKE_CASE_,     labels=SCREAMING_SNAKE_CASE_,     )
										self.parent.assertEqual(result.logits.shape,     (self.batch_size, self.num_choices)   )




				def 						__snake_case				(				self						:					Dict   ):
										snake_case							:  Union[str, Any]			=     self.prepare_config_and_inputs()
										(
										    (
										    snake_case
										),       (
										    snake_case
										),       (
										    snake_case
										),       (
										    snake_case
										),       (
										    snake_case
										),       (
										    snake_case
										),       (
										    snake_case
										),       (
										    snake_case
										),       
										)							:  Union[str, Any]			=     config_and_inputs
										snake_case							:  Dict			=     {'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': input_mask}
										return config, inputs_dict




@require_torch
class     a (					__magic_name__					,__magic_name__					,unittest.TestCase     ):
				_snake_case		     =			(
				    (
				        ElectraModel,
				        ElectraForPreTraining,
				        ElectraForMaskedLM,
				        ElectraForCausalLM,
				        ElectraForMultipleChoice,
				        ElectraForTokenClassification,
				        ElectraForSequenceClassification,
				        ElectraForQuestionAnswering,
				    )
				    if is_torch_available()
				    else ()
				)
				_snake_case		     =			(
				    {
				        '''feature-extraction''': ElectraModel,
				        '''fill-mask''': ElectraForMaskedLM,
				        '''question-answering''': ElectraForQuestionAnswering,
				        '''text-classification''': ElectraForSequenceClassification,
				        '''text-generation''': ElectraForCausalLM,
				        '''token-classification''': ElectraForTokenClassification,
				        '''zero-shot''': ElectraForSequenceClassification,
				    }
				    if is_torch_available()
				    else {}
				)
				_snake_case		     =			True




				def 						__snake_case				(				self						:					str,     SCREAMING_SNAKE_CASE_						:					Union[str, Any],     SCREAMING_SNAKE_CASE_						:					Tuple,     SCREAMING_SNAKE_CASE_						:					int=False   ):
										snake_case							:  Dict			=     super()._prepare_for_class(SCREAMING_SNAKE_CASE_,     SCREAMING_SNAKE_CASE_,     return_labels=SCREAMING_SNAKE_CASE_   )

										if return_labels:
																if model_class in get_values(SCREAMING_SNAKE_CASE_   ):
																						snake_case							:  int			=     torch.zeros(
																						    (self.model_tester.batch_size, self.model_tester.seq_length),     dtype=torch.long,     device=SCREAMING_SNAKE_CASE_   )
										return inputs_dict




				def 						__snake_case				(				self						:					Dict   ):
										snake_case							:  Dict			=     ElectraModelTester(self   )
										snake_case							:  int			=     ConfigTester(self,     config_class=SCREAMING_SNAKE_CASE_,     hidden_size=37   )




				def 						__snake_case				(				self						:					Dict   ):
										self.config_tester.run_common_tests()




				def 						__snake_case				(				self						:					Tuple   ):
										snake_case							:  Optional[int]			=     self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_electra_model(*SCREAMING_SNAKE_CASE_   )




				def 						__snake_case				(				self						:					str   ):
										snake_case							:  int			=     self.model_tester.prepare_config_and_inputs_for_decoder()
										self.model_tester.create_and_check_electra_model_as_decoder(*SCREAMING_SNAKE_CASE_   )




				def 						__snake_case				(				self						:					List[str]   ):
										snake_case							:  Tuple			=     self.model_tester.prepare_config_and_inputs()
										for type in ["absolute", "relative_key", "relative_key_query"]:
																snake_case							:  List[Any]			=     type
																self.model_tester.create_and_check_electra_model(*SCREAMING_SNAKE_CASE_   )




				def 						__snake_case				(				self						:					str   ):
										snake_case							:  Dict			=     self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_electra_for_masked_lm(*SCREAMING_SNAKE_CASE_   )




				def 						__snake_case				(				self						:					Optional[int]   ):
										snake_case							:  Optional[Any]			=     self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_electra_for_token_classification(*SCREAMING_SNAKE_CASE_   )




				def 						__snake_case				(				self						:					List[str]   ):
										snake_case							:  Any			=     self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_electra_for_pretraining(*SCREAMING_SNAKE_CASE_   )




				def 						__snake_case				(				self						:					int   ):
										snake_case							:  List[str]			=     self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_electra_for_sequence_classification(*SCREAMING_SNAKE_CASE_   )




				def 						__snake_case				(				self						:					Optional[int]   ):
										snake_case							:  str			=     self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_electra_for_question_answering(*SCREAMING_SNAKE_CASE_   )




				def 						__snake_case				(				self						:					Any   ):
										snake_case							:  Any			=     self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_electra_for_multiple_choice(*SCREAMING_SNAKE_CASE_   )




				@slow
				def 						__snake_case				(				self						:					Tuple   ):
										for model_name in ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																snake_case							:  Any			=     ElectraModel.from_pretrained(SCREAMING_SNAKE_CASE_   )
																self.assertIsNotNone(SCREAMING_SNAKE_CASE_   )




				def 						__snake_case				(				self						:					Optional[int]   ):
										snake_case							:  Optional[int]			=     self.model_tester.prepare_config_and_inputs_for_decoder()
										self.model_tester.create_and_check_electra_for_causal_lm(*SCREAMING_SNAKE_CASE_   )




@require_torch
class     a (					unittest.TestCase     ):




				@slow
				def 						__snake_case				(				self						:					Optional[int]   ):
										snake_case							:  Optional[int]			=     ElectraModel.from_pretrained('''google/electra-small-discriminator'''   )
										snake_case							:  Optional[int]			=     torch.tensor([[0, 3_45, 2_32, 3_28, 7_40, 1_40, 16_95, 69, 60_78, 15_88, 2]]   )
										snake_case							:  List[str]			=     torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]   )
										snake_case							:  str			=     model(SCREAMING_SNAKE_CASE_,     attention_mask=SCREAMING_SNAKE_CASE_   )[0]
										snake_case							:  int			=     torch.Size((1, 11, 2_56)   )
										self.assertEqual(output.shape,     SCREAMING_SNAKE_CASE_   )
										snake_case							:  Union[str, Any]			=     torch.tensor(
										    [[[0.4471, 0.6821, -0.3265], [0.4627, 0.5255, -0.3668], [0.4532, 0.3313, -0.4344]]]   )

										self.assertTrue(torch.allclose(output[:, 1:4, 1:4],     SCREAMING_SNAKE_CASE_,     atol=1e-4   )   )




'''simple docstring'''







import argparse
import glob
import inspect
import os
import re
import unittest

from get_test_info import get_test_classes

from tests.test_pipeline_mixin import pipeline_test_mapping


_lowerCamelCase    =  {}
for task, _ in pipeline_test_mapping.items():
							_lowerCamelCase    =  {'pt': None, 'tf': None}


# DO **NOT** add item to this set (unless the reason is approved)
_lowerCamelCase    =  {
    'tests/models/esm/test_modeling_esmfold.py',  # The pipeline test mapping is added to `test_modeling_esm.py`
}






def 					_SCREAMING_SNAKE_CASE		(						snake_case_	):

	if "ModelTesterMixin" in [x.__name__ for x in test_class.__bases__]:
		return "pt"
	elif "TFModelTesterMixin" in [x.__name__ for x in test_class.__bases__]:
		return "tf"
	elif "FlaxModelTesterMixin" in [x.__name__ for x in test_class.__bases__]:
		return "flax"
	else:
		return None






def 					_SCREAMING_SNAKE_CASE		(						snake_case_							,       snake_case_	):
	# Use the cached results
	if PIPELINE_TEST_MAPPING[task].get(snake_case_							,       snake_case_	) is not None:
		return PIPELINE_TEST_MAPPING[task][framework]

	_lowercase							=     pipeline_test_mapping[task]["""test"""]
	_lowercase							=     None

	if framework == "pt":
		_lowercase							=     getattr(snake_case_							,       """model_mapping"""							,       snake_case_	)
	elif framework == "tf":
		_lowercase							=     getattr(snake_case_							,       """tf_model_mapping"""							,       snake_case_	)

	if mapping is not None:
		_lowercase							=     dict(mapping.items()	)

	# cache the results
	_lowercase							=     mapping
	return mapping






def 					_SCREAMING_SNAKE_CASE		(						snake_case_							,       snake_case_	):
	_lowercase							=     get_framework(snake_case_	)
	if framework is None:
		return None
	_lowercase							=     get_mapping_for_task(snake_case_							,       snake_case_	)
	if mapping is None:
		return None

	_lowercase							=     list({model_class.config_class for model_class in test_class.all_model_classes}	)
	if len(snake_case_	) != 1:
		raise ValueError("""There should be exactly one configuration class from `test_class.all_model_classes`."""	)

	# This could be a list/tuple of model classes, but it's rare.
	_lowercase							=     mapping.get(config_classes[0]							,       snake_case_	)
	if isinstance(snake_case_							,       (tuple, list)	):
		_lowercase							=     sorted(snake_case_							,       key=lambda snake_case_	: x.__name__	)

	return model_class






def 					_SCREAMING_SNAKE_CASE		(						snake_case_	):
	_lowercase							=     [(task, get_model_for_pipeline_test(snake_case_							,       snake_case_	)) for task in pipeline_test_mapping]
	_lowercase							=     sorted([(task, model) for task, model in mapping if model is not None]							,       key=lambda snake_case_	: x[0]	)

	return dict(snake_case_	)






def 					_SCREAMING_SNAKE_CASE		(						snake_case_	):
	_lowercase							=     get_framework(snake_case_	)
	if framework == "pt":
		_lowercase							=     """torch"""
	_lowercase							=     """{}"""

	_lowercase							=     get_pipeline_model_mapping(snake_case_	)
	if len(snake_case_	) == 0:
		return ""

	_lowercase							=     []
	for task, model_classes in mapping.items():
		if isinstance(snake_case_							,       (tuple, list)	):
			# A list/tuple of model classes
			_lowercase							=     """(""" + """, """.join([x.__name__ for x in model_classes]	) + """)"""
		else:
			# A single model class
			_lowercase							=     model_classes.__name__
		texts.append(F"""\"{task}\": {value}"""	)
	_lowercase							=     """{""" + """, """.join(snake_case_	) + """}"""
	_lowercase							=     F"""pipeline_model_mapping = {text} if is_{framework}_available() else {default_value}"""

	return text






def 					_SCREAMING_SNAKE_CASE		(						snake_case_	):
	_lowercase							=     {"""ModelTesterMixin""", """TFModelTesterMixin""", """FlaxModelTesterMixin"""}
	if not issubclass(snake_case_							,       unittest.TestCase	):
		return False
	return len(base_class_names.intersection([x.__name__ for x in test_class.__bases__]	)	) > 0






def 					_SCREAMING_SNAKE_CASE		(						snake_case_	):
	_lowercase							=     [x for x in get_test_classes(snake_case_	) if is_valid_test_class(snake_case_	)]

	_lowercase							=     None
	for test_class in test_classes:
		# If a test class has defined `pipeline_model_mapping`, let's take it
		if getattr(snake_case_							,       """pipeline_model_mapping"""							,       snake_case_	) is not None:
			_lowercase							=     test_class
			break
    # Take the test class with the shortest name (just a heuristic)
	if target_test_class is None and len(snake_case_	) > 0:
		_lowercase							=     sorted(snake_case_							,       key=lambda snake_case_	: (len(x.__name__	), x.__name__)	)[0]

	return target_test_class






def 					_SCREAMING_SNAKE_CASE		(						snake_case_							,       snake_case_							,       snake_case_	):
	_lowercase							=     start_idx
	for idx, line in enumerate(lines[start_idx:]	):
		_lowercase							=     len(snake_case_	) - len(line.lstrip()	)
		if idx == 0 or indent > indent_level or (indent == indent_level and line.strip() == ")"):
			_lowercase							=     start_idx + idx
		elif idx > 0 and indent <= indent_level:
			# Outside the definition block of `pipeline_model_mapping`
			break

	return end_idx






def 					_SCREAMING_SNAKE_CASE		(						snake_case_							,       snake_case_=False	):
	if getattr(snake_case_							,       """pipeline_model_mapping"""							,       snake_case_	) is not None:
		if not overwrite:
			return "", -1

	_lowercase							=     get_pipeline_model_mapping_string(snake_case_	)
	if len(snake_case_	) == 0:
		return "", -1
	_lowercase							=     line_to_add + """\n"""

	# The code defined the class `test_class`
	_lowercase		,		_lowercase							=     inspect.getsourcelines(snake_case_	)
	# `inspect` gives the code for an object, including decorator(s) if any.
	# We (only) need the exact line of the class definition.
	for idx, line in enumerate(snake_case_	):
		if line.lstrip().startswith("""class """	):
			_lowercase							=     class_lines[idx:]
			class_start_line_no += idx
			break
	_lowercase							=     class_start_line_no + len(snake_case_	) - 1

	# The index in `class_lines` that starts the definition of `all_model_classes`, `all_generative_model_classes` or
	# `pipeline_model_mapping`. This assumes they are defined in such order, and we take the start index of the last
	# block that appears in a `test_class`.
	_lowercase							=     None
	# The indent level of the line at `class_lines[start_idx]` (if defined)
	_lowercase							=     0
	# To record if `pipeline_model_mapping` is found in `test_class`.
	_lowercase							=     None
	for idx, line in enumerate(snake_case_	):
		if line.strip().startswith("""all_model_classes = """	):
			_lowercase							=     len(snake_case_	) - len(line.lstrip()	)
			_lowercase							=     idx
		elif line.strip().startswith("""all_generative_model_classes = """	):
			_lowercase							=     len(snake_case_	) - len(line.lstrip()	)
			_lowercase							=     idx
		elif line.strip().startswith("""pipeline_model_mapping = """	):
			_lowercase							=     len(snake_case_	) - len(line.lstrip()	)
			_lowercase							=     idx
			_lowercase							=     line
			break

	if start_idx is None:
		return "", -1
	# Find the ending index (inclusive) of the above found block.
	_lowercase							=     find_block_ending(snake_case_							,       snake_case_							,       snake_case_	)

	# Extract `is_xxx_available()` from existing blocks: some models require specific libraries like `timm` and use
	# `is_timm_available()` instead of `is_torch_available()`.
	# Keep leading and trailing whitespaces
	_lowercase							=     re.compile(r"""\s(is_\S+?_available\(\))\s"""	)
	for line in class_lines[start_idx : end_idx + 1]:
		_lowercase							=     r.search(snake_case_	)
		if backend_condition is not None:
			# replace the leading and trailing whitespaces to the space character " ".
			_lowercase							=     """ """ + backend_condition[0][1:-1] + """ """
			_lowercase							=     r.sub(snake_case_							,       snake_case_	)
			break

	if def_line is None:
		# `pipeline_model_mapping` is not defined. The target index is set to the ending index (inclusive) of
		# `all_model_classes` or `all_generative_model_classes`.
		_lowercase							=     end_idx
	else:
		# `pipeline_model_mapping` is defined. The target index is set to be one **BEFORE** its start index.
		_lowercase							=     start_idx - 1
		# mark the lines of the currently existing `pipeline_model_mapping` to be removed.
		for idx in range(snake_case_							,       end_idx + 1	):
			# These lines are going to be removed before writing to the test file.
			_lowercase							=     None  # noqa

    # Make sure the test class is a subclass of `PipelineTesterMixin`.
	_lowercase							=     [x.__name__ for x in test_class.__bases__]
	if "PipelineTesterMixin" not in parent_classes:
		# Put `PipelineTesterMixin` just before `unittest.TestCase`
		_lowercase							=     [x for x in parent_classes if x != """TestCase"""] + ["""PipelineTesterMixin"""]
		if "TestCase" in parent_classes:
			# Here we **assume** the original string is always with `unittest.TestCase`.
			_parent_classes.append("""unittest.TestCase"""	)
		_lowercase							=     """, """.join(_parent_classes	)
		for idx, line in enumerate(snake_case_	):
			# Find the ending of the declaration of `test_class`
			if line.strip().endswith("""):"""	):
				# mark the lines of the declaration of `test_class` to be removed
				for _idx in range(idx + 1	):
					_lowercase							=     None  # noqa
				break
        # Add the new, one-line, class declaration for `test_class`
		_lowercase							=     F"""class {test_class.__name__}({parent_classes}):\n"""

	# Add indentation
	_lowercase							=     """ """ * indent_level + line_to_add
	# Insert `pipeline_model_mapping` to `class_lines`.
	# (The line at `target_idx` should be kept by definition!)
	_lowercase							=     class_lines[: target_idx + 1] + [line_to_add] + class_lines[target_idx + 1 :]
	# Remove the lines that are marked to be removed
	_lowercase							=     [x for x in class_lines if x is not None]

	# Move from test class to module (in order to write to the test file)
	_lowercase							=     inspect.getsourcelines(inspect.getmodule(snake_case_	)	)[0]
	# Be careful with the 1-off between line numbers and array indices
	_lowercase							=     module_lines[: class_start_line_no - 1] + class_lines + module_lines[class_end_line_no:]
	_lowercase							=     """""".join(snake_case_	)

	_lowercase							=     inspect.getsourcefile(snake_case_	)
	with open(snake_case_							,       """w"""							,       encoding="""UTF-8"""							,       newline="""\n"""	) as fp:
		fp.write(snake_case_	)

	return line_to_add






def 					_SCREAMING_SNAKE_CASE		(						snake_case_							,       snake_case_=False	):
	_lowercase							=     find_test_class(snake_case_	)
	if test_class:
		add_pipeline_model_mapping(snake_case_							,       overwrite=snake_case_	)


if __name__ == "__main__":
							_lowerCamelCase    =  argparse.ArgumentParser()
							parser.add_argument(
							    '--test_file', type=str, help='A path to the test file, starting with the repository\'s `tests` directory.'
							)
							parser.add_argument(
							    '--all',
							    action='store_true',
							    help='If to check and modify all test files.',
							)
							parser.add_argument(
							    '--overwrite',
							    action='store_true',
							    help='If to overwrite a test class if it has already defined `pipeline_model_mapping`.',
							)
							_lowerCamelCase    =  parser.parse_args()

							if not args.all and not args.test_file:
														raise ValueError('Please specify either `test_file` or pass `--all` to check/modify all test files.')
							elif args.all and args.test_file:
														raise ValueError('Only one of `--test_file` and `--all` could be specified.')

							_lowerCamelCase    =  []
							if args.test_file:
														_lowerCamelCase    =  [args.test_file]
							else:
														_lowerCamelCase    =  os.path.join('tests', 'models', '**', 'test_modeling_*.py')
														for test_file in glob.glob(pattern):
																					# `Flax` is not concerned at this moment
																					if not test_file.startswith('test_modeling_flax_'):
																												test_files.append(test_file)

							for test_file in test_files:
														if test_file in TEST_FILE_TO_IGNORE:
																					print(F"""[SKIPPED] {test_file} is skipped as it is in `TEST_FILE_TO_IGNORE` in the file {__file__}.""")
																					continue
														add_pipeline_model_mapping_to_test_file(test_file, overwrite=args.overwrite)




