




'''simple docstring'''







_lowerCamelCase				:		Dict				      =    '\n# Transformers installation\n! pip install transformers datasets\n# To install from source instead of the last release, comment the command above and uncomment the following one.\n# ! pip install git+https://github.com/huggingface/transformers.git\n'

_lowerCamelCase				:		Union[str, Any]				      =    [{'type': 'code', 'content': INSTALL_CONTENT}]
_lowerCamelCase				:		int				      =    {
    '{processor_class}': 'FakeProcessorClass',
    '{model_class}': 'FakeModelClass',
    '{object_class}': 'FakeObjectClass',
}











'''simple docstring'''







import concurrent.futures
import json
import os
import shutil
import tempfile
import unittest

from transformers import AutoTokenizer, PreTrainedTokenizerFast
from transformers.testing_utils import require_tokenizers

from ..test_tokenization_common import TokenizerTesterMixin





@require_tokenizers
class 	lowerCamelCase_				(			UpperCAmelCase_,			unittest.TestCase				):




					'''simple docstring'''






					lowercase__       =					PreTrainedTokenizerFast
					lowercase__       =					False
					lowercase__       =					True
					lowercase__       =					"""tokenizer_file"""






					def 							__SCREAMING_SNAKE_CASE      (       self					):
							_snake_case      			=			False  # because we don't have pretrained_vocab_files_map
							super().setUp()
							_snake_case      			=			True

							_snake_case      			=			["robot-test/dummy-tokenizer-fast", "robot-test/dummy-tokenizer-wordlevel"]
							_snake_case      			=			"SaulLu/dummy-tokenizer-bytelevel-bpe"

							# Inclusion of 2 tokenizers to test different types of models (Unigram and WordLevel for the moment)
							_snake_case      			=			[(PreTrainedTokenizerFast, model_path, {}) for model_path in model_paths]

							_snake_case      			=			PreTrainedTokenizerFast.from_pretrained(model_paths[0]					)
							tokenizer.save_pretrained(self.tmpdirname					)






					def 							__SCREAMING_SNAKE_CASE      (       self					):
							# We disable this test for PreTrainedTokenizerFast because it is the only tokenizer that is not linked to any
							# model
							pass






					def 							__SCREAMING_SNAKE_CASE      (       self					):
							# We disable this test for PreTrainedTokenizerFast because it is the only tokenizer that is not linked to any
							# model
							pass






					def 							__SCREAMING_SNAKE_CASE      (       self					):
							# We disable this test for PreTrainedTokenizerFast because it is the only tokenizer that is not linked to any
							# model
							pass






					def 							__SCREAMING_SNAKE_CASE      (       self					):
							# PreTrainedTokenizerFast doesn't have tokenizer_file in its signature
							pass






					def 							__SCREAMING_SNAKE_CASE      (       self					):
							_snake_case      			=			self.tmpdirname
							# Here we want to test the 2 available tokenizers that use 2 different types of models: Unigram and WordLevel.
							for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
									with self.subTest(f'''{tokenizer.__class__.__name__} ({pretrained_name})'''					):
											try:
													_snake_case      			=			tempfile.mkdtemp()
													_snake_case      			=			self.rust_tokenizer_class.from_pretrained(__UpperCamelCase,    **__UpperCamelCase					)

													tokenizer.save_pretrained(self.tmpdirname					)
													super().test_training_new_tokenizer()
											finally:
													# Even if the test fails, we must be sure that the folder is deleted and that the default tokenizer
													# is restored
													shutil.rmtree(self.tmpdirname					)
													_snake_case      			=			tmpdirname_orig






					def 							__SCREAMING_SNAKE_CASE      (       self					):
							_snake_case      			=			self.tmpdirname
							# Here we want to test the 2 available tokenizers that use 2 different types of models: Unigram and WordLevel.
							for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
									with self.subTest(f'''{tokenizer.__class__.__name__} ({pretrained_name})'''					):
											try:
													_snake_case      			=			tempfile.mkdtemp()
													_snake_case      			=			self.rust_tokenizer_class.from_pretrained(__UpperCamelCase,    **__UpperCamelCase					)

													tokenizer.save_pretrained(self.tmpdirname					)
													super().test_training_new_tokenizer_with_special_tokens_change()
											finally:
													# Even if the test fails, we must be sure that the folder is deleted and that the default tokenizer
													# is restored
													shutil.rmtree(self.tmpdirname					)
													_snake_case      			=			tmpdirname_orig






					def 							__SCREAMING_SNAKE_CASE      (       self					):
							_snake_case      			=			self.rust_tokenizer_class.from_pretrained(self.bytelevel_bpe_model_name					)

							_snake_case      			=			("a" for _ in range(1_000					))
							_snake_case      			=			tokenizer.train_new_from_iterator(text_iterator=__UpperCamelCase,    length=1_000,    vocab_size=50					)

							_snake_case      			=			new_tokenizer.encode("a🤗"					)
							self.assertEqual(__UpperCamelCase,    [64, 172, 253, 97, 245]					)





