




import unittest

import numpy as np

from transformers import ElectraConfig, is_flax_available
from transformers.testing_utils import require_flax, slow

from ...test_modeling_flax_common import FlaxModelTesterMixin, ids_tensor, random_attention_mask


if is_flax_available():
							from transformers.models.electra.modeling_flax_electra import (
							    FlaxElectraForCausalLM,
							    FlaxElectraForMaskedLM,
							    FlaxElectraForMultipleChoice,
							    FlaxElectraForPreTraining,
							    FlaxElectraForQuestionAnswering,
							    FlaxElectraForSequenceClassification,
							    FlaxElectraForTokenClassification,
							    FlaxElectraModel,
							)


class 				__SCREAMING_SNAKE_CASE							(		unittest.TestCase  ):

					def __init__(				self ,       __lowercase ,       __lowercase=13 ,       __lowercase=7 ,       __lowercase=True ,       __lowercase=True ,       __lowercase=True ,       __lowercase=True ,       __lowercase=99 ,       __lowercase=24 ,       __lowercase=32 ,       __lowercase=5 ,       __lowercase=4 ,       __lowercase=37 ,       __lowercase="gelu" ,       __lowercase=0.1 ,       __lowercase=0.1 ,       __lowercase=512 ,       __lowercase=16 ,       __lowercase=2 ,       __lowercase=0.02 ,       __lowercase=4 ,       ):







						'''simple docstring'''




						lowerCamelCase_							:		str							   =							parent
						lowerCamelCase_							:		Any							   =							batch_size
						lowerCamelCase_							:		Union[str, Any]							   =							seq_length
						lowerCamelCase_							:		Dict							   =							is_training
						lowerCamelCase_							:		Any							   =							use_attention_mask
						lowerCamelCase_							:		Any							   =							use_token_type_ids
						lowerCamelCase_							:		Any							   =							use_labels
						lowerCamelCase_							:		Any							   =							vocab_size
						lowerCamelCase_							:		Any							   =							hidden_size
						lowerCamelCase_							:		Optional[Any]							   =							embedding_size
						lowerCamelCase_							:		Dict							   =							num_hidden_layers
						lowerCamelCase_							:		Optional[Any]							   =							num_attention_heads
						lowerCamelCase_							:		Optional[Any]							   =							intermediate_size
						lowerCamelCase_							:		List[str]							   =							hidden_act
						lowerCamelCase_							:		Optional[Any]							   =							hidden_dropout_prob
						lowerCamelCase_							:		int							   =							attention_probs_dropout_prob
						lowerCamelCase_							:		Optional[int]							   =							max_position_embeddings
						lowerCamelCase_							:		List[str]							   =							type_vocab_size
						lowerCamelCase_							:		int							   =							type_sequence_label_size
						lowerCamelCase_							:		Tuple							   =							initializer_range
						lowerCamelCase_							:		int							   =							num_choices

					def 	lowercase_							(				self					):







						'''simple docstring'''




						lowerCamelCase_							:		int							   =							ids_tensor([self.batch_size, self.seq_length] ,       self.vocab_size					)

						lowerCamelCase_							:		List[Any]							   =							None
						if self.use_attention_mask:
							lowerCamelCase_							:		Tuple							   =							random_attention_mask([self.batch_size, self.seq_length]					)

						lowerCamelCase_							:		int							   =							None
						if self.use_token_type_ids:
							lowerCamelCase_							:		List[Any]							   =							ids_tensor([self.batch_size, self.seq_length] ,       self.type_vocab_size					)

						lowerCamelCase_							:		List[str]							   =							ElectraConfig(
						    vocab_size=self.vocab_size ,       hidden_size=self.hidden_size ,       embedding_size=self.embedding_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 config, input_ids, token_type_ids, attention_mask





					def 	lowercase_							(				self					):







						'''simple docstring'''




						lowerCamelCase_							:		Tuple							   =							self.prepare_config_and_inputs()
						lowerCamelCase_   ,			lowerCamelCase_   ,			lowerCamelCase_   ,			lowerCamelCase_							:		Tuple							   =							config_and_inputs
						lowerCamelCase_							:		Union[str, Any]							   =							{'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': attention_mask}
						return config, inputs_dict


@require_flax
class 				__SCREAMING_SNAKE_CASE							(		lowerCamelCase   ,     unittest.TestCase  ):
					_lowerCamelCase		  = True

					_lowerCamelCase		  = (
					    (
					        FlaxElectraModel,
					        FlaxElectraForCausalLM,
					        FlaxElectraForMaskedLM,
					        FlaxElectraForPreTraining,
					        FlaxElectraForTokenClassification,
					        FlaxElectraForQuestionAnswering,
					        FlaxElectraForMultipleChoice,
					        FlaxElectraForSequenceClassification,
					    )
					    if is_flax_available()
					    else ()
					)

					def 	lowercase_							(				self					):







						'''simple docstring'''




						lowerCamelCase_							:		Union[str, Any]							   =							FlaxElectraModelTester(self					)





					@slow
					def 	lowercase_							(				self					):







						'''simple docstring'''




						for model_class_name in self.all_model_classes:
							if model_class_name == FlaxElectraForMaskedLM:
								lowerCamelCase_							:		Union[str, Any]							   =							model_class_name.from_pretrained('google/electra-small-generator'					)
							else:
								lowerCamelCase_							:		List[Any]							   =							model_class_name.from_pretrained('google/electra-small-discriminator'					)
							lowerCamelCase_							:		Dict							   =							model(np.ones((1, 1)					)					)
							self.assertIsNotNone(__lowercase					)






def 					snake_case					(							A			)							->							int:




	'''simple docstring'''


	if not isinstance(A						,   A			):
		raise ValueError('double_factorial() only accepts integral values'			)
	if n < 0:
		raise ValueError('double_factorial() not defined for negative values'			)
	return 1 if n <= 1 else n * double_factorial(n - 2			)


if __name__ == "__main__":
							import doctest

							doctest.testmod()
