





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

  """simple docstring"""


  @slow
  def 				lowercase		(				self :		Tuple     )							->						Dict:
     for model_name in ["bert-base-cased", "bert-large-uncased"]:
        with self.subTest(__lowerCamelCase     ):
           __lowerCAmelCase								=	AutoConfig.from_pretrained(__lowerCamelCase     )
           self.assertIsNotNone(__lowerCamelCase     )
           self.assertIsInstance(__lowerCamelCase					,  __lowerCamelCase     )

           __lowerCAmelCase								=	FlaxAutoModel.from_pretrained(__lowerCamelCase     )
           self.assertIsNotNone(__lowerCamelCase     )
           self.assertIsInstance(__lowerCamelCase					,  __lowerCamelCase     )






  @slow
  def 				lowercase		(				self :		Union[str, Any]     )							->						int:
     for model_name in ["roberta-base", "roberta-large"]:
        with self.subTest(__lowerCamelCase     ):
           __lowerCAmelCase								=	AutoConfig.from_pretrained(__lowerCamelCase     )
           self.assertIsNotNone(__lowerCamelCase     )
           self.assertIsInstance(__lowerCamelCase					,  __lowerCamelCase     )

           __lowerCAmelCase								=	FlaxAutoModel.from_pretrained(__lowerCamelCase     )
           self.assertIsNotNone(__lowerCamelCase     )
           self.assertIsInstance(__lowerCamelCase					,  __lowerCamelCase     )






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

        @jax.jit
        def eval(**lowerCAmelCase_ :		str     ):
           return model(**__lowerCamelCase     )

        eval(**__lowerCamelCase     ).block_until_ready()






  @slow
  def 				lowercase		(				self :		str     )							->						List[Any]:
     for model_name in ["roberta-base", "roberta-large"]:
        __lowerCAmelCase								=	AutoTokenizer.from_pretrained(__lowerCamelCase     )
        __lowerCAmelCase								=	FlaxRobertaModel.from_pretrained(__lowerCamelCase     )
        __lowerCAmelCase								=	tokenizer('Do you support jax jitted function?'					,  return_tensors=TensorType.JAX     )

        @jax.jit
        def eval(**lowerCAmelCase_ :		Any     ):
           return model(**__lowerCamelCase     )

        eval(**__lowerCamelCase     ).block_until_ready()






  def 				lowercase		(				self :		Optional[Any]     )							->						Dict:
     with self.assertRaisesRegex(
         __lowerCamelCase					,  'bert-base is not a local folder and is not a valid model identifier'     ):
        __lowerCAmelCase								=	FlaxAutoModel.from_pretrained('bert-base'     )






  def 				lowercase		(				self :		Tuple     )							->						Tuple:
     with self.assertRaisesRegex(
         __lowerCamelCase					,  R'aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)'     ):
        __lowerCAmelCase								=	FlaxAutoModel.from_pretrained(__lowerCamelCase					,  revision='aaaaaa'     )






  def 				lowercase		(				self :		Any     )							->						List[str]:
     with self.assertRaisesRegex(
         __lowerCamelCase					,  'hf-internal-testing/config-no-model does not appear to have a file named flax_model.msgpack'					,  ):
        __lowerCAmelCase								=	FlaxAutoModel.from_pretrained('hf-internal-testing/config-no-model'     )






  def 				lowercase		(				self :		List[str]     )							->						Any:
     with self.assertRaisesRegex(__lowerCamelCase					,  'Use `from_pt=True` to load this model'     ):
        __lowerCAmelCase								=	FlaxAutoModel.from_pretrained('hf-internal-testing/tiny-bert-pt-only'     )








import json
from typing import List, Optional, Tuple

from tokenizers import normalizers

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_distilbert import DistilBertTokenizer


a__:      Dict									=		logging.get_logger(__name__)

a__:      str									=		{'vocab_file': 'vocab.txt', 'tokenizer_file': 'tokenizer.json'}

