




'''simple docstring'''



import os
import shutil
import sys
import tempfile
import unittest
from pathlib import Path

import pytest

import transformers
from transformers import (
    BERT_PRETRAINED_CONFIG_ARCHIVE_MAP,
    GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP,
    AutoTokenizer,
    BertConfig,
    BertTokenizer,
    BertTokenizerFast,
    CTRLTokenizer,
    GPTaTokenizer,
    GPTaTokenizerFast,
    PreTrainedTokenizerFast,
    RobertaTokenizer,
    RobertaTokenizerFast,
    is_tokenizers_available,
)
from transformers.models.auto.configuration_auto import CONFIG_MAPPING, AutoConfig
from transformers.models.auto.tokenization_auto import (
    TOKENIZER_MAPPING,
    get_tokenizer_config,
    tokenizer_class_from_name,
)
from transformers.models.roberta.configuration_roberta import RobertaConfig
from transformers.testing_utils import (
    DUMMY_DIFF_TOKENIZER_IDENTIFIER,
    DUMMY_UNKNOWN_IDENTIFIER,
    SMALL_MODEL_IDENTIFIER,
    RequestCounter,
    require_tokenizers,
    slow,
)


sys.path.append(str(Path(__file__).parent.parent.parent.parent / 'utils'))

from test_module.custom_configuration import CustomConfig  # noqa E402
from test_module.custom_tokenization import CustomTokenizer  # noqa E402


if is_tokenizers_available():
 from test_module.custom_tokenization_fast import CustomTokenizerFast







