
"""simple docstring"""







from __future__ import annotations

import copy
import tempfile
import unittest

from transformers import CONFIG_MAPPING, AutoConfig, BertConfig, GPTaConfig, TaConfig, TapasConfig, is_tf_available
from transformers.testing_utils import (
    DUMMY_UNKNOWN_IDENTIFIER,
    SMALL_MODEL_IDENTIFIER,
    RequestCounter,
    require_tensorflow_probability,
    require_tf,
    slow,
)

from ..bert.test_modeling_bert import BertModelTester


if is_tf_available():
       from transformers import (
           TFAutoModel,
           TFAutoModelForCausalLM,
           TFAutoModelForMaskedLM,
           TFAutoModelForPreTraining,
           TFAutoModelForQuestionAnswering,
           TFAutoModelForSeqaSeqLM,
           TFAutoModelForSequenceClassification,
           TFAutoModelForTableQuestionAnswering,
           TFAutoModelForTokenClassification,
           TFAutoModelWithLMHead,
           TFBertForMaskedLM,
           TFBertForPreTraining,
           TFBertForQuestionAnswering,
           TFBertForSequenceClassification,
           TFBertModel,
           TFFunnelBaseModel,
           TFFunnelModel,
           TFGPTaLMHeadModel,
           TFRobertaForMaskedLM,
           TFTaForConditionalGeneration,
           TFTapasForQuestionAnswering,
       )
       from transformers.models.auto.modeling_tf_auto import (
           TF_MODEL_FOR_CAUSAL_LM_MAPPING,
           TF_MODEL_FOR_MASKED_LM_MAPPING,
           TF_MODEL_FOR_PRETRAINING_MAPPING,
           TF_MODEL_FOR_QUESTION_ANSWERING_MAPPING,
           TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
           TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
           TF_MODEL_MAPPING,
       )
       from transformers.models.bert.modeling_tf_bert import TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST
       from transformers.models.gpta.modeling_tf_gpta import TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST
       from transformers.models.ta.modeling_tf_ta import TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST
       from transformers.models.tapas.modeling_tf_tapas import TF_TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST




class 				A__ (			_lowerCamelCase):
  A_		: str            =			'new-model'


if is_tf_available():




       class 				A__ (			_lowerCamelCase):
         A_		: Optional[Any]            =			NewModelConfig




