from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


UpperCAmelCase_								=							{
    '''configuration_electra''': ['''ELECTRA_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''ElectraConfig''', '''ElectraOnnxConfig'''],
    '''tokenization_electra''': ['''ElectraTokenizer'''],
}

try:
      if not is_tokenizers_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      UpperCAmelCase_								=							['''ElectraTokenizerFast''']

try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      UpperCAmelCase_								=							[
          '''ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST''',
          '''ElectraForCausalLM''',
          '''ElectraForMaskedLM''',
          '''ElectraForMultipleChoice''',
          '''ElectraForPreTraining''',
          '''ElectraForQuestionAnswering''',
          '''ElectraForSequenceClassification''',
          '''ElectraForTokenClassification''',
          '''ElectraModel''',
          '''ElectraPreTrainedModel''',
          '''load_tf_weights_in_electra''',
      ]

try:
      if not is_tf_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      UpperCAmelCase_								=							[
          '''TF_ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST''',
          '''TFElectraForMaskedLM''',
          '''TFElectraForMultipleChoice''',
          '''TFElectraForPreTraining''',
          '''TFElectraForQuestionAnswering''',
          '''TFElectraForSequenceClassification''',
          '''TFElectraForTokenClassification''',
          '''TFElectraModel''',
          '''TFElectraPreTrainedModel''',
      ]

try:
      if not is_flax_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      UpperCAmelCase_								=							[
          '''FlaxElectraForCausalLM''',
          '''FlaxElectraForMaskedLM''',
          '''FlaxElectraForMultipleChoice''',
          '''FlaxElectraForPreTraining''',
          '''FlaxElectraForQuestionAnswering''',
          '''FlaxElectraForSequenceClassification''',
          '''FlaxElectraForTokenClassification''',
          '''FlaxElectraModel''',
          '''FlaxElectraPreTrainedModel''',
      ]


if TYPE_CHECKING:
      from .configuration_electra import ELECTRA_PRETRAINED_CONFIG_ARCHIVE_MAP, ElectraConfig, ElectraOnnxConfig
      from .tokenization_electra import ElectraTokenizer

      try:
            if not is_tokenizers_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .tokenization_electra_fast import ElectraTokenizerFast

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_electra import (
                ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST,
                ElectraForCausalLM,
                ElectraForMaskedLM,
                ElectraForMultipleChoice,
                ElectraForPreTraining,
                ElectraForQuestionAnswering,
                ElectraForSequenceClassification,
                ElectraForTokenClassification,
                ElectraModel,
                ElectraPreTrainedModel,
                load_tf_weights_in_electra,
            )

      try:
            if not is_tf_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_tf_electra import (
                TF_ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST,
                TFElectraForMaskedLM,
                TFElectraForMultipleChoice,
                TFElectraForPreTraining,
                TFElectraForQuestionAnswering,
                TFElectraForSequenceClassification,
                TFElectraForTokenClassification,
                TFElectraModel,
                TFElectraPreTrainedModel,
            )

      try:
            if not is_flax_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_flax_electra import (
                FlaxElectraForCausalLM,
                FlaxElectraForMaskedLM,
                FlaxElectraForMultipleChoice,
                FlaxElectraForPreTraining,
                FlaxElectraForQuestionAnswering,
                FlaxElectraForSequenceClassification,
                FlaxElectraForTokenClassification,
                FlaxElectraModel,
                FlaxElectraPreTrainedModel,
            )

else:
      import sys

      UpperCAmelCase_								=							_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
import unittest

from transformers import AutoConfig, AutoTokenizer, BertConfig, TensorType, is_flax_available
from transformers.testing_utils import DUMMY_UNKNOWN_IDENTIFIER, require_flax, slow


if is_flax_available():
      import jax

      from transformers.models.auto.modeling_flax_auto import FlaxAutoModel
      from transformers.models.bert.modeling_flax_bert import FlaxBertModel
      from transformers.models.roberta.modeling_flax_roberta import FlaxRobertaModel





@require_flax
class      lowerCAmelCase						(					unittest.TestCase			):



     @slow
     def 			a__  (					self       ):
            for model_name in ["bert-base-cased", "bert-large-uncased"]:
                   with self.subTest(lowerCAmelCase__       ):
                          _A=	AutoConfig.from_pretrained(lowerCAmelCase__       )
                          self.assertIsNotNone(lowerCAmelCase__       )
                          self.assertIsInstance(lowerCAmelCase__				,      lowerCAmelCase__       )

                          _A=	FlaxAutoModel.from_pretrained(lowerCAmelCase__       )
                          self.assertIsNotNone(lowerCAmelCase__       )
                          self.assertIsInstance(lowerCAmelCase__				,      lowerCAmelCase__       )



     @slow
     def 			a__  (					self       ):
            for model_name in ["roberta-base", "roberta-large"]:
                   with self.subTest(lowerCAmelCase__       ):
                          _A=	AutoConfig.from_pretrained(lowerCAmelCase__       )
                          self.assertIsNotNone(lowerCAmelCase__       )
                          self.assertIsInstance(lowerCAmelCase__				,      lowerCAmelCase__       )

                          _A=	FlaxAutoModel.from_pretrained(lowerCAmelCase__       )
                          self.assertIsNotNone(lowerCAmelCase__       )
                          self.assertIsInstance(lowerCAmelCase__				,      lowerCAmelCase__       )



     @slow
     def 			a__  (					self       ):
            for model_name in ["bert-base-cased", "bert-large-uncased"]:
                   _A=	AutoTokenizer.from_pretrained(lowerCAmelCase__       )
                   _A=	FlaxBertModel.from_pretrained(lowerCAmelCase__       )
                   _A=	tokenizer('Do you support jax jitted function?'				,      return_tensors=TensorType.JAX       )

                   @jax.jit
                   def eval(**lowerCAmelCase__       ):
                          return model(**lowerCAmelCase__       )

                   eval(**lowerCAmelCase__       ).block_until_ready()



     @slow
     def 			a__  (					self       ):
            for model_name in ["roberta-base", "roberta-large"]:
                   _A=	AutoTokenizer.from_pretrained(lowerCAmelCase__       )
                   _A=	FlaxRobertaModel.from_pretrained(lowerCAmelCase__       )
                   _A=	tokenizer('Do you support jax jitted function?'				,      return_tensors=TensorType.JAX       )

                   @jax.jit
                   def eval(**lowerCAmelCase__       ):
                          return model(**lowerCAmelCase__       )

                   eval(**lowerCAmelCase__       ).block_until_ready()



     def 			a__  (					self       ):
            with self.assertRaisesRegex(
                lowerCAmelCase__				,      'bert-base is not a local folder and is not a valid model identifier'       ):
                   _A=	FlaxAutoModel.from_pretrained('bert-base'       )



     def 			a__  (					self       ):
            with self.assertRaisesRegex(
                lowerCAmelCase__				,      r'aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)'       ):
                   _A=	FlaxAutoModel.from_pretrained(lowerCAmelCase__				,      revision='aaaaaa'       )



     def 			a__  (					self       ):
            with self.assertRaisesRegex(
                lowerCAmelCase__				,      'hf-internal-testing/config-no-model does not appear to have a file named flax_model.msgpack'				,      ):
                   _A=	FlaxAutoModel.from_pretrained('hf-internal-testing/config-no-model'       )





     def 			a__  (					self       ):
            with self.assertRaisesRegex(lowerCAmelCase__				,      'Use `from_pt=True` to load this model'       ):
                   _A=	FlaxAutoModel.from_pretrained('hf-internal-testing/tiny-bert-pt-only'       )