





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

										"""simple docstring"""




										__SCREAMING_SNAKE_CASE:				Optional[int]           =   0






				@slow
				def 			snake_case_    (  self					):

										"""simple docstring"""




										for model_name in (x for x in BERT_PRETRAINED_CONFIG_ARCHIVE_MAP.keys() if "japanese" not in x):
																__SCREAMING_SNAKE_CASE:				str           =   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:				Tuple           =   AutoTokenizer.from_pretrained(_lowerCAmelCase					)
																self.assertIsNotNone(_lowerCAmelCase					)
																self.assertIsInstance(_lowerCAmelCase			, (GPTaTokenizer, GPTaTokenizerFast)					)
																self.assertGreater(len(_lowerCAmelCase					)			, 0					)






				def 			snake_case_    (  self					):

										"""simple docstring"""




										__SCREAMING_SNAKE_CASE:				Dict           =   AutoTokenizer.from_pretrained(_lowerCAmelCase					)
										self.assertIsInstance(_lowerCAmelCase			, (BertTokenizer, BertTokenizerFast)					)
										self.assertEqual(tokenizer.vocab_size			, 12					)






				def 			snake_case_    (  self					):

										"""simple docstring"""




										__SCREAMING_SNAKE_CASE:				List[Any]           =   AutoTokenizer.from_pretrained(_lowerCAmelCase					)
										self.assertIsInstance(_lowerCAmelCase			, (RobertaTokenizer, RobertaTokenizerFast)					)
										self.assertEqual(tokenizer.vocab_size			, 20					)






				def 			snake_case_    (  self					):

										"""simple docstring"""




										__SCREAMING_SNAKE_CASE:				Tuple           =   AutoConfig.from_pretrained(_lowerCAmelCase					)
										self.assertIsInstance(_lowerCAmelCase			, _lowerCAmelCase					)
										# Check that tokenizer_type ≠ model_type
										__SCREAMING_SNAKE_CASE:				Dict           =   AutoTokenizer.from_pretrained(_lowerCAmelCase			, config=_lowerCAmelCase					)
										self.assertIsInstance(_lowerCAmelCase			, (BertTokenizer, BertTokenizerFast)					)
										self.assertEqual(tokenizer.vocab_size			, 12					)






				def 			snake_case_    (  self					):

										"""simple docstring"""




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

																__SCREAMING_SNAKE_CASE:				str           =   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:				int           =   AutoTokenizer.from_pretrained(_lowerCAmelCase			, tokenizer_type='''gpt2'''			, use_fast=_lowerCAmelCase					)
																self.assertIsInstance(_lowerCAmelCase			, _lowerCAmelCase					)






				@require_tokenizers
				def 			snake_case_    (  self					):

										"""simple docstring"""




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

																__SCREAMING_SNAKE_CASE:				Tuple           =   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:				Dict           =   AutoTokenizer.from_pretrained(_lowerCAmelCase			, tokenizer_type='''gpt2'''					)
																self.assertIsInstance(_lowerCAmelCase			, _lowerCAmelCase					)






				def 			snake_case_    (  self					):

										"""simple docstring"""




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






				@require_tokenizers
				def 			snake_case_    (  self					):

										"""simple docstring"""




										for tokenizer_class in [BertTokenizer, BertTokenizerFast, AutoTokenizer]:
																__SCREAMING_SNAKE_CASE:				Optional[int]           =   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			, 512					)






				@require_tokenizers
				def 			snake_case_    (  self					):

										"""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:				List[str]           =   tokenizer_class.from_pretrained('''julien-c/herlolip-not-exists'''					)






				def 			snake_case_    (  self					):

										"""simple docstring"""




										__SCREAMING_SNAKE_CASE:				Any           =   TOKENIZER_MAPPING.values()
										__SCREAMING_SNAKE_CASE:				int           =   []

										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 			snake_case_    (  self					):

										"""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 			snake_case_    (  self					):

										"""simple docstring"""




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

										__SCREAMING_SNAKE_CASE:				Optional[Any]           =   AutoTokenizer.from_pretrained('''microsoft/mpnet-base'''			, do_lower_case=_lowerCAmelCase					)
										__SCREAMING_SNAKE_CASE:				List[str]           =   tokenizer.tokenize(_lowerCAmelCase					)
										self.assertEqual('''[UNK]'''			, tokens[0]					)






				@require_tokenizers
				def 			snake_case_    (  self					):

										"""simple docstring"""




										__SCREAMING_SNAKE_CASE:				List[Any]           =   AutoTokenizer.from_pretrained('''robot-test/dummy-tokenizer-fast-with-model-config'''					)
										self.assertEqual(type(_lowerCAmelCase					)			, _lowerCAmelCase					)
										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					):

										"""simple docstring"""




										__SCREAMING_SNAKE_CASE:				Any           =   AutoTokenizer.from_pretrained(_lowerCAmelCase					)
										self.assertIsInstance(_lowerCAmelCase			, (BertTokenizer, BertTokenizerFast)					)
										with tempfile.TemporaryDirectory() as tmp_dir:
																tokenizer.save_pretrained(_lowerCAmelCase					)
																__SCREAMING_SNAKE_CASE:				Dict           =   AutoTokenizer.from_pretrained(_lowerCAmelCase					)

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






				def 			snake_case_    (  self					):

										"""simple docstring"""




										__SCREAMING_SNAKE_CASE:				List[str]           =   AutoTokenizer.from_pretrained('''ctrl'''					)
										# There is no fast CTRL so this always gives us a slow tokenizer.
										self.assertIsInstance(_lowerCAmelCase			, _lowerCAmelCase					)






				def 			snake_case_    (  self					):

										"""simple docstring"""




										__SCREAMING_SNAKE_CASE:				int           =   get_tokenizer_config('''bert-base-cased'''					)
										__SCREAMING_SNAKE_CASE:				int           =   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:				int           =   get_tokenizer_config(_lowerCAmelCase					)
										self.assertDictEqual(_lowerCAmelCase			, {}					)

										# A tokenizer saved with `save_pretrained` always creates a tokenizer config.
										__SCREAMING_SNAKE_CASE:				List[str]           =   AutoTokenizer.from_pretrained(_lowerCAmelCase					)
										with tempfile.TemporaryDirectory() as tmp_dir:
																tokenizer.save_pretrained(_lowerCAmelCase					)
																__SCREAMING_SNAKE_CASE:				List[str]           =   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 			snake_case_    (  self					):

										"""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:				List[str]           =   CustomTokenizer.from_pretrained(_lowerCAmelCase					)
																with tempfile.TemporaryDirectory() as tmp_dir:
																						tokenizer.save_pretrained(_lowerCAmelCase					)

																						__SCREAMING_SNAKE_CASE:				Dict           =   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 			snake_case_    (  self					):

										"""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:				Any           =   BertTokenizerFast.from_pretrained(_lowerCAmelCase					)
																						bert_tokenizer.save_pretrained(_lowerCAmelCase					)
																						__SCREAMING_SNAKE_CASE:				Dict           =   CustomTokenizerFast.from_pretrained(_lowerCAmelCase					)

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

																						__SCREAMING_SNAKE_CASE:				Union[str, Any]           =   AutoTokenizer.from_pretrained(_lowerCAmelCase					)
																						self.assertIsInstance(_lowerCAmelCase			, _lowerCAmelCase					)

																						__SCREAMING_SNAKE_CASE:				int           =   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 			snake_case_    (  self					):

										"""simple docstring"""




										with self.assertRaises(_lowerCAmelCase					):
																__SCREAMING_SNAKE_CASE:				Optional[Any]           =   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:				int           =   AutoTokenizer.from_pretrained(
																    '''hf-internal-testing/test_dynamic_tokenizer'''			, trust_remote_code=_lowerCAmelCase					)

										__SCREAMING_SNAKE_CASE:				int           =   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:				Tuple           =   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:				Dict           =   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:				List[Any]           =   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 			snake_case_    (  self					):

										"""simple docstring"""




										class 				a			(      __lowercase			):
														SCREAMING_SNAKE_CASE__     :   str		      =     False





										class 				a			(      __lowercase			):
														SCREAMING_SNAKE_CASE__     :   int		      =     NewTokenizer
														SCREAMING_SNAKE_CASE__     :   Tuple		      =     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:				Union[str, Any]           =   AutoTokenizer.from_pretrained('''hf-internal-testing/test_dynamic_tokenizer'''					)
																self.assertEqual(tokenizer.__class__.__name__			, '''NewTokenizerFast'''					)
																self.assertFalse(tokenizer.special_attribute_present					)
																__SCREAMING_SNAKE_CASE:				List[str]           =   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:				Tuple           =   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:				Optional[Any]           =   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:				Any           =   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:				Dict           =   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 			snake_case_    (  self					):

										"""simple docstring"""




										__SCREAMING_SNAKE_CASE:				int           =   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:				Optional[int]           =   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 			snake_case_    (  self					):

										"""simple docstring"""




										with self.assertRaisesRegex(
										    _lowerCAmelCase			, '''bert-base is not a local folder and is not a valid model identifier'''					):
																__SCREAMING_SNAKE_CASE:				List[Any]           =   AutoTokenizer.from_pretrained('''bert-base'''					)






				def 			snake_case_    (  self					):

										"""simple docstring"""




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






				def 			snake_case_    (  self					):

										"""simple docstring"""




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










def 		lowerCAmelCase  (	UpperCamelCase__   :   List[Any]       ,			UpperCamelCase__   :   Dict					)      ->    List[Any]:

						"""simple docstring"""





						__SCREAMING_SNAKE_CASE:				int           =   [0 for i in range(r + 1					)]
						# nc0 = 1
						__SCREAMING_SNAKE_CASE:				Dict           =   1
						for i in range(1       ,			n + 1					):
												# to compute current row from previous row.
												__SCREAMING_SNAKE_CASE:				Optional[Any]           =   min(UpperCamelCase__       ,			UpperCamelCase__					)
												while j > 0:
																		c[j] += c[j - 1]
																		j -= 1
						return c[r]




print(binomial_coefficient(n=10, r=5))