@require_tf
class 				A__ (			unittest.TestCase):

  @slow
  def 							__lowerCamelCase							(   self				):
   __lowerCAmelCase    :		Any		    =   'bert-base-cased'
   __lowerCAmelCase    :		Optional[int]		    =   AutoConfig.from_pretrained(_SCREAMING_SNAKE_CASE				)
   self.assertIsNotNone(_SCREAMING_SNAKE_CASE				)
   self.assertIsInstance(_SCREAMING_SNAKE_CASE ,	_SCREAMING_SNAKE_CASE				)

   __lowerCAmelCase    :		Any		    =   TFAutoModel.from_pretrained(_SCREAMING_SNAKE_CASE				)
   self.assertIsNotNone(_SCREAMING_SNAKE_CASE				)
   self.assertIsInstance(_SCREAMING_SNAKE_CASE ,	_SCREAMING_SNAKE_CASE				)

  @slow
  def 							__lowerCamelCase							(   self				):
   __lowerCAmelCase    :		Optional[int]		    =   'bert-base-cased'
   __lowerCAmelCase    :		List[str]		    =   AutoConfig.from_pretrained(_SCREAMING_SNAKE_CASE				)
   self.assertIsNotNone(_SCREAMING_SNAKE_CASE				)
   self.assertIsInstance(_SCREAMING_SNAKE_CASE ,	_SCREAMING_SNAKE_CASE				)

   __lowerCAmelCase    :		Any		    =   TFAutoModelForPreTraining.from_pretrained(_SCREAMING_SNAKE_CASE				)
   self.assertIsNotNone(_SCREAMING_SNAKE_CASE				)
   self.assertIsInstance(_SCREAMING_SNAKE_CASE ,	_SCREAMING_SNAKE_CASE				)

  @slow
  def 							__lowerCamelCase							(   self				):







   for model_name in TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
    __lowerCAmelCase    :		Optional[int]		    =   AutoConfig.from_pretrained(_SCREAMING_SNAKE_CASE				)
    self.assertIsNotNone(_SCREAMING_SNAKE_CASE				)
    self.assertIsInstance(_SCREAMING_SNAKE_CASE ,	_SCREAMING_SNAKE_CASE				)

    __lowerCAmelCase    :		Dict		    =   TFAutoModelForCausalLM.from_pretrained(_SCREAMING_SNAKE_CASE				)
    __lowerCAmelCase    ,     __lowerCAmelCase    :		str		    =   TFAutoModelForCausalLM.from_pretrained(_SCREAMING_SNAKE_CASE ,	output_loading_info=_SCREAMING_SNAKE_CASE				)
    self.assertIsNotNone(_SCREAMING_SNAKE_CASE				)
    self.assertIsInstance(_SCREAMING_SNAKE_CASE ,	_SCREAMING_SNAKE_CASE				)

  @slow
  def 							__lowerCamelCase							(   self				):







   for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
    __lowerCAmelCase    :		Tuple		    =   AutoConfig.from_pretrained(_SCREAMING_SNAKE_CASE				)
    self.assertIsNotNone(_SCREAMING_SNAKE_CASE				)
    self.assertIsInstance(_SCREAMING_SNAKE_CASE ,	_SCREAMING_SNAKE_CASE				)

    __lowerCAmelCase    :		Tuple		    =   TFAutoModelWithLMHead.from_pretrained(_SCREAMING_SNAKE_CASE				)
    self.assertIsNotNone(_SCREAMING_SNAKE_CASE				)
    self.assertIsInstance(_SCREAMING_SNAKE_CASE ,	_SCREAMING_SNAKE_CASE				)

  @slow
  def 							__lowerCamelCase							(   self				):







   for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
    __lowerCAmelCase    :		Tuple		    =   AutoConfig.from_pretrained(_SCREAMING_SNAKE_CASE				)
    self.assertIsNotNone(_SCREAMING_SNAKE_CASE				)
    self.assertIsInstance(_SCREAMING_SNAKE_CASE ,	_SCREAMING_SNAKE_CASE				)

    __lowerCAmelCase    :		Union[str, Any]		    =   TFAutoModelForMaskedLM.from_pretrained(_SCREAMING_SNAKE_CASE				)
    __lowerCAmelCase    ,     __lowerCAmelCase    :		Optional[Any]		    =   TFAutoModelForMaskedLM.from_pretrained(_SCREAMING_SNAKE_CASE ,	output_loading_info=_SCREAMING_SNAKE_CASE				)
    self.assertIsNotNone(_SCREAMING_SNAKE_CASE				)
    self.assertIsInstance(_SCREAMING_SNAKE_CASE ,	_SCREAMING_SNAKE_CASE				)

  @slow
  def 							__lowerCamelCase							(   self				):







   for model_name in TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
    __lowerCAmelCase    :		Dict		    =   AutoConfig.from_pretrained(_SCREAMING_SNAKE_CASE				)
    self.assertIsNotNone(_SCREAMING_SNAKE_CASE				)
    self.assertIsInstance(_SCREAMING_SNAKE_CASE ,	_SCREAMING_SNAKE_CASE				)

    __lowerCAmelCase    :		int		    =   TFAutoModelForSeqaSeqLM.from_pretrained(_SCREAMING_SNAKE_CASE				)
    __lowerCAmelCase    ,     __lowerCAmelCase    :		Dict		    =   TFAutoModelForSeqaSeqLM.from_pretrained(_SCREAMING_SNAKE_CASE ,	output_loading_info=_SCREAMING_SNAKE_CASE				)
    self.assertIsNotNone(_SCREAMING_SNAKE_CASE				)
    self.assertIsInstance(_SCREAMING_SNAKE_CASE ,	_SCREAMING_SNAKE_CASE				)

  @slow
  def 							__lowerCamelCase							(   self				):







   for model_name in ["bert-base-uncased"]:
    __lowerCAmelCase    :		Optional[Any]		    =   AutoConfig.from_pretrained(_SCREAMING_SNAKE_CASE				)
    self.assertIsNotNone(_SCREAMING_SNAKE_CASE				)
    self.assertIsInstance(_SCREAMING_SNAKE_CASE ,	_SCREAMING_SNAKE_CASE				)

    __lowerCAmelCase    :		str		    =   TFAutoModelForSequenceClassification.from_pretrained(_SCREAMING_SNAKE_CASE				)
    self.assertIsNotNone(_SCREAMING_SNAKE_CASE				)
    self.assertIsInstance(_SCREAMING_SNAKE_CASE ,	_SCREAMING_SNAKE_CASE				)

  @slow
  def 							__lowerCamelCase							(   self				):







   for model_name in ["bert-base-uncased"]:
    __lowerCAmelCase    :		Tuple		    =   AutoConfig.from_pretrained(_SCREAMING_SNAKE_CASE				)
    self.assertIsNotNone(_SCREAMING_SNAKE_CASE				)
    self.assertIsInstance(_SCREAMING_SNAKE_CASE ,	_SCREAMING_SNAKE_CASE				)

    __lowerCAmelCase    :		Optional[Any]		    =   TFAutoModelForQuestionAnswering.from_pretrained(_SCREAMING_SNAKE_CASE				)
    self.assertIsNotNone(_SCREAMING_SNAKE_CASE				)
    self.assertIsInstance(_SCREAMING_SNAKE_CASE ,	_SCREAMING_SNAKE_CASE				)

  @slow
  @require_tensorflow_probability
  def 							__lowerCamelCase							(   self				):







   for model_name in TF_TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST[5:6]:
    __lowerCAmelCase    :		List[str]		    =   AutoConfig.from_pretrained(_SCREAMING_SNAKE_CASE				)
    self.assertIsNotNone(_SCREAMING_SNAKE_CASE				)
    self.assertIsInstance(_SCREAMING_SNAKE_CASE ,	_SCREAMING_SNAKE_CASE				)

    __lowerCAmelCase    :		List[Any]		    =   TFAutoModelForTableQuestionAnswering.from_pretrained(_SCREAMING_SNAKE_CASE				)
    __lowerCAmelCase    ,     __lowerCAmelCase    :		Any		    =   TFAutoModelForTableQuestionAnswering.from_pretrained(
        _SCREAMING_SNAKE_CASE ,	output_loading_info=_SCREAMING_SNAKE_CASE				)
    self.assertIsNotNone(_SCREAMING_SNAKE_CASE				)
    self.assertIsInstance(_SCREAMING_SNAKE_CASE ,	_SCREAMING_SNAKE_CASE				)

  def 							__lowerCamelCase							(   self				):
   __lowerCAmelCase    :		Any		    =   TFAutoModelWithLMHead.from_pretrained(_SCREAMING_SNAKE_CASE				)
   self.assertIsInstance(_SCREAMING_SNAKE_CASE ,	_SCREAMING_SNAKE_CASE				)
   self.assertEqual(model.num_parameters() ,	1_44_10				)
   self.assertEqual(model.num_parameters(only_trainable=_SCREAMING_SNAKE_CASE				) ,	1_44_10				)

  def 							__lowerCamelCase							(   self				):
   __lowerCAmelCase    :		Tuple		    =   TFAutoModelWithLMHead.from_pretrained(_SCREAMING_SNAKE_CASE				)
   self.assertIsInstance(_SCREAMING_SNAKE_CASE ,	_SCREAMING_SNAKE_CASE				)
   self.assertEqual(model.num_parameters() ,	1_44_10				)
   self.assertEqual(model.num_parameters(only_trainable=_SCREAMING_SNAKE_CASE				) ,	1_44_10				)

  def 							__lowerCamelCase							(   self				):
   __lowerCAmelCase    :		Dict		    =   TFAutoModel.from_pretrained('sgugger/funnel-random-tiny'				)
   self.assertIsInstance(_SCREAMING_SNAKE_CASE ,	_SCREAMING_SNAKE_CASE				)

   __lowerCAmelCase    :		str		    =   copy.deepcopy(model.config				)
   __lowerCAmelCase    :		str		    =   ['FunnelBaseModel']
   __lowerCAmelCase    :		Optional[Any]		    =   TFAutoModel.from_config(_SCREAMING_SNAKE_CASE				)
   self.assertIsInstance(_SCREAMING_SNAKE_CASE ,	_SCREAMING_SNAKE_CASE				)

   with tempfile.TemporaryDirectory() as tmp_dir:
    model.save_pretrained(_SCREAMING_SNAKE_CASE				)
    __lowerCAmelCase    :		Optional[Any]		    =   TFAutoModel.from_pretrained(_SCREAMING_SNAKE_CASE				)
    self.assertIsInstance(_SCREAMING_SNAKE_CASE ,	_SCREAMING_SNAKE_CASE				)

  def 							__lowerCamelCase							(   self				):







   try:
    AutoConfig.register('new-model' ,	_SCREAMING_SNAKE_CASE				)

    __lowerCAmelCase    :		Tuple		    =   [
        TFAutoModel,
        TFAutoModelForCausalLM,
        TFAutoModelForMaskedLM,
        TFAutoModelForPreTraining,
        TFAutoModelForQuestionAnswering,
        TFAutoModelForSequenceClassification,
        TFAutoModelForTokenClassification,
    ]

    for auto_class in auto_classes:
     with self.subTest(auto_class.__name__				):
      # Wrong config class will raise an error
      with self.assertRaises(_SCREAMING_SNAKE_CASE				):
       auto_class.register(_SCREAMING_SNAKE_CASE ,	_SCREAMING_SNAKE_CASE				)
      auto_class.register(_SCREAMING_SNAKE_CASE ,	_SCREAMING_SNAKE_CASE				)
      # Trying to register something existing in the Transformers library will raise an error
      with self.assertRaises(_SCREAMING_SNAKE_CASE				):
       auto_class.register(_SCREAMING_SNAKE_CASE ,	_SCREAMING_SNAKE_CASE				)

      # Now that the config is registered, it can be used as any other config with the auto-API
      __lowerCAmelCase    :		Optional[int]		    =   BertModelTester(self				).get_config()
      __lowerCAmelCase    :		int		    =   NewModelConfig(**tiny_config.to_dict()				)
      __lowerCAmelCase    :		List[Any]		    =   auto_class.from_config(_SCREAMING_SNAKE_CASE				)
      self.assertIsInstance(_SCREAMING_SNAKE_CASE ,	_SCREAMING_SNAKE_CASE				)

      with tempfile.TemporaryDirectory() as tmp_dir:
       model.save_pretrained(_SCREAMING_SNAKE_CASE				)
       __lowerCAmelCase    :		Any		    =   auto_class.from_pretrained(_SCREAMING_SNAKE_CASE				)
       self.assertIsInstance(_SCREAMING_SNAKE_CASE ,	_SCREAMING_SNAKE_CASE				)

   finally:
    if "new-model" in CONFIG_MAPPING._extra_content:
     del CONFIG_MAPPING._extra_content["new-model"]
    for mapping in (
        TF_MODEL_MAPPING,
        TF_MODEL_FOR_PRETRAINING_MAPPING,
        TF_MODEL_FOR_QUESTION_ANSWERING_MAPPING,
        TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
        TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
        TF_MODEL_FOR_CAUSAL_LM_MAPPING,
        TF_MODEL_FOR_MASKED_LM_MAPPING,
    ):
     if NewModelConfig in mapping._extra_content:
      del mapping._extra_content[NewModelConfig]

  def 							__lowerCamelCase							(   self				):







   with self.assertRaisesRegex(
       _SCREAMING_SNAKE_CASE ,	'bert-base is not a local folder and is not a valid model identifier'				):
    __lowerCAmelCase    :		Tuple		    =   TFAutoModel.from_pretrained('bert-base'				)

  def 							__lowerCamelCase							(   self				):







   with self.assertRaisesRegex(
       _SCREAMING_SNAKE_CASE ,	R'aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)'				):
    __lowerCAmelCase    :		Optional[Any]		    =   TFAutoModel.from_pretrained(_SCREAMING_SNAKE_CASE ,	revision='aaaaaa'				)

  def 							__lowerCamelCase							(   self				):







   with self.assertRaisesRegex(
       _SCREAMING_SNAKE_CASE ,	'hf-internal-testing/config-no-model does not appear to have a file named pytorch_model.bin' ,	):
    __lowerCAmelCase    :		List[Any]		    =   TFAutoModel.from_pretrained('hf-internal-testing/config-no-model'				)

  def 							__lowerCamelCase							(   self				):







   with self.assertRaisesRegex(_SCREAMING_SNAKE_CASE ,	'Use `from_pt=True` to load this model'				):
    __lowerCAmelCase    :		int		    =   TFAutoModel.from_pretrained('hf-internal-testing/tiny-bert-pt-only'				)







  def 							__lowerCamelCase							(   self				):
   __lowerCAmelCase    :		Optional[int]		    =   TFAutoModel.from_pretrained('hf-internal-testing/tiny-random-bert'				)
   with RequestCounter() as counter:
    __lowerCAmelCase    :		str		    =   TFAutoModel.from_pretrained('hf-internal-testing/tiny-random-bert'				)
    self.assertEqual(counter.get_request_count ,	0				)
    self.assertEqual(counter.head_request_count ,	1				)
    self.assertEqual(counter.other_request_count ,	0				)

   # With a sharded checkpoint
   __lowerCAmelCase    :		Optional[Any]		    =   TFAutoModel.from_pretrained('ArthurZ/tiny-random-bert-sharded'				)
   with RequestCounter() as counter:
    __lowerCAmelCase    :		Dict		    =   TFAutoModel.from_pretrained('ArthurZ/tiny-random-bert-sharded'				)
    self.assertEqual(counter.get_request_count ,	0				)
    self.assertEqual(counter.head_request_count ,	1				)
    self.assertEqual(counter.other_request_count ,	0				)

