

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







       def       snake_case (				self      :			Union[str, Any]   ):







            """simple docstring"""







            __lowercase      		=0







       @slow
       def       snake_case (				self      :			Tuple   ):







            """simple docstring"""







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

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







       def       snake_case (				self      :			Any   ):







            """simple docstring"""







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







       def       snake_case (				self      :			Dict   ):







            """simple docstring"""







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







       def       snake_case (				self      :			Optional[Any]   ):







            """simple docstring"""







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







       def       snake_case (				self      :			Dict   ):







            """simple docstring"""







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

                 __lowercase      		=AutoTokenizer.from_pretrained(__lowercase    ,   tokenizer_type='bert'    ,   use_fast=__lowercase   )
                 self.assertIsInstance(__lowercase    ,   __lowercase   )

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

                 __lowercase      		=AutoTokenizer.from_pretrained(__lowercase    ,   tokenizer_type='gpt2'    ,   use_fast=__lowercase   )
                 self.assertIsInstance(__lowercase    ,   __lowercase   )







       @require_tokenizers
       def       snake_case (				self      :			Optional[Any]   ):







            """simple docstring"""







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

                 __lowercase      		=AutoTokenizer.from_pretrained(__lowercase    ,   tokenizer_type='bert'   )
                 self.assertIsInstance(__lowercase    ,   __lowercase   )

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

                 __lowercase      		=AutoTokenizer.from_pretrained(__lowercase    ,   tokenizer_type='gpt2'   )
                 self.assertIsInstance(__lowercase    ,   __lowercase   )







       def       snake_case (				self      :			List[str]   ):







            """simple docstring"""







            with pytest.raises(__lowercase   ):
                 AutoTokenizer.from_pretrained('./'    ,   tokenizer_type='xxx'   )







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







            """simple docstring"""







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

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

                 self.assertEqual(tokenizer.model_max_length    ,   512   )







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







            """simple docstring"""







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







       def       snake_case (				self      :			Tuple   ):







            """simple docstring"""







            __lowercase      		=TOKENIZER_MAPPING.values()
            __lowercase      		=[]

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







       @require_tokenizers
       def       snake_case (				self      :			Optional[int]   ):







            """simple docstring"""







            self.assertIsInstance(AutoTokenizer.from_pretrained('bert-base-cased'    ,   use_fast=__lowercase   )    ,   __lowercase   )
            self.assertIsInstance(AutoTokenizer.from_pretrained('bert-base-cased'   )    ,   __lowercase   )







       @require_tokenizers
       def       snake_case (				self      :			str   ):







            """simple docstring"""







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

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







       @require_tokenizers
       def       snake_case (				self      :			Optional[Any]   ):







            """simple docstring"""







            __lowercase      		=AutoTokenizer.from_pretrained('robot-test/dummy-tokenizer-fast-with-model-config'   )
            self.assertEqual(type(__lowercase   )    ,   __lowercase   )
            self.assertEqual(tokenizer.model_max_length    ,   512   )
            self.assertEqual(tokenizer.vocab_size    ,   30000   )
            self.assertEqual(tokenizer.unk_token    ,   '[UNK]'   )
            self.assertEqual(tokenizer.padding_side    ,   'right'   )
            self.assertEqual(tokenizer.truncation_side    ,   'right'   )







       def       snake_case (				self      :			int   ):







            """simple docstring"""







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

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







       def       snake_case (				self      :			str   ):







            """simple docstring"""







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







       def       snake_case (				self      :			int   ):







            """simple docstring"""







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

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

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

            # 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      :			Tuple   ):







            """simple docstring"""







            try:
                 AutoConfig.register('custom'    ,   __lowercase   )

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

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

                      __lowercase      		=AutoTokenizer.from_pretrained(__lowercase   )
                      self.assertIsInstance(__lowercase    ,   __lowercase   )

            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      :			List[Any]   ):







            """simple docstring"""







            try:
                 AutoConfig.register('custom'    ,   __lowercase   )

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

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

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

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

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

                      __lowercase      		=AutoTokenizer.from_pretrained(__lowercase   )
                      self.assertIsInstance(__lowercase    ,   __lowercase   )

                      __lowercase      		=AutoTokenizer.from_pretrained(__lowercase    ,   use_fast=__lowercase   )
                      self.assertIsInstance(__lowercase    ,   __lowercase   )

            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      :			Optional[int]   ):







            """simple docstring"""







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

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







            """simple docstring"""







            class 	lowerCAmelCase  (   A ):
                   lowerCAmelCase_												=			False






            class 	lowerCAmelCase  (   A ):
                   lowerCAmelCase_												=			NewTokenizer
                   lowerCAmelCase_												=			False

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

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

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







            """simple docstring"""







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

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







       def       snake_case (				self      :			Optional[int]   ):







            """simple docstring"""







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







       def       snake_case (				self      :			Union[str, Any]   ):







            """simple docstring"""







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







       def       snake_case (				self      :			Optional[int]   ):







            """simple docstring"""







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

import os
from collections.abc import Iterator

def 					__UpperCamelCase				(						lowercase__    :	str = "."			):






     '''simple docstring'''





     for dir_path, dir_names, filenames in os.walk(lowercase__			):
          __lowercase      		=[d for d in dir_names if d != 'scripts' and d[0] not in '._']
          for filename in filenames:
               if filename == "__init__.py":
                    continue
               if os.path.splitext(lowercase__			)[1] in (".py", ".ipynb"):
                    yield os.path.join(lowercase__,       lowercase__			).lstrip('./'			)

def 					__UpperCamelCase				(						lowercase__    :	Optional[Any]			):






     '''simple docstring'''





     return F'''{i * "  "}*''' if i else "\n##"

def 					__UpperCamelCase				(						lowercase__    :	str,       lowercase__    :	str			):






     '''simple docstring'''





     __lowercase      		=old_path.split(os.sep			)
     for i, new_part in enumerate(new_path.split(os.sep			)			):
          if (i + 1 > len(lowercase__			) or old_parts[i] != new_part) and new_part:
               print(F'''{md_prefix(lowercase__			)} {new_part.replace("_",       " "			).title()}'''			)
     return new_path

def 					__UpperCamelCase				(						lowercase__    :	str = "."			):






     '''simple docstring'''





     __lowercase      		=''
     for filepath in sorted(good_file_paths(lowercase__			)			):
          __lowercase		,  __lowercase      		=os.path.split(lowercase__			)
          if filepath != old_path:
               __lowercase      		=print_path(lowercase__,       lowercase__			)
          __lowercase      		=(filepath.count(os.sep			) + 1) if filepath else 0
          __lowercase      		=F'''{filepath}/{filename}'''.replace(' ',       '%20'			)
          __lowercase      		=os.path.splitext(filename.replace('_',       ' '			).title()			)[0]
          print(F'''{md_prefix(lowercase__			)} [{filename}]({url})'''			)


if __name__ == "__main__":
       print_directory_md('''.''')