class 		lowercase_   (			unittest.TestCase       ):


   """simple docstring"""

   def 							lowerCAmelCase_      (   self :     Any   ):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE	=				0



   @slow
   def 							lowerCAmelCase_      (   self :     int   ):

      """simple docstring"""
      for model_name in (x for x in BERT_PRETRAINED_CONFIG_ARCHIVE_MAP.keys() if "japanese" not in x):
         _SCREAMING_SNAKE_CASE	=				AutoTokenizer.from_pretrained(__lowerCamelCase   )
         self.assertIsNotNone(__lowerCamelCase   )
         self.assertIsInstance(__lowerCamelCase  ,				(BertTokenizer, BertTokenizerFast)   )
         self.assertGreater(len(__lowerCamelCase   )  ,				0   )

      for model_name in GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP.keys():
         _SCREAMING_SNAKE_CASE	=				AutoTokenizer.from_pretrained(__lowerCamelCase   )
         self.assertIsNotNone(__lowerCamelCase   )
         self.assertIsInstance(__lowerCamelCase  ,				(GPTaTokenizer, GPTaTokenizerFast)   )
         self.assertGreater(len(__lowerCamelCase   )  ,				0   )



   def 							lowerCAmelCase_      (   self :     Any   ):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE	=				AutoTokenizer.from_pretrained(__lowerCamelCase   )
      self.assertIsInstance(__lowerCamelCase  ,				(BertTokenizer, BertTokenizerFast)   )
      self.assertEqual(tokenizer.vocab_size  ,				1_2   )



   def 							lowerCAmelCase_      (   self :     List[Any]   ):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE	=				AutoTokenizer.from_pretrained(__lowerCamelCase   )
      self.assertIsInstance(__lowerCamelCase  ,				(RobertaTokenizer, RobertaTokenizerFast)   )
      self.assertEqual(tokenizer.vocab_size  ,				2_0   )



   def 							lowerCAmelCase_      (   self :     Any   ):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE	=				AutoConfig.from_pretrained(__lowerCamelCase   )
      self.assertIsInstance(__lowerCamelCase  ,				__lowerCamelCase   )
      # Check that tokenizer_type ≠ model_type
      _SCREAMING_SNAKE_CASE	=				AutoTokenizer.from_pretrained(__lowerCamelCase  ,				config=__lowerCamelCase   )
      self.assertIsInstance(__lowerCamelCase  ,				(BertTokenizer, BertTokenizerFast)   )
      self.assertEqual(tokenizer.vocab_size  ,				1_2   )



   def 							lowerCAmelCase_      (   self :     Optional[int]   ):

      """simple docstring"""
      with tempfile.TemporaryDirectory() as tmp_dir:
         shutil.copy("./tests/fixtures/vocab.txt"  ,				os.path.join(__lowerCamelCase  ,				"vocab.txt"   )   )

         _SCREAMING_SNAKE_CASE	=				AutoTokenizer.from_pretrained(__lowerCamelCase  ,				tokenizer_type="bert"  ,				use_fast=__lowerCamelCase   )
         self.assertIsInstance(__lowerCamelCase  ,				__lowerCamelCase   )

      with tempfile.TemporaryDirectory() as tmp_dir:
         shutil.copy("./tests/fixtures/vocab.json"  ,				os.path.join(__lowerCamelCase  ,				"vocab.json"   )   )
         shutil.copy("./tests/fixtures/merges.txt"  ,				os.path.join(__lowerCamelCase  ,				"merges.txt"   )   )

         _SCREAMING_SNAKE_CASE	=				AutoTokenizer.from_pretrained(__lowerCamelCase  ,				tokenizer_type="gpt2"  ,				use_fast=__lowerCamelCase   )
         self.assertIsInstance(__lowerCamelCase  ,				__lowerCamelCase   )



   @require_tokenizers
   def 							lowerCAmelCase_      (   self :     List[Any]   ):

      """simple docstring"""
      with tempfile.TemporaryDirectory() as tmp_dir:
         shutil.copy("./tests/fixtures/vocab.txt"  ,				os.path.join(__lowerCamelCase  ,				"vocab.txt"   )   )

         _SCREAMING_SNAKE_CASE	=				AutoTokenizer.from_pretrained(__lowerCamelCase  ,				tokenizer_type="bert"   )
         self.assertIsInstance(__lowerCamelCase  ,				__lowerCamelCase   )

      with tempfile.TemporaryDirectory() as tmp_dir:
         shutil.copy("./tests/fixtures/vocab.json"  ,				os.path.join(__lowerCamelCase  ,				"vocab.json"   )   )
         shutil.copy("./tests/fixtures/merges.txt"  ,				os.path.join(__lowerCamelCase  ,				"merges.txt"   )   )

         _SCREAMING_SNAKE_CASE	=				AutoTokenizer.from_pretrained(__lowerCamelCase  ,				tokenizer_type="gpt2"   )
         self.assertIsInstance(__lowerCamelCase  ,				__lowerCamelCase   )



   def 							lowerCAmelCase_      (   self :     Dict   ):

      """simple docstring"""
      with pytest.raises(__lowerCamelCase   ):
         AutoTokenizer.from_pretrained("./"  ,				tokenizer_type="xxx"   )



   @require_tokenizers
   def 							lowerCAmelCase_      (   self :     Any   ):

      """simple docstring"""
      for tokenizer_class in [BertTokenizer, BertTokenizerFast, AutoTokenizer]:
         _SCREAMING_SNAKE_CASE	=				tokenizer_class.from_pretrained("wietsedv/bert-base-dutch-cased"   )
         self.assertIsInstance(__lowerCamelCase  ,				(BertTokenizer, BertTokenizerFast)   )

         if isinstance(__lowerCamelCase  ,				__lowerCamelCase   ):
            self.assertEqual(tokenizer.basic_tokenizer.do_lower_case  ,				__lowerCamelCase   )
         else:
            self.assertEqual(tokenizer.do_lower_case  ,				__lowerCamelCase   )

         self.assertEqual(tokenizer.model_max_length  ,				5_1_2   )



   @require_tokenizers
   def 							lowerCAmelCase_      (   self :     List[str]   ):

      """simple docstring"""
      for tokenizer_class in [BertTokenizer, BertTokenizerFast, AutoTokenizer]:
         with self.assertRaisesRegex(
             __lowerCamelCase  ,				"julien-c/herlolip-not-exists is not a local folder and is not a valid model identifier"  ,				):
            _SCREAMING_SNAKE_CASE	=				tokenizer_class.from_pretrained("julien-c/herlolip-not-exists"   )



   def 							lowerCAmelCase_      (   self :     Any   ):

      """simple docstring"""
      # tests: https://github.com/huggingface/transformers/pull/13251
      # 1. models with `-`, e.g. xlm-roberta -> xlm_roberta
      # 2. models that don't remap 1-1 from model-name to model file, e.g., openai-gpt -> openai
      _SCREAMING_SNAKE_CASE	=				TOKENIZER_MAPPING.values()
      _SCREAMING_SNAKE_CASE	=				[]

      for slow_tok, fast_tok in tokenizers:
         if slow_tok is not None:
            tokenizer_names.append(slow_tok.__name__   )

         if fast_tok is not None:
            tokenizer_names.append(fast_tok.__name__   )

      for tokenizer_name in tokenizer_names:
         # must find the right class
         tokenizer_class_from_name(__lowerCamelCase   )



   @require_tokenizers
   def 							lowerCAmelCase_      (   self :     List[str]   ):

      """simple docstring"""
      self.assertIsInstance(AutoTokenizer.from_pretrained("bert-base-cased"  ,				use_fast=__lowerCamelCase   )  ,				__lowerCamelCase   )
      self.assertIsInstance(AutoTokenizer.from_pretrained("bert-base-cased"   )  ,				__lowerCamelCase   )



   @require_tokenizers
   def 							lowerCAmelCase_      (   self :     List[str]   ):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE	=				AutoTokenizer.from_pretrained("distilbert-base-uncased"  ,				do_lower_case=__lowerCamelCase   )
      _SCREAMING_SNAKE_CASE	=				"Hello, world. How are you?"
      _SCREAMING_SNAKE_CASE	=				tokenizer.tokenize(__lowerCamelCase   )
      self.assertEqual("[UNK]"  ,				tokens[0]   )

      _SCREAMING_SNAKE_CASE	=				AutoTokenizer.from_pretrained("microsoft/mpnet-base"  ,				do_lower_case=__lowerCamelCase   )
      _SCREAMING_SNAKE_CASE	=				tokenizer.tokenize(__lowerCamelCase   )
      self.assertEqual("[UNK]"  ,				tokens[0]   )



   @require_tokenizers
   def 							lowerCAmelCase_      (   self :     Union[str, Any]   ):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE	=				AutoTokenizer.from_pretrained("robot-test/dummy-tokenizer-fast-with-model-config"   )
      self.assertEqual(type(__lowerCamelCase   )  ,				__lowerCamelCase   )
      self.assertEqual(tokenizer.model_max_length  ,				5_1_2   )
      self.assertEqual(tokenizer.vocab_size  ,				3_0_0_0_0   )
      self.assertEqual(tokenizer.unk_token  ,				"[UNK]"   )
      self.assertEqual(tokenizer.padding_side  ,				"right"   )
      self.assertEqual(tokenizer.truncation_side  ,				"right"   )



   def 							lowerCAmelCase_      (   self :     List[str]   ):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE	=				AutoTokenizer.from_pretrained(__lowerCamelCase   )
      self.assertIsInstance(__lowerCamelCase  ,				(BertTokenizer, BertTokenizerFast)   )
      with tempfile.TemporaryDirectory() as tmp_dir:
         tokenizer.save_pretrained(__lowerCamelCase   )
         _SCREAMING_SNAKE_CASE	=				AutoTokenizer.from_pretrained(__lowerCamelCase   )

      self.assertIsInstance(__lowerCamelCase  ,				tokenizer.__class__   )
      self.assertEqual(tokenizera.vocab_size  ,				1_2   )



   def 							lowerCAmelCase_      (   self :     Any   ):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE	=				AutoTokenizer.from_pretrained("ctrl"   )
      # There is no fast CTRL so this always gives us a slow tokenizer.
      self.assertIsInstance(__lowerCamelCase  ,				__lowerCamelCase   )



   def 							lowerCAmelCase_      (   self :     Optional[Any]   ):

      """simple docstring"""
      # Check we can load the tokenizer config of an online model.
      _SCREAMING_SNAKE_CASE	=				get_tokenizer_config("bert-base-cased"   )
      _SCREAMING_SNAKE_CASE	=				config.pop("_commit_hash"  ,				__lowerCamelCase   )
      # If we ever update bert-base-cased tokenizer config, this dict here will need to be updated.
      self.assertEqual(__lowerCamelCase  ,				{"do_lower_case": False}   )

      # This model does not have a tokenizer_config so we get back an empty dict.
      _SCREAMING_SNAKE_CASE	=				get_tokenizer_config(__lowerCamelCase   )
      self.assertDictEqual(__lowerCamelCase  ,				{}   )

      # A tokenizer saved with `save_pretrained` always creates a tokenizer config.
      _SCREAMING_SNAKE_CASE	=				AutoTokenizer.from_pretrained(__lowerCamelCase   )
      with tempfile.TemporaryDirectory() as tmp_dir:
         tokenizer.save_pretrained(__lowerCamelCase   )
         _SCREAMING_SNAKE_CASE	=				get_tokenizer_config(__lowerCamelCase   )

      # Check the class of the tokenizer was properly saved (note that it always saves the slow class).
      self.assertEqual(config["tokenizer_class"]  ,				"BertTokenizer"   )



   def 							lowerCAmelCase_      (   self :     Optional[Any]   ):

      """simple docstring"""
      try:
         AutoConfig.register("custom"  ,				__lowerCamelCase   )

         AutoTokenizer.register(__lowerCamelCase  ,				slow_tokenizer_class=__lowerCamelCase   )
         # Trying to register something existing in the Transformers library will raise an error
         with self.assertRaises(__lowerCamelCase   ):
            AutoTokenizer.register(__lowerCamelCase  ,				slow_tokenizer_class=__lowerCamelCase   )

         _SCREAMING_SNAKE_CASE	=				CustomTokenizer.from_pretrained(__lowerCamelCase   )
         with tempfile.TemporaryDirectory() as tmp_dir:
            tokenizer.save_pretrained(__lowerCamelCase   )

            _SCREAMING_SNAKE_CASE	=				AutoTokenizer.from_pretrained(__lowerCamelCase   )
            self.assertIsInstance(__lowerCamelCase  ,				__lowerCamelCase   )

      finally:
         if "custom" in CONFIG_MAPPING._extra_content:
            del CONFIG_MAPPING._extra_content["custom"]
         if CustomConfig in TOKENIZER_MAPPING._extra_content:
            del TOKENIZER_MAPPING._extra_content[CustomConfig]



   @require_tokenizers
   def 							lowerCAmelCase_      (   self :     Dict   ):

      """simple docstring"""
      try:
         AutoConfig.register("custom"  ,				__lowerCamelCase   )

         # Can register in two steps
         AutoTokenizer.register(__lowerCamelCase  ,				slow_tokenizer_class=__lowerCamelCase   )
         self.assertEqual(TOKENIZER_MAPPING[CustomConfig]  ,				(CustomTokenizer, None)   )
         AutoTokenizer.register(__lowerCamelCase  ,				fast_tokenizer_class=__lowerCamelCase   )
         self.assertEqual(TOKENIZER_MAPPING[CustomConfig]  ,				(CustomTokenizer, CustomTokenizerFast)   )

         del TOKENIZER_MAPPING._extra_content[CustomConfig]
         # Can register in one step
         AutoTokenizer.register(
             __lowerCamelCase  ,				slow_tokenizer_class=__lowerCamelCase  ,				fast_tokenizer_class=__lowerCamelCase   )
         self.assertEqual(TOKENIZER_MAPPING[CustomConfig]  ,				(CustomTokenizer, CustomTokenizerFast)   )

         # Trying to register something existing in the Transformers library will raise an error
         with self.assertRaises(__lowerCamelCase   ):
            AutoTokenizer.register(__lowerCamelCase  ,				fast_tokenizer_class=__lowerCamelCase   )

         # We pass through a bert tokenizer fast cause there is no converter slow to fast for our new toknizer
         # and that model does not have a tokenizer.json
         with tempfile.TemporaryDirectory() as tmp_dir:
            _SCREAMING_SNAKE_CASE	=				BertTokenizerFast.from_pretrained(__lowerCamelCase   )
            bert_tokenizer.save_pretrained(__lowerCamelCase   )
            _SCREAMING_SNAKE_CASE	=				CustomTokenizerFast.from_pretrained(__lowerCamelCase   )

         with tempfile.TemporaryDirectory() as tmp_dir:
            tokenizer.save_pretrained(__lowerCamelCase   )

            _SCREAMING_SNAKE_CASE	=				AutoTokenizer.from_pretrained(__lowerCamelCase   )
            self.assertIsInstance(__lowerCamelCase  ,				__lowerCamelCase   )

            _SCREAMING_SNAKE_CASE	=				AutoTokenizer.from_pretrained(__lowerCamelCase  ,				use_fast=__lowerCamelCase   )
            self.assertIsInstance(__lowerCamelCase  ,				__lowerCamelCase   )

      finally:
         if "custom" in CONFIG_MAPPING._extra_content:
            del CONFIG_MAPPING._extra_content["custom"]
         if CustomConfig in TOKENIZER_MAPPING._extra_content:
            del TOKENIZER_MAPPING._extra_content[CustomConfig]



   def 							lowerCAmelCase_      (   self :     List[str]   ):

      """simple docstring"""
      # If remote code is not set, we will time out when asking whether to load the model.
      with self.assertRaises(__lowerCamelCase   ):
         _SCREAMING_SNAKE_CASE	=				AutoTokenizer.from_pretrained("hf-internal-testing/test_dynamic_tokenizer"   )
      # If remote code is disabled, we can't load this config.
      with self.assertRaises(__lowerCamelCase   ):
         _SCREAMING_SNAKE_CASE	=				AutoTokenizer.from_pretrained(
             "hf-internal-testing/test_dynamic_tokenizer"  ,				trust_remote_code=__lowerCamelCase   )

      _SCREAMING_SNAKE_CASE	=				AutoTokenizer.from_pretrained("hf-internal-testing/test_dynamic_tokenizer"  ,				trust_remote_code=__lowerCamelCase   )
      self.assertTrue(tokenizer.special_attribute_present   )
      # Test tokenizer can be reloaded.
      with tempfile.TemporaryDirectory() as tmp_dir:
         tokenizer.save_pretrained(__lowerCamelCase   )
         _SCREAMING_SNAKE_CASE	=				AutoTokenizer.from_pretrained(__lowerCamelCase  ,				trust_remote_code=__lowerCamelCase   )
      self.assertTrue(reloaded_tokenizer.special_attribute_present   )

      if is_tokenizers_available():
         self.assertEqual(tokenizer.__class__.__name__  ,				"NewTokenizerFast"   )
         self.assertEqual(reloaded_tokenizer.__class__.__name__  ,				"NewTokenizerFast"   )

         # Test we can also load the slow version
         _SCREAMING_SNAKE_CASE	=				AutoTokenizer.from_pretrained(
             "hf-internal-testing/test_dynamic_tokenizer"  ,				trust_remote_code=__lowerCamelCase  ,				use_fast=__lowerCamelCase   )
         self.assertTrue(tokenizer.special_attribute_present   )
         self.assertEqual(tokenizer.__class__.__name__  ,				"NewTokenizer"   )
         # Test tokenizer can be reloaded.
         with tempfile.TemporaryDirectory() as tmp_dir:
            tokenizer.save_pretrained(__lowerCamelCase   )
            _SCREAMING_SNAKE_CASE	=				AutoTokenizer.from_pretrained(__lowerCamelCase  ,				trust_remote_code=__lowerCamelCase  ,				use_fast=__lowerCamelCase   )
         self.assertEqual(reloaded_tokenizer.__class__.__name__  ,				"NewTokenizer"   )
         self.assertTrue(reloaded_tokenizer.special_attribute_present   )
      else:
         self.assertEqual(tokenizer.__class__.__name__  ,				"NewTokenizer"   )
         self.assertEqual(reloaded_tokenizer.__class__.__name__  ,				"NewTokenizer"   )



   @require_tokenizers
   def 							lowerCAmelCase_      (   self :     str   ):

      """simple docstring"""







      class 		lowercase_   (			A       ):


         """simple docstring"""

         lowerCamelCase_      =						False







      class 		lowercase_   (			A       ):


         """simple docstring"""

         lowerCamelCase_      =						NewTokenizer
         lowerCamelCase_      =						False

      try:
         AutoConfig.register("custom"  ,				__lowerCamelCase   )
         AutoTokenizer.register(__lowerCamelCase  ,				slow_tokenizer_class=__lowerCamelCase   )
         AutoTokenizer.register(__lowerCamelCase  ,				fast_tokenizer_class=__lowerCamelCase   )
         # If remote code is not set, the default is to use local
         _SCREAMING_SNAKE_CASE	=				AutoTokenizer.from_pretrained("hf-internal-testing/test_dynamic_tokenizer"   )
         self.assertEqual(tokenizer.__class__.__name__  ,				"NewTokenizerFast"   )
         self.assertFalse(tokenizer.special_attribute_present   )
         _SCREAMING_SNAKE_CASE	=				AutoTokenizer.from_pretrained("hf-internal-testing/test_dynamic_tokenizer"  ,				use_fast=__lowerCamelCase   )
         self.assertEqual(tokenizer.__class__.__name__  ,				"NewTokenizer"   )
         self.assertFalse(tokenizer.special_attribute_present   )

         # If remote code is disabled, we load the local one.
         _SCREAMING_SNAKE_CASE	=				AutoTokenizer.from_pretrained(
             "hf-internal-testing/test_dynamic_tokenizer"  ,				trust_remote_code=__lowerCamelCase   )
         self.assertEqual(tokenizer.__class__.__name__  ,				"NewTokenizerFast"   )
         self.assertFalse(tokenizer.special_attribute_present   )
         _SCREAMING_SNAKE_CASE	=				AutoTokenizer.from_pretrained(
             "hf-internal-testing/test_dynamic_tokenizer"  ,				trust_remote_code=__lowerCamelCase  ,				use_fast=__lowerCamelCase   )
         self.assertEqual(tokenizer.__class__.__name__  ,				"NewTokenizer"   )
         self.assertFalse(tokenizer.special_attribute_present   )

         # If remote is enabled, we load from the Hub
         _SCREAMING_SNAKE_CASE	=				AutoTokenizer.from_pretrained(
             "hf-internal-testing/test_dynamic_tokenizer"  ,				trust_remote_code=__lowerCamelCase   )
         self.assertEqual(tokenizer.__class__.__name__  ,				"NewTokenizerFast"   )
         self.assertTrue(tokenizer.special_attribute_present   )
         _SCREAMING_SNAKE_CASE	=				AutoTokenizer.from_pretrained(
             "hf-internal-testing/test_dynamic_tokenizer"  ,				trust_remote_code=__lowerCamelCase  ,				use_fast=__lowerCamelCase   )
         self.assertEqual(tokenizer.__class__.__name__  ,				"NewTokenizer"   )
         self.assertTrue(tokenizer.special_attribute_present   )

      finally:
         if "custom" in CONFIG_MAPPING._extra_content:
            del CONFIG_MAPPING._extra_content["custom"]
         if CustomConfig in TOKENIZER_MAPPING._extra_content:
            del TOKENIZER_MAPPING._extra_content[CustomConfig]



   def 							lowerCAmelCase_      (   self :     Optional[int]   ):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE	=				AutoTokenizer.from_pretrained(
          "hf-internal-testing/test_dynamic_tokenizer_legacy"  ,				trust_remote_code=__lowerCamelCase   )
      self.assertTrue(tokenizer.special_attribute_present   )
      if is_tokenizers_available():
         self.assertEqual(tokenizer.__class__.__name__  ,				"NewTokenizerFast"   )

         # Test we can also load the slow version
         _SCREAMING_SNAKE_CASE	=				AutoTokenizer.from_pretrained(
             "hf-internal-testing/test_dynamic_tokenizer_legacy"  ,				trust_remote_code=__lowerCamelCase  ,				use_fast=__lowerCamelCase   )
         self.assertTrue(tokenizer.special_attribute_present   )
         self.assertEqual(tokenizer.__class__.__name__  ,				"NewTokenizer"   )
      else:
         self.assertEqual(tokenizer.__class__.__name__  ,				"NewTokenizer"   )



   def 							lowerCAmelCase_      (   self :     str   ):

      """simple docstring"""
      with self.assertRaisesRegex(
          __lowerCamelCase  ,				"bert-base is not a local folder and is not a valid model identifier"   ):
         _SCREAMING_SNAKE_CASE	=				AutoTokenizer.from_pretrained("bert-base"   )



   def 							lowerCAmelCase_      (   self :     Tuple   ):

      """simple docstring"""
      with self.assertRaisesRegex(
          __lowerCamelCase  ,				r"aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)"   ):
         _SCREAMING_SNAKE_CASE	=				AutoTokenizer.from_pretrained(__lowerCamelCase  ,				revision="aaaaaa"   )



   def 							lowerCAmelCase_      (   self :     int   ):

      """simple docstring"""
      # Make sure we have cached the tokenizer.
      _SCREAMING_SNAKE_CASE	=				AutoTokenizer.from_pretrained("hf-internal-testing/tiny-random-bert"   )
      with RequestCounter() as counter:
         _SCREAMING_SNAKE_CASE	=				AutoTokenizer.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   )







