import numpy as np

from transformers import BatchFeature
from transformers.testing_utils import require_tf, require_torch

from .test_feature_extraction_common import FeatureExtractionSavingTestMixin


class      lowerCamelCase    (UpperCamelCase__    ):
  """simple docstring"""







  lowerCamelCase__   =  None
  lowerCamelCase__   =  None







  @property
  def       __A   (							self       :				Union[str, Any]      )     ->		Optional[Any]:
        return self.feat_extract_tester.prepare_feat_extract_dict()







  def       __A   (							self       :				Any      )     ->		Any:
        SCREAMING_SNAKE_CASE_      =     self.feature_extraction_class(**self.feat_extract_dict      )
        self.assertTrue(hasattr(__lowerCamelCase     ,   "feature_size"      )      )
        self.assertTrue(hasattr(__lowerCamelCase     ,   "sampling_rate"      )      )
        self.assertTrue(hasattr(__lowerCamelCase     ,   "padding_value"      )      )







  def       __A   (							self       :				List[Any]      )     ->		int:
        SCREAMING_SNAKE_CASE_      =     self.feat_extract_tester.prepare_inputs_for_common()
        SCREAMING_SNAKE_CASE_      =     self.feature_extraction_class(**self.feat_extract_dict      )
        SCREAMING_SNAKE_CASE_      =     feat_extract.model_input_names[0]

        SCREAMING_SNAKE_CASE_      =     BatchFeature({input_name: speech_inputs}      )

        self.assertTrue(all(len(__lowerCamelCase      ) == len(__lowerCamelCase      ) for x, y in zip(__lowerCamelCase     ,   processed_features[input_name]      )      )      )

        SCREAMING_SNAKE_CASE_      =     self.feat_extract_tester.prepare_inputs_for_common(equal_length=__lowerCamelCase      )
        SCREAMING_SNAKE_CASE_      =     BatchFeature({input_name: speech_inputs}     ,   tensor_type="np"      )

        SCREAMING_SNAKE_CASE_      =     processed_features[input_name]

        if len(batch_features_input.shape      ) < 3:
              SCREAMING_SNAKE_CASE_      =     batch_features_input[:, :, None]

        self.assertTrue(
            batch_features_input.shape
            == (self.feat_extract_tester.batch_size, len(speech_inputs[0]      ), self.feat_extract_tester.feature_size)      )







  @require_torch
  def       __A   (							self       :				Optional[Any]      )     ->		List[str]:
        SCREAMING_SNAKE_CASE_      =     self.feat_extract_tester.prepare_inputs_for_common(equal_length=__lowerCamelCase      )
        SCREAMING_SNAKE_CASE_      =     self.feature_extraction_class(**self.feat_extract_dict      )
        SCREAMING_SNAKE_CASE_      =     feat_extract.model_input_names[0]

        SCREAMING_SNAKE_CASE_      =     BatchFeature({input_name: speech_inputs}     ,   tensor_type="pt"      )

        SCREAMING_SNAKE_CASE_      =     processed_features[input_name]

        if len(batch_features_input.shape      ) < 3:
              SCREAMING_SNAKE_CASE_      =     batch_features_input[:, :, None]

        self.assertTrue(
            batch_features_input.shape
            == (self.feat_extract_tester.batch_size, len(speech_inputs[0]      ), self.feat_extract_tester.feature_size)      )







  @require_tf
  def       __A   (							self       :				str      )     ->		Tuple:
        SCREAMING_SNAKE_CASE_      =     self.feat_extract_tester.prepare_inputs_for_common(equal_length=__lowerCamelCase      )
        SCREAMING_SNAKE_CASE_      =     self.feature_extraction_class(**self.feat_extract_dict      )
        SCREAMING_SNAKE_CASE_      =     feat_extract.model_input_names[0]

        SCREAMING_SNAKE_CASE_      =     BatchFeature({input_name: speech_inputs}     ,   tensor_type="tf"      )

        SCREAMING_SNAKE_CASE_      =     processed_features[input_name]

        if len(batch_features_input.shape      ) < 3:
              SCREAMING_SNAKE_CASE_      =     batch_features_input[:, :, None]

        self.assertTrue(
            batch_features_input.shape
            == (self.feat_extract_tester.batch_size, len(speech_inputs[0]      ), self.feat_extract_tester.feature_size)      )







  def       __A   (							self       :				int     ,   __magic_name__       :				str=False      )     ->		Any:
        def _inputs_have_equal_length(__magic_name__       :				Tuple      ):
              SCREAMING_SNAKE_CASE_      =     len(input[0]      )
              for input_slice in input[1:]:
                    if len(__lowerCamelCase      ) != length:
                          return False
              return True

        def _inputs_are_equal(__magic_name__       :				Dict     ,   __magic_name__       :				Optional[int]      ):
              if len(__lowerCamelCase      ) != len(__lowerCamelCase      ):
                    return False

              for input_slice_a, input_slice_a in zip(__lowerCamelCase     ,   __lowerCamelCase      ):
                    if not np.allclose(np.asarray(__lowerCamelCase      )     ,   np.asarray(__lowerCamelCase      )     ,   atol=1e-3      ):
                          return False
              return True

        SCREAMING_SNAKE_CASE_      =     self.feature_extraction_class(**self.feat_extract_dict      )
        SCREAMING_SNAKE_CASE_      =     self.feat_extract_tester.prepare_inputs_for_common(numpify=__lowerCamelCase      )
        SCREAMING_SNAKE_CASE_      =     feat_extract.model_input_names[0]

        SCREAMING_SNAKE_CASE_      =     BatchFeature({input_name: speech_inputs}      )

        SCREAMING_SNAKE_CASE_      =     self.feat_extract_tester.seq_length_diff
        SCREAMING_SNAKE_CASE_      =     self.feat_extract_tester.max_seq_length + pad_diff
        SCREAMING_SNAKE_CASE_      =     self.feat_extract_tester.min_seq_length
        SCREAMING_SNAKE_CASE_      =     self.feat_extract_tester.batch_size
        SCREAMING_SNAKE_CASE_      =     self.feat_extract_tester.feature_size

        # test padding for List[int] + numpy
        SCREAMING_SNAKE_CASE_      =     feat_extract.pad(__lowerCamelCase     ,   padding=__lowerCamelCase      )
        SCREAMING_SNAKE_CASE_      =     input_a[input_name]

        SCREAMING_SNAKE_CASE_      =     feat_extract.pad(__lowerCamelCase     ,   padding="longest"      )
        SCREAMING_SNAKE_CASE_      =     input_a[input_name]

        SCREAMING_SNAKE_CASE_      =     feat_extract.pad(__lowerCamelCase     ,   padding="max_length"     ,   max_length=len(speech_inputs[-1]      )      )
        SCREAMING_SNAKE_CASE_      =     input_a[input_name]

        SCREAMING_SNAKE_CASE_      =     feat_extract.pad(__lowerCamelCase     ,   padding="longest"     ,   return_tensors="np"      )
        SCREAMING_SNAKE_CASE_      =     input_a[input_name]

        # max_length parameter has to be provided when setting `padding="max_length"`
        with self.assertRaises(__lowerCamelCase      ):
              feat_extract.pad(__lowerCamelCase     ,   padding="max_length"      )[input_name]

        SCREAMING_SNAKE_CASE_      =     feat_extract.pad(
            __lowerCamelCase     ,   padding="max_length"     ,   max_length=__lowerCamelCase     ,   return_tensors="np"      )
        SCREAMING_SNAKE_CASE_      =     input_a[input_name]

        self.assertFalse(_inputs_have_equal_length(__lowerCamelCase      )      )
        self.assertTrue(_inputs_have_equal_length(__lowerCamelCase      )      )
        self.assertTrue(_inputs_have_equal_length(__lowerCamelCase      )      )
        self.assertTrue(_inputs_are_equal(__lowerCamelCase     ,   __lowerCamelCase      )      )
        self.assertTrue(len(input_a[0]      ) == pad_min_length      )
        self.assertTrue(len(input_a[1]      ) == pad_min_length + pad_diff      )
        self.assertTrue(input_a.shape[:2] == (batch_size, len(input_a[0]      ))      )
        self.assertTrue(input_a.shape[:2] == (batch_size, pad_max_length)      )

        if feature_size > 1:
              self.assertTrue(input_a.shape[2] == input_a.shape[2] == feature_size      )

        # test padding for `pad_to_multiple_of` for List[int] + numpy
        SCREAMING_SNAKE_CASE_      =     feat_extract.pad(__lowerCamelCase     ,   pad_to_multiple_of=10      )
        SCREAMING_SNAKE_CASE_      =     input_a[input_name]

        SCREAMING_SNAKE_CASE_      =     feat_extract.pad(__lowerCamelCase     ,   padding="longest"     ,   pad_to_multiple_of=10      )
        SCREAMING_SNAKE_CASE_      =     input_a[input_name]

        SCREAMING_SNAKE_CASE_      =     feat_extract.pad(
            __lowerCamelCase     ,   padding="max_length"     ,   pad_to_multiple_of=10     ,   max_length=__lowerCamelCase      )
        SCREAMING_SNAKE_CASE_      =     input_a[input_name]

        SCREAMING_SNAKE_CASE_      =     feat_extract.pad(
            __lowerCamelCase     ,   padding="max_length"     ,   pad_to_multiple_of=10     ,   max_length=__lowerCamelCase     ,   return_tensors="np"     ,   )
        SCREAMING_SNAKE_CASE_      =     input_a[input_name]

        self.assertTrue(all(len(__lowerCamelCase      ) % 10 == 0 for x in input_a      )      )
        self.assertTrue(_inputs_are_equal(__lowerCamelCase     ,   __lowerCamelCase      )      )

        SCREAMING_SNAKE_CASE_      =     pad_max_length if pad_max_length % 10 == 0 else (pad_max_length // 10 + 1) * 10
        self.assertTrue(all(len(__lowerCamelCase      ) == expected_mult_pad_length for x in input_a      )      )
        self.assertEqual(input_a.shape[:2]     ,   (batch_size, expected_mult_pad_length)      )

        if feature_size > 1:
              self.assertTrue(input_a.shape[2] == feature_size      )

        # Check padding value is correct
        SCREAMING_SNAKE_CASE_      =     (np.ones(self.feat_extract_tester.feature_size      ) * feat_extract.padding_value).sum()
        self.assertTrue(
            abs(np.asarray(input_a[0]      )[pad_min_length:].sum() - padding_vector_sum * (pad_max_length - pad_min_length)      )
            < 1e-3      )
        self.assertTrue(
            abs(
                np.asarray(input_a[1]      )[pad_min_length + pad_diff :].sum()
                - padding_vector_sum * (pad_max_length - pad_min_length - pad_diff)      )
            < 1e-3      )
        self.assertTrue(
            abs(
                np.asarray(input_a[2]      )[pad_min_length + 2 * pad_diff :].sum()
                - padding_vector_sum * (pad_max_length - pad_min_length - 2 * pad_diff)      )
            < 1e-3      )
        self.assertTrue(
            abs(input_a[0, pad_min_length:].sum() - padding_vector_sum * (pad_max_length - pad_min_length)      ) < 1e-3      )
        self.assertTrue(
            abs(input_a[0, pad_min_length:].sum() - padding_vector_sum * (expected_mult_pad_length - pad_min_length)      )
            < 1e-3      )







  def       __A   (							self       :				str     ,   __magic_name__       :				List[str]=False      )     ->		str:
        def _inputs_have_equal_length(__magic_name__       :				Optional[Any]      ):
              SCREAMING_SNAKE_CASE_      =     len(input[0]      )
              for input_slice in input[1:]:
                    if len(__lowerCamelCase      ) != length:
                          return False
              return True

        def _inputs_are_equal(__magic_name__       :				str     ,   __magic_name__       :				Optional[Any]      ):
              if len(__lowerCamelCase      ) != len(__lowerCamelCase      ):
                    return False

              for input_slice_a, input_slice_a in zip(__lowerCamelCase     ,   __lowerCamelCase      ):
                    if not np.allclose(np.asarray(__lowerCamelCase      )     ,   np.asarray(__lowerCamelCase      )     ,   atol=1e-3      ):
                          return False
              return True

        SCREAMING_SNAKE_CASE_      =     self.feature_extraction_class(**self.feat_extract_dict      )
        SCREAMING_SNAKE_CASE_      =     self.feat_extract_tester.prepare_inputs_for_common(numpify=__lowerCamelCase      )
        SCREAMING_SNAKE_CASE_      =     feat_extract.model_input_names[0]

        SCREAMING_SNAKE_CASE_      =     BatchFeature({input_name: speech_inputs}      )

        # truncate to smallest
        SCREAMING_SNAKE_CASE_      =     feat_extract.pad(
            __lowerCamelCase     ,   padding="max_length"     ,   max_length=len(speech_inputs[0]      )     ,   truncation=__lowerCamelCase      )
        SCREAMING_SNAKE_CASE_      =     input_a[input_name]

        SCREAMING_SNAKE_CASE_      =     feat_extract.pad(__lowerCamelCase     ,   padding="max_length"     ,   max_length=len(speech_inputs[0]      )      )
        SCREAMING_SNAKE_CASE_      =     input_a[input_name]

        self.assertTrue(_inputs_have_equal_length(__lowerCamelCase      )      )
        self.assertFalse(_inputs_have_equal_length(__lowerCamelCase      )      )

        # truncate to smallest with np
        SCREAMING_SNAKE_CASE_      =     feat_extract.pad(
            __lowerCamelCase     ,   padding="max_length"     ,   max_length=len(speech_inputs[0]      )     ,   return_tensors="np"     ,   truncation=__lowerCamelCase     ,   )
        SCREAMING_SNAKE_CASE_      =     input_a[input_name]

        SCREAMING_SNAKE_CASE_      =     feat_extract.pad(
            __lowerCamelCase     ,   padding="max_length"     ,   max_length=len(speech_inputs[0]      )     ,   return_tensors="np"      )
        SCREAMING_SNAKE_CASE_      =     input_a[input_name]

        self.assertTrue(_inputs_have_equal_length(__lowerCamelCase      )      )
        self.assertTrue(input_a.shape[1] == len(speech_inputs[0]      )      )

        # since truncation forces padding to be smaller than longest input
        # function can't return `np.ndarray`, but has to return list
        self.assertFalse(_inputs_have_equal_length(__lowerCamelCase      )      )

        # truncate to middle
        SCREAMING_SNAKE_CASE_      =     feat_extract.pad(
            __lowerCamelCase     ,   padding="max_length"     ,   max_length=len(speech_inputs[1]      )     ,   truncation=__lowerCamelCase     ,   return_tensors="np"     ,   )
        SCREAMING_SNAKE_CASE_      =     input_a[input_name]

        SCREAMING_SNAKE_CASE_      =     feat_extract.pad(
            __lowerCamelCase     ,   padding="max_length"     ,   max_length=len(speech_inputs[1]      )     ,   truncation=__lowerCamelCase      )
        SCREAMING_SNAKE_CASE_      =     input_a[input_name]

        SCREAMING_SNAKE_CASE_      =     feat_extract.pad(
            __lowerCamelCase     ,   padding="max_length"     ,   max_length=len(speech_inputs[1]      )     ,   return_tensors="np"      )
        SCREAMING_SNAKE_CASE_      =     input_a[input_name]

        self.assertTrue(input_a.shape[1] == len(speech_inputs[1]      )      )
        self.assertTrue(_inputs_have_equal_length(__lowerCamelCase      )      )
        self.assertTrue(_inputs_have_equal_length(__lowerCamelCase      )      )
        self.assertTrue(_inputs_are_equal(__lowerCamelCase     ,   __lowerCamelCase      )      )

        # since truncation forces padding to be smaller than longest input
        # function can't return `np.ndarray`, but has to return list
        self.assertFalse(_inputs_have_equal_length(__lowerCamelCase      )      )
        self.assertTrue(len(input_a[-1]      ) == len(speech_inputs[-1]      )      )

        # padding has to be max_length when setting `truncation=True`
        with self.assertRaises(__lowerCamelCase      ):
              feat_extract.pad(__lowerCamelCase     ,   truncation=__lowerCamelCase      )[input_name]

        # padding has to be max_length when setting `truncation=True`
        with self.assertRaises(__lowerCamelCase      ):
              feat_extract.pad(__lowerCamelCase     ,   padding="longest"     ,   truncation=__lowerCamelCase      )[input_name]

        # padding has to be max_length when setting `truncation=True`
        with self.assertRaises(__lowerCamelCase      ):
              feat_extract.pad(__lowerCamelCase     ,   padding="longest"     ,   truncation=__lowerCamelCase      )[input_name]

        # max_length parameter has to be provided when setting `truncation=True` and padding="max_length"
        with self.assertRaises(__lowerCamelCase      ):
              feat_extract.pad(__lowerCamelCase     ,   padding="max_length"     ,   truncation=__lowerCamelCase      )[input_name]

        # test truncation for `pad_to_multiple_of` for List[int] + numpy
        SCREAMING_SNAKE_CASE_      =     12
        SCREAMING_SNAKE_CASE_      =     feat_extract.pad(
            __lowerCamelCase     ,   padding="max_length"     ,   max_length=len(speech_inputs[0]      )     ,   pad_to_multiple_of=__lowerCamelCase     ,   truncation=__lowerCamelCase     ,   )
        SCREAMING_SNAKE_CASE_      =     input_a[input_name]

        SCREAMING_SNAKE_CASE_      =     feat_extract.pad(
            __lowerCamelCase     ,   padding="max_length"     ,   max_length=len(speech_inputs[0]      )     ,   pad_to_multiple_of=__lowerCamelCase     ,   )
        SCREAMING_SNAKE_CASE_      =     input_a[input_name]

        # retrieve expected_length as multiple of pad_to_multiple_of
        SCREAMING_SNAKE_CASE_      =     len(speech_inputs[0]      )
        if expected_length % pad_to_multiple_of != 0:
              SCREAMING_SNAKE_CASE_      =     ((len(speech_inputs[0]      ) // pad_to_multiple_of) + 1) * pad_to_multiple_of

        self.assertTrue(len(input_a[0]      ) == expected_length      )
        self.assertTrue(_inputs_have_equal_length(__lowerCamelCase      )      )
        self.assertFalse(_inputs_have_equal_length(__lowerCamelCase      )      )







  def       __A   (							self       :				Optional[Any]      )     ->		Dict:
        self._check_padding(numpify=__lowerCamelCase      )







  def       __A   (							self       :				Any      )     ->		Optional[Any]:
        self._check_padding(numpify=__lowerCamelCase      )







  def       __A   (							self       :				int      )     ->		Union[str, Any]:
        self._check_truncation(numpify=__lowerCamelCase      )







  def       __A   (							self       :				Optional[Any]      )     ->		int:
        self._check_truncation(numpify=__lowerCamelCase      )







  @require_torch
  def       __A   (							self       :				Tuple      )     ->		int:
        SCREAMING_SNAKE_CASE_      =     self.feature_extraction_class(**self.feat_extract_dict      )
        SCREAMING_SNAKE_CASE_      =     self.feat_extract_tester.prepare_inputs_for_common()
        SCREAMING_SNAKE_CASE_      =     feat_extract.model_input_names[0]

        SCREAMING_SNAKE_CASE_      =     BatchFeature({input_name: speech_inputs}      )

        SCREAMING_SNAKE_CASE_      =     feat_extract.pad(__lowerCamelCase     ,   padding="longest"     ,   return_tensors="np"      )[input_name]
        SCREAMING_SNAKE_CASE_      =     feat_extract.pad(__lowerCamelCase     ,   padding="longest"     ,   return_tensors="pt"      )[input_name]

        self.assertTrue(abs(input_np.astype(np.floataa      ).sum() - input_pt.numpy().astype(np.floataa      ).sum()      ) < 1e-2      )







  @require_tf
  def       __A   (							self       :				int      )     ->		int:
        SCREAMING_SNAKE_CASE_      =     self.feature_extraction_class(**self.feat_extract_dict      )
        SCREAMING_SNAKE_CASE_      =     self.feat_extract_tester.prepare_inputs_for_common()
        SCREAMING_SNAKE_CASE_      =     feat_extract.model_input_names[0]

        SCREAMING_SNAKE_CASE_      =     BatchFeature({input_name: speech_inputs}      )

        SCREAMING_SNAKE_CASE_      =     feat_extract.pad(__lowerCamelCase     ,   padding="longest"     ,   return_tensors="np"      )[input_name]
        SCREAMING_SNAKE_CASE_      =     feat_extract.pad(__lowerCamelCase     ,   padding="longest"     ,   return_tensors="tf"      )[input_name]

        self.assertTrue(abs(input_np.astype(np.floataa      ).sum() - input_tf.numpy().astype(np.floataa      ).sum()      ) < 1e-2      )







  def       __A   (							self       :				List[Any]      )     ->		List[Any]:
        SCREAMING_SNAKE_CASE_      =     self.feat_extract_dict
        SCREAMING_SNAKE_CASE_      =     True
        SCREAMING_SNAKE_CASE_      =     self.feature_extraction_class(**__lowerCamelCase      )
        SCREAMING_SNAKE_CASE_      =     self.feat_extract_tester.prepare_inputs_for_common()
        SCREAMING_SNAKE_CASE_      =     [len(__lowerCamelCase      ) for x in speech_inputs]
        SCREAMING_SNAKE_CASE_      =     feat_extract.model_input_names[0]

        SCREAMING_SNAKE_CASE_      =     BatchFeature({input_name: speech_inputs}      )

        SCREAMING_SNAKE_CASE_      =     feat_extract.pad(__lowerCamelCase     ,   padding="longest"     ,   return_tensors="np"      )
        self.assertIn("attention_mask"     ,   __lowerCamelCase      )
        self.assertListEqual(list(processed.attention_mask.shape      )     ,   list(processed[input_name].shape[:2]      )      )
        self.assertListEqual(processed.attention_mask.sum(-1      ).tolist()     ,   __lowerCamelCase      )







  def       __A   (							self       :				str      )     ->		Dict:
        SCREAMING_SNAKE_CASE_      =     self.feat_extract_dict
        SCREAMING_SNAKE_CASE_      =     True
        SCREAMING_SNAKE_CASE_      =     self.feature_extraction_class(**__lowerCamelCase      )
        SCREAMING_SNAKE_CASE_      =     self.feat_extract_tester.prepare_inputs_for_common()
        SCREAMING_SNAKE_CASE_      =     [len(__lowerCamelCase      ) for x in speech_inputs]
        SCREAMING_SNAKE_CASE_      =     feat_extract.model_input_names[0]

        SCREAMING_SNAKE_CASE_      =     BatchFeature({input_name: speech_inputs}      )
        SCREAMING_SNAKE_CASE_      =     min(__lowerCamelCase      )

        SCREAMING_SNAKE_CASE_      =     feat_extract.pad(
            __lowerCamelCase     ,   padding="max_length"     ,   max_length=__lowerCamelCase     ,   truncation=__lowerCamelCase     ,   return_tensors="np"      )
        self.assertIn("attention_mask"     ,   __lowerCamelCase      )
        self.assertListEqual(
            list(processed_pad.attention_mask.shape      )     ,   [processed_pad[input_name].shape[0], max_length]      )
        self.assertListEqual(
            processed_pad.attention_mask[:, :max_length].sum(-1      ).tolist()     ,   [max_length for x in speech_inputs]      )









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     SCREAMING_SNAKE_CASE__ (						unittest.TestCase      ):



 @slow
 def 				UpperCamelCase			(							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 				UpperCamelCase			(							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 				UpperCamelCase			(							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 				UpperCamelCase			(							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 				UpperCamelCase			(							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 				UpperCamelCase			(							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 				UpperCamelCase			(							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 				UpperCamelCase			(							self ):
        with self.assertRaisesRegex(__lowerCamelCase,'''Use `from_pt=True` to load this model''' ):
               A__											=						FlaxAutoModel.from_pretrained('''hf-internal-testing/tiny-bert-pt-only''' )