@require_tokenizers
class 	lowerCamelCase_				(			unittest.TestCase				):




					'''simple docstring'''






					def 							__SCREAMING_SNAKE_CASE      (       self					):
							_snake_case      			=			AutoTokenizer.from_pretrained("bert-base-cased"					)
							_snake_case      			=			json.loads(tokenizer._tokenizer.to_str()					)
							_snake_case      			=			len(__UpperCamelCase					)

							with tempfile.TemporaryDirectory() as tmp_dir:
									# Hack to save this in the tokenizer_config.json
									_snake_case      			=			["tokenizer.4.0.0.json"]
									tokenizer.save_pretrained(__UpperCamelCase					)
									json.dump(__UpperCamelCase,    open(os.path.join(__UpperCamelCase,    "tokenizer.4.0.0.json"					),    "w"					)					)

									# This should pick the new tokenizer file as the version of Transformers is > 4.0.0
									_snake_case      			=			AutoTokenizer.from_pretrained(__UpperCamelCase					)
									self.assertEqual(len(__UpperCamelCase					),    len(__UpperCamelCase					) + 1					)
									_snake_case      			=			json.loads(new_tokenizer._tokenizer.to_str()					)
									self.assertIn("huggingface",    json_tokenizer["model"]["vocab"]					)

									# Will need to be adjusted if we reach v42 and this test is still here.
									# Should pick the old tokenizer file as the version of Transformers is < 4.0.0
									shutil.move(os.path.join(__UpperCamelCase,    "tokenizer.4.0.0.json"					),    os.path.join(__UpperCamelCase,    "tokenizer.42.0.0.json"					)					)
									_snake_case      			=			["tokenizer.42.0.0.json"]
									tokenizer.save_pretrained(__UpperCamelCase					)
									_snake_case      			=			AutoTokenizer.from_pretrained(__UpperCamelCase					)
									self.assertEqual(len(__UpperCamelCase					),    len(__UpperCamelCase					)					)
									_snake_case      			=			json.loads(new_tokenizer._tokenizer.to_str()					)
									self.assertNotIn("huggingface",    json_tokenizer["model"]["vocab"]					)






					def 							__SCREAMING_SNAKE_CASE      (       self					):
							# This repo has two tokenizer files, one for v4.0.0 and above with an added token, one for versions lower.
							_snake_case      			=			"hf-internal-testing/test-two-tokenizers"

							# This should pick the new tokenizer file as the version of Transformers is > 4.0.0
							_snake_case      			=			AutoTokenizer.from_pretrained(__UpperCamelCase					)
							self.assertEqual(len(__UpperCamelCase					),    28_997					)
							_snake_case      			=			json.loads(tokenizer._tokenizer.to_str()					)
							self.assertIn("huggingface",    json_tokenizer["model"]["vocab"]					)

							# Testing an older version by monkey-patching the version in the module it's used.
							import transformers as old_transformers

							_snake_case      			=			"3.0.0"
							_snake_case      			=			old_transformers.models.auto.AutoTokenizer.from_pretrained(__UpperCamelCase					)
							self.assertEqual(len(__UpperCamelCase					),    28_996					)
							_snake_case      			=			json.loads(old_tokenizer._tokenizer.to_str()					)
							self.assertNotIn("huggingface",    json_tokenizer["model"]["vocab"]					)





@require_tokenizers
class 	lowerCamelCase_				(			unittest.TestCase				):




					'''simple docstring'''






					def 							__SCREAMING_SNAKE_CASE      (       self					):
							# See https://github.com/huggingface/transformers/pull/12550
							# and https://github.com/huggingface/tokenizers/issues/537
							_snake_case      			=			PreTrainedTokenizerFast.from_pretrained("robot-test/dummy-tokenizer-wordlevel"					)
							_snake_case      			=			"The Matrix is a 1999 science fiction action film."

							with concurrent.futures.ThreadPoolExecutor() as executor:
									_snake_case      			=			[executor.submit(self.fetch,    __UpperCamelCase,    __UpperCamelCase					) for i in range(10					)]
									_snake_case      			=			[future.result() for future in futures]
									self.assertEqual(__UpperCamelCase,    [[1, 10, 0, 8, 0, 18, 0, 0, 0, 2] for i in range(10					)]					)






					def 							__SCREAMING_SNAKE_CASE      (       self,    __UpperCamelCase,    __UpperCamelCase					):
							return tokenizer.encode(__UpperCamelCase,    truncation="longest_first",    padding="longest"					)