a__:      Any									=		{
    'vocab_file': {
        'distilbert-base-uncased': 'https://huggingface.co/distilbert-base-uncased/resolve/main/vocab.txt',
        'distilbert-base-uncased-distilled-squad': (
            'https://huggingface.co/distilbert-base-uncased-distilled-squad/resolve/main/vocab.txt'
        ),
        'distilbert-base-cased': 'https://huggingface.co/distilbert-base-cased/resolve/main/vocab.txt',
        'distilbert-base-cased-distilled-squad': (
            'https://huggingface.co/distilbert-base-cased-distilled-squad/resolve/main/vocab.txt'
        ),
        'distilbert-base-german-cased': 'https://huggingface.co/distilbert-base-german-cased/resolve/main/vocab.txt',
        'distilbert-base-multilingual-cased': (
            'https://huggingface.co/distilbert-base-multilingual-cased/resolve/main/vocab.txt'
        ),
    },
    'tokenizer_file': {
        'distilbert-base-uncased': 'https://huggingface.co/distilbert-base-uncased/resolve/main/tokenizer.json',
        'distilbert-base-uncased-distilled-squad': (
            'https://huggingface.co/distilbert-base-uncased-distilled-squad/resolve/main/tokenizer.json'
        ),
        'distilbert-base-cased': 'https://huggingface.co/distilbert-base-cased/resolve/main/tokenizer.json',
        'distilbert-base-cased-distilled-squad': (
            'https://huggingface.co/distilbert-base-cased-distilled-squad/resolve/main/tokenizer.json'
        ),
        'distilbert-base-german-cased': (
            'https://huggingface.co/distilbert-base-german-cased/resolve/main/tokenizer.json'
        ),
        'distilbert-base-multilingual-cased': (
            'https://huggingface.co/distilbert-base-multilingual-cased/resolve/main/tokenizer.json'
        ),
    },
}

a__:      Any									=		{
    'distilbert-base-uncased': 512,
    'distilbert-base-uncased-distilled-squad': 512,
    'distilbert-base-cased': 512,
    'distilbert-base-cased-distilled-squad': 512,
    'distilbert-base-german-cased': 512,
    'distilbert-base-multilingual-cased': 512,
}


a__:      Optional[Any]									=		{
    'distilbert-base-uncased': {'do_lower_case': True},
    'distilbert-base-uncased-distilled-squad': {'do_lower_case': True},
    'distilbert-base-cased': {'do_lower_case': False},
    'distilbert-base-cased-distilled-squad': {'do_lower_case': False},
    'distilbert-base-german-cased': {'do_lower_case': False},
    'distilbert-base-multilingual-cased': {'do_lower_case': False},
}




class     SCREAMING_SNAKE_CASE__ (						UpperCamelCase__      ):
 __SCREAMING_SNAKE_CASE							       =	VOCAB_FILES_NAMES
 __SCREAMING_SNAKE_CASE							       =	PRETRAINED_VOCAB_FILES_MAP
 __SCREAMING_SNAKE_CASE							       =	PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
 __SCREAMING_SNAKE_CASE							       =	PRETRAINED_INIT_CONFIGURATION
 __SCREAMING_SNAKE_CASE							       =	['''input_ids''', '''attention_mask''']
 __SCREAMING_SNAKE_CASE							       =	DistilBertTokenizer



 def __init__(							self,__lowerCamelCase=None,__lowerCamelCase=None,__lowerCamelCase=True,__lowerCamelCase="[UNK]",__lowerCamelCase="[SEP]",__lowerCamelCase="[PAD]",__lowerCamelCase="[CLS]",__lowerCamelCase="[MASK]",__lowerCamelCase=True,__lowerCamelCase=None,**__lowerCamelCase,):
        super().__init__(
            __lowerCamelCase,tokenizer_file=__lowerCamelCase,do_lower_case=__lowerCamelCase,unk_token=__lowerCamelCase,sep_token=__lowerCamelCase,pad_token=__lowerCamelCase,cls_token=__lowerCamelCase,mask_token=__lowerCamelCase,tokenize_chinese_chars=__lowerCamelCase,strip_accents=__lowerCamelCase,**__lowerCamelCase,)

        A__											=						json.loads(self.backend_tokenizer.normalizer.__getstate__() )
        if (
            normalizer_state.get('''lowercase''',__lowerCamelCase ) != do_lower_case
            or normalizer_state.get('''strip_accents''',__lowerCamelCase ) != strip_accents
            or normalizer_state.get('''handle_chinese_chars''',__lowerCamelCase ) != tokenize_chinese_chars
        ):
               A__											=						getattr(__lowerCamelCase,normalizer_state.pop('''type''' ) )
               A__											=						do_lower_case
               A__											=						strip_accents
               A__											=						tokenize_chinese_chars
               A__											=						normalizer_class(**__lowerCamelCase )

        A__											=						do_lower_case



 def 				UpperCamelCase			(							self,__lowerCamelCase,__lowerCamelCase=None ):
        A__											=						[self.cls_token_id] + token_ids_a + [self.sep_token_id]

        if token_ids_a:
               output += token_ids_a + [self.sep_token_id]

        return output



 def 				UpperCamelCase			(							self,__lowerCamelCase,__lowerCamelCase = None ):
        A__											=						[self.sep_token_id]
        A__											=						[self.cls_token_id]
        if token_ids_a is None:
               return len(cls + token_ids_a + sep ) * [0]
        return len(cls + token_ids_a + sep ) * [0] + len(token_ids_a + sep ) * [1]




 def 				UpperCamelCase			(							self,__lowerCamelCase,__lowerCamelCase = None ):
        A__											=						self._tokenizer.model.save(__lowerCamelCase,name=__lowerCamelCase )
        return tuple(__lowerCamelCase )





