

import unittest

import numpy as np

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

from ...test_modeling_flax_common import FlaxModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask


if is_flax_available():
					from transformers.models.bert.modeling_flax_bert import (
					    FlaxBertForMaskedLM,
					    FlaxBertForMultipleChoice,
					    FlaxBertForNextSentencePrediction,
					    FlaxBertForPreTraining,
					    FlaxBertForQuestionAnswering,
					    FlaxBertForSequenceClassification,
					    FlaxBertForTokenClassification,
					    FlaxBertModel,
					)







class 			lowercase    (	unittest.TestCase      ):




				def __init__( self				,       snake_case				,       snake_case=13				,       snake_case=7				,       snake_case=True				,       snake_case=True				,       snake_case=True				,       snake_case=True				,       snake_case=99				,       snake_case=32				,       snake_case=5				,       snake_case=4				,       snake_case=37				,       snake_case="gelu"				,       snake_case=0.1				,       snake_case=0.1				,       snake_case=512				,       snake_case=16				,       snake_case=2				,       snake_case=0.02				,       snake_case=4				,       ):
											snake_case_          =   parent
											snake_case_          =   batch_size
											snake_case_          =   seq_length
											snake_case_          =   is_training
											snake_case_          =   use_attention_mask
											snake_case_          =   use_token_type_ids
											snake_case_          =   use_labels
											snake_case_          =   vocab_size
											snake_case_          =   hidden_size
											snake_case_          =   num_hidden_layers
											snake_case_          =   num_attention_heads
											snake_case_          =   intermediate_size
											snake_case_          =   hidden_act
											snake_case_          =   hidden_dropout_prob
											snake_case_          =   attention_probs_dropout_prob
											snake_case_          =   max_position_embeddings
											snake_case_          =   type_vocab_size
											snake_case_          =   type_sequence_label_size
											snake_case_          =   initializer_range
											snake_case_          =   num_choices




				def    a							( self	):
											snake_case_          =   ids_tensor([self.batch_size, self.seq_length]				,       self.vocab_size	)

											snake_case_          =   None
											if self.use_attention_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_          =   BertConfig(
											    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=snake_case				,       initializer_range=self.initializer_range				,       )

											return config, input_ids, token_type_ids, attention_mask




				def    a							( self	):
											snake_case_          =   self.prepare_config_and_inputs()
											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': attention_mask}
											return config, inputs_dict




				def    a							( self	):
											snake_case_          =   self.prepare_config_and_inputs()
											snake_case_    ,   snake_case_    ,   snake_case_    ,   snake_case_          =   config_and_inputs

											snake_case_          =   True
											snake_case_          =   floats_tensor([self.batch_size, self.seq_length, self.hidden_size]	)
											snake_case_          =   ids_tensor([self.batch_size, self.seq_length]				,       vocab_size=2	)

											return (
											    config,
											    input_ids,
											    attention_mask,
											    encoder_hidden_states,
											    encoder_attention_mask,
											)







@require_flax
class 			lowercase    (	lowercase_     ,  unittest.TestCase      ):
				__SCREAMING_SNAKE_CASE :			Dict	      =      True

				__SCREAMING_SNAKE_CASE :			List[Any]	      =      (
				    (
				        FlaxBertModel,
				        FlaxBertForPreTraining,
				        FlaxBertForMaskedLM,
				        FlaxBertForMultipleChoice,
				        FlaxBertForQuestionAnswering,
				        FlaxBertForNextSentencePrediction,
				        FlaxBertForSequenceClassification,
				        FlaxBertForTokenClassification,
				        FlaxBertForQuestionAnswering,
				    )
				    if is_flax_available()
				    else ()
				)




				def    a							( self	):
											snake_case_          =   FlaxBertModelTester(self	)




				@slow
				def    a							( self	):
											# Only check this for base model, not necessary for all model classes.
											# This will also help speed-up tests.
											snake_case_          =   FlaxBertModel.from_pretrained('bert-base-cased'	)
											snake_case_          =   model(np.ones((1, 1)	)	)
											self.assertIsNotNone(snake_case	)







from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


_UpperCAmelCase		:       Tuple						    =	{
    """configuration_xlm_roberta_xl""": [
        """XLM_ROBERTA_XL_PRETRAINED_CONFIG_ARCHIVE_MAP""",
        """XLMRobertaXLConfig""",
        """XLMRobertaXLOnnxConfig""",
    ],
}

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					_UpperCAmelCase		:       int						    =	[
					    """XLM_ROBERTA_XL_PRETRAINED_MODEL_ARCHIVE_LIST""",
					    """XLMRobertaXLForCausalLM""",
					    """XLMRobertaXLForMaskedLM""",
					    """XLMRobertaXLForMultipleChoice""",
					    """XLMRobertaXLForQuestionAnswering""",
					    """XLMRobertaXLForSequenceClassification""",
					    """XLMRobertaXLForTokenClassification""",
					    """XLMRobertaXLModel""",
					    """XLMRobertaXLPreTrainedModel""",
					]

if TYPE_CHECKING:
					from .configuration_xlm_roberta_xl import (
					    XLM_ROBERTA_XL_PRETRAINED_CONFIG_ARCHIVE_MAP,
					    XLMRobertaXLConfig,
					    XLMRobertaXLOnnxConfig,
					)

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_xlm_roberta_xl import (
										    XLM_ROBERTA_XL_PRETRAINED_MODEL_ARCHIVE_LIST,
										    XLMRobertaXLForCausalLM,
										    XLMRobertaXLForMaskedLM,
										    XLMRobertaXLForMultipleChoice,
										    XLMRobertaXLForQuestionAnswering,
										    XLMRobertaXLForSequenceClassification,
										    XLMRobertaXLForTokenClassification,
										    XLMRobertaXLModel,
										    XLMRobertaXLPreTrainedModel,
										)

else:
					import sys

					_UpperCAmelCase		:       Optional[Any]						    =	_LazyModule(__name__, globals()["""__file__"""], _import_structure)




