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







    def      _snake_case					(			self			:       Optional[Any]     )		->str:






        '''simple docstring'''






        _UpperCAmelCase          =   0







    @slow
    def      _snake_case					(			self			:       int     )		->List[Any]:






        '''simple docstring'''






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

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







    def      _snake_case					(			self			:       Optional[int]     )		->str:






        '''simple docstring'''






        _UpperCAmelCase          =   AutoTokenizer.from_pretrained(__UpperCamelCase     )
        self.assertIsInstance(__UpperCamelCase     ,					(BertTokenizer, BertTokenizerFast)     )
        self.assertEqual(tokenizer.vocab_size     ,					12     )







    def      _snake_case					(			self			:       Dict     )		->Optional[Any]:






        '''simple docstring'''






        _UpperCAmelCase          =   AutoTokenizer.from_pretrained(__UpperCamelCase     )
        self.assertIsInstance(__UpperCamelCase     ,					(RobertaTokenizer, RobertaTokenizerFast)     )
        self.assertEqual(tokenizer.vocab_size     ,					20     )







    def      _snake_case					(			self			:       Any     )		->str:






        '''simple docstring'''






        _UpperCAmelCase          =   AutoConfig.from_pretrained(__UpperCamelCase     )
        self.assertIsInstance(__UpperCamelCase     ,					__UpperCamelCase     )
        # Check that tokenizer_type ≠ model_type
        _UpperCAmelCase          =   AutoTokenizer.from_pretrained(__UpperCamelCase     ,					config=__UpperCamelCase     )
        self.assertIsInstance(__UpperCamelCase     ,					(BertTokenizer, BertTokenizerFast)     )
        self.assertEqual(tokenizer.vocab_size     ,					12     )







    def      _snake_case					(			self			:       Dict     )		->int:






        '''simple docstring'''






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

            _UpperCAmelCase          =   AutoTokenizer.from_pretrained(__UpperCamelCase     ,					tokenizer_type="""bert"""     ,					use_fast=__UpperCamelCase     )
            self.assertIsInstance(__UpperCamelCase     ,					__UpperCamelCase     )

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

            _UpperCAmelCase          =   AutoTokenizer.from_pretrained(__UpperCamelCase     ,					tokenizer_type="""gpt2"""     ,					use_fast=__UpperCamelCase     )
            self.assertIsInstance(__UpperCamelCase     ,					__UpperCamelCase     )







    @require_tokenizers
    def      _snake_case					(			self			:       List[Any]     )		->Union[str, Any]:






        '''simple docstring'''






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

            _UpperCAmelCase          =   AutoTokenizer.from_pretrained(__UpperCamelCase     ,					tokenizer_type="""bert"""     )
            self.assertIsInstance(__UpperCamelCase     ,					__UpperCamelCase     )

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

            _UpperCAmelCase          =   AutoTokenizer.from_pretrained(__UpperCamelCase     ,					tokenizer_type="""gpt2"""     )
            self.assertIsInstance(__UpperCamelCase     ,					__UpperCamelCase     )







    def      _snake_case					(			self			:       int     )		->Optional[Any]:






        '''simple docstring'''






        with pytest.raises(__UpperCamelCase     ):
            AutoTokenizer.from_pretrained("""./"""     ,					tokenizer_type="""xxx"""     )







    @require_tokenizers
    def      _snake_case					(			self			:       str     )		->Optional[Any]:






        '''simple docstring'''






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

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

            self.assertEqual(tokenizer.model_max_length     ,					5_12     )







    @require_tokenizers
    def      _snake_case					(			self			:       str     )		->Dict:






        '''simple docstring'''






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







    def      _snake_case					(			self			:       Union[str, Any]     )		->Union[str, Any]:






        '''simple docstring'''






        _UpperCAmelCase          =   TOKENIZER_MAPPING.values()
        _UpperCAmelCase          =   []

        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(__UpperCamelCase     )







    @require_tokenizers
    def      _snake_case					(			self			:       int     )		->Union[str, Any]:






        '''simple docstring'''






        self.assertIsInstance(AutoTokenizer.from_pretrained("""bert-base-cased"""     ,					use_fast=__UpperCamelCase     )     ,					__UpperCamelCase     )
        self.assertIsInstance(AutoTokenizer.from_pretrained("""bert-base-cased"""     )     ,					__UpperCamelCase     )







    @require_tokenizers
    def      _snake_case					(			self			:       List[Any]     )		->Any:






        '''simple docstring'''






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

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







    @require_tokenizers
    def      _snake_case					(			self			:       List[str]     )		->List[Any]:






        '''simple docstring'''






        _UpperCAmelCase          =   AutoTokenizer.from_pretrained("""robot-test/dummy-tokenizer-fast-with-model-config"""     )
        self.assertEqual(type(__UpperCamelCase     )     ,					__UpperCamelCase     )
        self.assertEqual(tokenizer.model_max_length     ,					5_12     )
        self.assertEqual(tokenizer.vocab_size     ,					3_00_00     )
        self.assertEqual(tokenizer.unk_token     ,					"""[UNK]"""     )
        self.assertEqual(tokenizer.padding_side     ,					"""right"""     )
        self.assertEqual(tokenizer.truncation_side     ,					"""right"""     )







    def      _snake_case					(			self			:       Tuple     )		->Tuple:






        '''simple docstring'''






        _UpperCAmelCase          =   AutoTokenizer.from_pretrained(__UpperCamelCase     )
        self.assertIsInstance(__UpperCamelCase     ,					(BertTokenizer, BertTokenizerFast)     )
        with tempfile.TemporaryDirectory() as tmp_dir:
            tokenizer.save_pretrained(__UpperCamelCase     )
            _UpperCAmelCase          =   AutoTokenizer.from_pretrained(__UpperCamelCase     )

        self.assertIsInstance(__UpperCamelCase     ,					tokenizer.__class__     )
        self.assertEqual(tokenizera.vocab_size     ,					12     )







    def      _snake_case					(			self			:       Any     )		->str:






        '''simple docstring'''






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







    def      _snake_case					(			self			:       Union[str, Any]     )		->Optional[int]:






        '''simple docstring'''






        _UpperCAmelCase          =   get_tokenizer_config("""bert-base-cased"""     )
        _UpperCAmelCase          =   config.pop("""_commit_hash"""     ,					__UpperCamelCase     )
        # If we ever update bert-base-cased tokenizer config, this dict here will need to be updated.
        self.assertEqual(__UpperCamelCase     ,					{"""do_lower_case""": False}     )

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

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

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







    def      _snake_case					(			self			:       str     )		->List[str]:






        '''simple docstring'''






        try:
            AutoConfig.register("""custom"""     ,					__UpperCamelCase     )

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

            _UpperCAmelCase          =   CustomTokenizer.from_pretrained(__UpperCamelCase     )
            with tempfile.TemporaryDirectory() as tmp_dir:
                tokenizer.save_pretrained(__UpperCamelCase     )

                _UpperCAmelCase          =   AutoTokenizer.from_pretrained(__UpperCamelCase     )
                self.assertIsInstance(__UpperCamelCase     ,					__UpperCamelCase     )

        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      _snake_case					(			self			:       Optional[int]     )		->Any:






        '''simple docstring'''






        try:
            AutoConfig.register("""custom"""     ,					__UpperCamelCase     )

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

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

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

            # 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:
                _UpperCAmelCase          =   BertTokenizerFast.from_pretrained(__UpperCamelCase     )
                bert_tokenizer.save_pretrained(__UpperCamelCase     )
                _UpperCAmelCase          =   CustomTokenizerFast.from_pretrained(__UpperCamelCase     )

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

                _UpperCAmelCase          =   AutoTokenizer.from_pretrained(__UpperCamelCase     )
                self.assertIsInstance(__UpperCamelCase     ,					__UpperCamelCase     )

                _UpperCAmelCase          =   AutoTokenizer.from_pretrained(__UpperCamelCase     ,					use_fast=__UpperCamelCase     )
                self.assertIsInstance(__UpperCamelCase     ,					__UpperCamelCase     )

        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      _snake_case					(			self			:       Any     )		->Union[str, Any]:






        '''simple docstring'''






        with self.assertRaises(__UpperCamelCase     ):
            _UpperCAmelCase          =   AutoTokenizer.from_pretrained("""hf-internal-testing/test_dynamic_tokenizer"""     )
        # If remote code is disabled, we can't load this config.
        with self.assertRaises(__UpperCamelCase     ):
            _UpperCAmelCase          =   AutoTokenizer.from_pretrained(
                """hf-internal-testing/test_dynamic_tokenizer"""     ,					trust_remote_code=__UpperCamelCase     )

        _UpperCAmelCase          =   AutoTokenizer.from_pretrained("""hf-internal-testing/test_dynamic_tokenizer"""     ,					trust_remote_code=__UpperCamelCase     )
        self.assertTrue(tokenizer.special_attribute_present     )
        # Test tokenizer can be reloaded.
        with tempfile.TemporaryDirectory() as tmp_dir:
            tokenizer.save_pretrained(__UpperCamelCase     )
            _UpperCAmelCase          =   AutoTokenizer.from_pretrained(__UpperCamelCase     ,					trust_remote_code=__UpperCamelCase     )
        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
            _UpperCAmelCase          =   AutoTokenizer.from_pretrained(
                """hf-internal-testing/test_dynamic_tokenizer"""     ,					trust_remote_code=__UpperCamelCase     ,					use_fast=__UpperCamelCase     )
            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(__UpperCamelCase     )
                _UpperCAmelCase          =   AutoTokenizer.from_pretrained(__UpperCamelCase     ,					trust_remote_code=__UpperCamelCase     ,					use_fast=__UpperCamelCase     )
            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      _snake_case					(			self			:       Dict     )		->List[Any]:






        '''simple docstring'''






        class 		a_						( _UpperCAmelCase	):
            a      :				Tuple     =				False







        class 		a_						( _UpperCAmelCase	):
            a      :				str     =				NewTokenizer
            a      :				List[Any]     =				False

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

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

            # If remote is enabled, we load from the Hub
            _UpperCAmelCase          =   AutoTokenizer.from_pretrained(
                """hf-internal-testing/test_dynamic_tokenizer"""     ,					trust_remote_code=__UpperCamelCase     )
            self.assertEqual(tokenizer.__class__.__name__     ,					"""NewTokenizerFast"""     )
            self.assertTrue(tokenizer.special_attribute_present     )
            _UpperCAmelCase          =   AutoTokenizer.from_pretrained(
                """hf-internal-testing/test_dynamic_tokenizer"""     ,					trust_remote_code=__UpperCamelCase     ,					use_fast=__UpperCamelCase     )
            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      _snake_case					(			self			:       List[Any]     )		->List[Any]:






        '''simple docstring'''






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

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







    def      _snake_case					(			self			:       Union[str, Any]     )		->str:






        '''simple docstring'''






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







    def      _snake_case					(			self			:       Dict     )		->Tuple:






        '''simple docstring'''






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







    def      _snake_case					(			self			:       int     )		->Dict:






        '''simple docstring'''






        _UpperCAmelCase          =   AutoTokenizer.from_pretrained("""hf-internal-testing/tiny-random-bert"""     )
        with RequestCounter() as counter:
            _UpperCAmelCase          =   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_torch_available


a					:	Tuple							=		{
    '''configuration_pegasus_x''': ['''PEGASUS_X_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''PegasusXConfig'''],
}

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 a					:	List[str]							=		[
     '''PEGASUS_X_PRETRAINED_MODEL_ARCHIVE_LIST''',
     '''PegasusXForConditionalGeneration''',
     '''PegasusXModel''',
     '''PegasusXPreTrainedModel''',
 ]


if TYPE_CHECKING:
 from .configuration_pegasus_x import PEGASUS_X_PRETRAINED_CONFIG_ARCHIVE_MAP, PegasusXConfig

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_pegasus_x import (
      PEGASUS_X_PRETRAINED_MODEL_ARCHIVE_LIST,
      PegasusXForConditionalGeneration,
      PegasusXModel,
      PegasusXPreTrainedModel,
  )


else:
 import sys

 a					:	Dict							=		_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)