"""simple docstring"""







import unittest

import numpy as np

from transformers import RobertaConfig, 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.roberta.modeling_flax_roberta import (
							    FlaxRobertaForCausalLM,
							    FlaxRobertaForMaskedLM,
							    FlaxRobertaForMultipleChoice,
							    FlaxRobertaForQuestionAnswering,
							    FlaxRobertaForSequenceClassification,
							    FlaxRobertaForTokenClassification,
							    FlaxRobertaModel,
							)




class 				A__ (			unittest.TestCase):

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

		def 							__lowerCamelCase							(   self				):
			__lowerCAmelCase    :		Union[str, Any]		    =   ids_tensor([self.batch_size, self.seq_length] ,	self.vocab_size				)

			__lowerCAmelCase    :		List[str]		    =   None
			if self.use_attention_mask:
				__lowerCAmelCase    :		str		    =   random_attention_mask([self.batch_size, self.seq_length]				)

			__lowerCAmelCase    :		Dict		    =   None
			if self.use_token_type_ids:
				__lowerCAmelCase    :		Tuple		    =   ids_tensor([self.batch_size, self.seq_length] ,	self.type_vocab_size				)

			__lowerCAmelCase    :		str		    =   RobertaConfig(
			    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 ,	)

			return config, input_ids, token_type_ids, attention_mask

		def 							__lowerCamelCase							(   self				):
			__lowerCAmelCase    :		Dict		    =   self.prepare_config_and_inputs()
			__lowerCAmelCase    ,     __lowerCAmelCase    ,     __lowerCAmelCase    ,     __lowerCAmelCase    :		List[Any]		    =   config_and_inputs
			__lowerCAmelCase    :		List[Any]		    =   {'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': attention_mask}
			return config, inputs_dict







		def 							__lowerCamelCase							(   self				):
			__lowerCAmelCase    :		Optional[int]		    =   self.prepare_config_and_inputs()
			__lowerCAmelCase    ,     __lowerCAmelCase    ,     __lowerCAmelCase    ,     __lowerCAmelCase    :		Any		    =   config_and_inputs

			__lowerCAmelCase    :		int		    =   True
			__lowerCAmelCase    :		Any		    =   floats_tensor([self.batch_size, self.seq_length, self.hidden_size]				)
			__lowerCAmelCase    :		int		    =   ids_tensor([self.batch_size, self.seq_length] ,	vocab_size=2				)

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




@require_flax
class 				A__ (			_lowerCamelCase ,  unittest.TestCase):
		A_		: List[Any]            =			True

		A_		: Optional[Any]            =			(
		    (
		        FlaxRobertaModel,
		        FlaxRobertaForCausalLM,
		        FlaxRobertaForMaskedLM,
		        FlaxRobertaForSequenceClassification,
		        FlaxRobertaForTokenClassification,
		        FlaxRobertaForMultipleChoice,
		        FlaxRobertaForQuestionAnswering,
		    )
		    if is_flax_available()
		    else ()
		)

		def 							__lowerCamelCase							(   self				):
			__lowerCAmelCase    :		Tuple		    =   FlaxRobertaModelTester(self				)







		@slow
		def 							__lowerCamelCase							(   self				):
			for model_class_name in self.all_model_classes:
				__lowerCAmelCase    :		str		    =   model_class_name.from_pretrained('roberta-base' ,	from_pt=_SCREAMING_SNAKE_CASE				)
				__lowerCAmelCase    :		Optional[int]		    =   model(np.ones((1, 1)				)				)
				self.assertIsNotNone(_SCREAMING_SNAKE_CASE				)