'''simple docstring'''



from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_tokenizers_available,
    is_torch_available,
    is_vision_available,
)


lowerCamelCase_			=						{
    'configuration_layoutlmv2': ['LAYOUTLMV2_PRETRAINED_CONFIG_ARCHIVE_MAP', 'LayoutLMv2Config'],
    'processing_layoutlmv2': ['LayoutLMv2Processor'],
    'tokenization_layoutlmv2': ['LayoutLMv2Tokenizer'],
}

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

try:
 if not is_vision_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 lowerCamelCase_			=						['LayoutLMv2FeatureExtractor']
 lowerCamelCase_			=						['LayoutLMv2ImageProcessor']

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 lowerCamelCase_			=						[
     'LAYOUTLMV2_PRETRAINED_MODEL_ARCHIVE_LIST',
     'LayoutLMv2ForQuestionAnswering',
     'LayoutLMv2ForSequenceClassification',
     'LayoutLMv2ForTokenClassification',
     'LayoutLMv2Layer',
     'LayoutLMv2Model',
     'LayoutLMv2PreTrainedModel',
 ]

if TYPE_CHECKING:
 from .configuration_layoutlmva import LAYOUTLMV2_PRETRAINED_CONFIG_ARCHIVE_MAP, LayoutLMvaConfig
 from .processing_layoutlmva import LayoutLMvaProcessor
 from .tokenization_layoutlmva import LayoutLMvaTokenizer

 try:
  if not is_tokenizers_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .tokenization_layoutlmva_fast import LayoutLMvaTokenizerFast

 try:
  if not is_vision_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .feature_extraction_layoutlmva import LayoutLMvaFeatureExtractor, LayoutLMvaImageProcessor

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_layoutlmva import (
      LAYOUTLMV2_PRETRAINED_MODEL_ARCHIVE_LIST,
      LayoutLMvaForQuestionAnswering,
      LayoutLMvaForSequenceClassification,
      LayoutLMvaForTokenClassification,
      LayoutLMvaLayer,
      LayoutLMvaModel,
      LayoutLMvaPreTrainedModel,
  )
else:
 import sys

 lowerCamelCase_			=						_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)

