






"""simple docstring"""







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





							"""simple docstring"""





							def __init__( self:  str					,		__A:  int					,		__A:  Optional[Any]=13					,		__A:  List[str]=7					,		__A:  Any=True					,		__A:  List[str]=True					,		__A:  Tuple=True					,		__A:  List[Any]=True					,		__A:  Dict=99					,		__A:  Tuple=24					,		__A:  Dict=32					,		__A:  List[str]=5					,		__A:  str=4					,		__A:  int=37					,		__A:  List[str]="gelu"					,		__A:  Optional[int]=0.1					,		__A:  Optional[int]=0.1					,		__A:  List[Any]=512					,		__A:  List[str]=16					,		__A:  Tuple=2					,		__A:  Any=0.0_2					,		__A:  Optional[int]=4					,		):

												'''simple docstring'''

												a__ 							=	parent
												a__ 							=	batch_size
												a__ 							=	seq_length
												a__ 							=	is_training
												a__ 							=	use_attention_mask
												a__ 							=	use_token_type_ids
												a__ 							=	use_labels
												a__ 							=	vocab_size
												a__ 							=	hidden_size
												a__ 							=	embedding_size
												a__ 							=	num_hidden_layers
												a__ 							=	num_attention_heads
												a__ 							=	intermediate_size
												a__ 							=	hidden_act
												a__ 							=	hidden_dropout_prob
												a__ 							=	attention_probs_dropout_prob
												a__ 							=	max_position_embeddings
												a__ 							=	type_vocab_size
												a__ 							=	type_sequence_label_size
												a__ 							=	initializer_range
												a__ 							=	num_choices




							def 			lowercase		( self:  Optional[Any]     ):

												'''simple docstring'''

												a__ 							=	ids_tensor([self.batch_size, self.seq_length]					,		self.vocab_size     )

												a__ 							=	None
												if self.use_attention_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__ 							=	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:  Any     ):

												'''simple docstring'''

												a__ 							=	self.prepare_config_and_inputs()
												a__							,a__							,a__							,a__ 							=	config_and_inputs
												a__ 							=	{'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': attention_mask}
												return config, inputs_dict







@require_flax
class 							_SCREAMING_SNAKE_CASE    (	__snake_case							,			unittest.TestCase				):





							"""simple docstring"""





							_SCREAMING_SNAKE_CASE     =True

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




							def 			lowercase		( self:  Any     ):

												'''simple docstring'''

												a__ 							=	FlaxElectraModelTester(self     )





							@slow
							def 			lowercase		( self:  Optional[int]     ):

												'''simple docstring'''

												for model_class_name in self.all_model_classes:
																	if model_class_name == FlaxElectraForMaskedLM:
																						a__ 							=	model_class_name.from_pretrained('''google/electra-small-generator'''     )
																	else:
																						a__ 							=	model_class_name.from_pretrained('''google/electra-small-discriminator'''     )
																	a__ 							=	model(np.ones((1, 1)     )     )
																	self.assertIsNotNone(__A     )










"""simple docstring"""







from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_sentencepiece_available, is_tokenizers_available


__a							:						Tuple   							=			{}

try:
	if not is_sentencepiece_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	__a							:						str   							=			['CpmTokenizer']

try:
	if not is_tokenizers_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	__a							:						List[str]   							=			['CpmTokenizerFast']


if TYPE_CHECKING:
	try:
		if not is_sentencepiece_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .tokenization_cpm import CpmTokenizer

	try:
		if not is_tokenizers_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .tokenization_cpm_fast import CpmTokenizerFast

else:
	import sys

	__a							:						Tuple   							=			_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)


