



import argparse
import json
import logging
import os
import shutil
import sys
import tempfile
import unittest
from unittest import mock

import torch
from accelerate.utils import write_basic_config

from transformers.testing_utils import TestCasePlus, get_gpu_count, run_command, slow, torch_device
from transformers.utils import is_apex_available


logging.basicConfig(level=logging.DEBUG)

__snake_case     :int			       =logging.getLogger()






def  lowerCamelCase_	(      )       ->							Dict:

							'''simple docstring'''






							A      						=    argparse.ArgumentParser()
							parser.add_argument('-f'				)
							A      						=    parser.parse_args()
							return args.f






def  lowerCamelCase_	(      lowerCAmelCase__	:	Optional[int]				)       ->							Dict:

							'''simple docstring'''






							A      						=    {}
							A      						=    os.path.join(lowerCAmelCase__			,	'all_results.json'				)
							if os.path.exists(lowerCAmelCase__				):
														with open(lowerCAmelCase__			,	'r'				) as f:
																					A      						=    json.load(lowerCAmelCase__				)
							else:
														raise ValueError(F'''can\'t find {path}'''				)
							return results






def  lowerCamelCase_	(      )       ->							Dict:

							'''simple docstring'''






							A      						=    torch.cuda.is_available() and torch_device == 'cuda'
							return is_using_cuda and is_apex_available()


__snake_case     :Tuple			       =logging.StreamHandler(sys.stdout)
logger.addHandler(stream_handler)



class        lowerCAmelCase__					(  _lowerCamelCase       ):


				@classmethod
				def __UpperCamelCase						(							cls      :  Optional[Any]       )		->     Optional[Any]:
											# Write Accelerate config, will pick up on CPU, GPU, and multi-GPU
											A      						=    tempfile.mkdtemp()
											A      						=    os.path.join(cls.tmpdir						, 'default_config.yml'       )
											write_basic_config(save_location=cls.configPath       )
											A      						=    ['accelerate', 'launch', '--config_file', cls.configPath]


				@classmethod
				def __UpperCamelCase						(							cls      :  Union[str, Any]       )		->     Optional[int]:
											shutil.rmtree(cls.tmpdir       )


				@mock.patch.dict(os.environ						, {'WANDB_MODE': 'offline'}       )
				def __UpperCamelCase						(							self      :  Tuple       )		->     List[str]:
											A      						=    self.get_auto_remove_tmp_dir()
											A      						=    f'''
            {self.examples_dir}/pytorch/text-classification/run_glue_no_trainer.py
            --model_name_or_path distilbert-base-uncased
            --output_dir {tmp_dir}
            --train_file ./tests/fixtures/tests_samples/MRPC/train.csv
            --validation_file ./tests/fixtures/tests_samples/MRPC/dev.csv
            --per_device_train_batch_size=2
            --per_device_eval_batch_size=1
            --learning_rate=1e-4
            --seed=42
            --checkpointing_steps epoch
            --with_tracking
        '''.split()

											if is_cuda_and_apex_available():
																		testargs.append('--fp16'       )

											run_command(self._launch_args + testargs       )
											A      						=    get_results(__UpperCamelCase       )
											self.assertGreaterEqual(result['eval_accuracy']						, 0.7_5       )
											self.assertTrue(os.path.exists(os.path.join(__UpperCamelCase						, 'epoch_0'       )       )       )
											self.assertTrue(os.path.exists(os.path.join(__UpperCamelCase						, 'glue_no_trainer'       )       )       )


				@mock.patch.dict(os.environ						, {'WANDB_MODE': 'offline'}       )
				def __UpperCamelCase						(							self      :  Union[str, Any]       )		->     str:
											A      						=    self.get_auto_remove_tmp_dir()
											A      						=    f'''
            {self.examples_dir}/pytorch/language-modeling/run_clm_no_trainer.py
            --model_name_or_path distilgpt2
            --train_file ./tests/fixtures/sample_text.txt
            --validation_file ./tests/fixtures/sample_text.txt
            --block_size 128
            --per_device_train_batch_size 5
            --per_device_eval_batch_size 5
            --num_train_epochs 2
            --output_dir {tmp_dir}
            --checkpointing_steps epoch
            --with_tracking
        '''.split()

											if torch.cuda.device_count() > 1:
																		# Skipping because there are not enough batches to train the model + would need a drop_last to work.
																		return

											run_command(self._launch_args + testargs       )
											A      						=    get_results(__UpperCamelCase       )
											self.assertLess(result['perplexity']						, 100       )
											self.assertTrue(os.path.exists(os.path.join(__UpperCamelCase						, 'epoch_0'       )       )       )
											self.assertTrue(os.path.exists(os.path.join(__UpperCamelCase						, 'clm_no_trainer'       )       )       )


				@mock.patch.dict(os.environ						, {'WANDB_MODE': 'offline'}       )
				def __UpperCamelCase						(							self      :  List[str]       )		->     Any:
											A      						=    self.get_auto_remove_tmp_dir()
											A      						=    f'''
            {self.examples_dir}/pytorch/language-modeling/run_mlm_no_trainer.py
            --model_name_or_path distilroberta-base
            --train_file ./tests/fixtures/sample_text.txt
            --validation_file ./tests/fixtures/sample_text.txt
            --output_dir {tmp_dir}
            --num_train_epochs=1
            --checkpointing_steps epoch
            --with_tracking
        '''.split()

											run_command(self._launch_args + testargs       )
											A      						=    get_results(__UpperCamelCase       )
											self.assertLess(result['perplexity']						, 42       )
											self.assertTrue(os.path.exists(os.path.join(__UpperCamelCase						, 'epoch_0'       )       )       )
											self.assertTrue(os.path.exists(os.path.join(__UpperCamelCase						, 'mlm_no_trainer'       )       )       )


				@mock.patch.dict(os.environ						, {'WANDB_MODE': 'offline'}       )
				def __UpperCamelCase						(							self      :  Any       )		->     int:
											# with so little data distributed training needs more epochs to get the score on par with 0/1 gpu
											A      						=    7 if get_gpu_count() > 1 else 2

											A      						=    self.get_auto_remove_tmp_dir()
											A      						=    f'''
            {self.examples_dir}/pytorch/token-classification/run_ner_no_trainer.py
            --model_name_or_path bert-base-uncased
            --train_file tests/fixtures/tests_samples/conll/sample.json
            --validation_file tests/fixtures/tests_samples/conll/sample.json
            --output_dir {tmp_dir}
            --learning_rate=2e-4
            --per_device_train_batch_size=2
            --per_device_eval_batch_size=2
            --num_train_epochs={epochs}
            --seed 7
            --checkpointing_steps epoch
            --with_tracking
        '''.split()

											run_command(self._launch_args + testargs       )
											A      						=    get_results(__UpperCamelCase       )
											self.assertGreaterEqual(result['eval_accuracy']						, 0.7_5       )
											self.assertLess(result['train_loss']						, 0.5       )
											self.assertTrue(os.path.exists(os.path.join(__UpperCamelCase						, 'epoch_0'       )       )       )
											self.assertTrue(os.path.exists(os.path.join(__UpperCamelCase						, 'ner_no_trainer'       )       )       )


				@unittest.skip(reason='Fix me @muellerzr'       )
				@mock.patch.dict(os.environ						, {'WANDB_MODE': 'offline'}       )
				def __UpperCamelCase						(							self      :  str       )		->     List[str]:
											A      						=    self.get_auto_remove_tmp_dir()
											A      						=    f'''
            {self.examples_dir}/pytorch/question-answering/run_qa_no_trainer.py
            --model_name_or_path bert-base-uncased
            --version_2_with_negative
            --train_file tests/fixtures/tests_samples/SQUAD/sample.json
            --validation_file tests/fixtures/tests_samples/SQUAD/sample.json
            --output_dir {tmp_dir}
            --seed=42
            --max_train_steps=10
            --num_warmup_steps=2
            --learning_rate=2e-4
            --per_device_train_batch_size=2
            --per_device_eval_batch_size=1
            --checkpointing_steps epoch
            --with_tracking
        '''.split()

											run_command(self._launch_args + testargs       )
											A      						=    get_results(__UpperCamelCase       )
											# Because we use --version_2_with_negative the testing script uses SQuAD v2 metrics.
											self.assertGreaterEqual(result['eval_f1']						, 28       )
											self.assertGreaterEqual(result['eval_exact']						, 28       )
											self.assertTrue(os.path.exists(os.path.join(__UpperCamelCase						, 'epoch_0'       )       )       )
											self.assertTrue(os.path.exists(os.path.join(__UpperCamelCase						, 'qa_no_trainer'       )       )       )


				@mock.patch.dict(os.environ						, {'WANDB_MODE': 'offline'}       )
				def __UpperCamelCase						(							self      :  Tuple       )		->     str:
											A      						=    self.get_auto_remove_tmp_dir()
											A      						=    f'''
            {self.examples_dir}/pytorch/multiple-choice/run_swag_no_trainer.py
            --model_name_or_path bert-base-uncased
            --train_file tests/fixtures/tests_samples/swag/sample.json
            --validation_file tests/fixtures/tests_samples/swag/sample.json
            --output_dir {tmp_dir}
            --max_train_steps=20
            --num_warmup_steps=2
            --learning_rate=2e-4
            --per_device_train_batch_size=2
            --per_device_eval_batch_size=1
            --with_tracking
        '''.split()

											run_command(self._launch_args + testargs       )
											A      						=    get_results(__UpperCamelCase       )
											self.assertGreaterEqual(result['eval_accuracy']						, 0.8       )
											self.assertTrue(os.path.exists(os.path.join(__UpperCamelCase						, 'swag_no_trainer'       )       )       )


				@slow
				@mock.patch.dict(os.environ						, {'WANDB_MODE': 'offline'}       )
				def __UpperCamelCase						(							self      :  Dict       )		->     Tuple:
											A      						=    self.get_auto_remove_tmp_dir()
											A      						=    f'''
            {self.examples_dir}/pytorch/summarization/run_summarization_no_trainer.py
            --model_name_or_path t5-small
            --train_file tests/fixtures/tests_samples/xsum/sample.json
            --validation_file tests/fixtures/tests_samples/xsum/sample.json
            --output_dir {tmp_dir}
            --max_train_steps=50
            --num_warmup_steps=8
            --learning_rate=2e-4
            --per_device_train_batch_size=2
            --per_device_eval_batch_size=1
            --checkpointing_steps epoch
            --with_tracking
        '''.split()

											run_command(self._launch_args + testargs       )
											A      						=    get_results(__UpperCamelCase       )
											self.assertGreaterEqual(result['eval_rouge1']						, 10       )
											self.assertGreaterEqual(result['eval_rouge2']						, 2       )
											self.assertGreaterEqual(result['eval_rougeL']						, 7       )
											self.assertGreaterEqual(result['eval_rougeLsum']						, 7       )
											self.assertTrue(os.path.exists(os.path.join(__UpperCamelCase						, 'epoch_0'       )       )       )
											self.assertTrue(os.path.exists(os.path.join(__UpperCamelCase						, 'summarization_no_trainer'       )       )       )


				@slow
				@mock.patch.dict(os.environ						, {'WANDB_MODE': 'offline'}       )
				def __UpperCamelCase						(							self      :  Union[str, Any]       )		->     str:
											A      						=    self.get_auto_remove_tmp_dir()
											A      						=    f'''
            {self.examples_dir}/pytorch/translation/run_translation_no_trainer.py
            --model_name_or_path sshleifer/student_marian_en_ro_6_1
            --source_lang en
            --target_lang ro
            --train_file tests/fixtures/tests_samples/wmt16/sample.json
            --validation_file tests/fixtures/tests_samples/wmt16/sample.json
            --output_dir {tmp_dir}
            --max_train_steps=50
            --num_warmup_steps=8
            --num_beams=6
            --learning_rate=3e-3
            --per_device_train_batch_size=2
            --per_device_eval_batch_size=1
            --source_lang en_XX
            --target_lang ro_RO
            --checkpointing_steps epoch
            --with_tracking
        '''.split()

											run_command(self._launch_args + testargs       )
											A      						=    get_results(__UpperCamelCase       )
											self.assertGreaterEqual(result['eval_bleu']						, 30       )
											self.assertTrue(os.path.exists(os.path.join(__UpperCamelCase						, 'epoch_0'       )       )       )
											self.assertTrue(os.path.exists(os.path.join(__UpperCamelCase						, 'translation_no_trainer'       )       )       )


				@slow
				def __UpperCamelCase						(							self      :  Optional[int]       )		->     Optional[int]:
											A      						=    logging.StreamHandler(sys.stdout       )
											logger.addHandler(__UpperCamelCase       )

											A      						=    self.get_auto_remove_tmp_dir()
											A      						=    f'''
            {self.examples_dir}/pytorch/semantic-segmentation/run_semantic_segmentation_no_trainer.py
            --dataset_name huggingface/semantic-segmentation-test-sample
            --output_dir {tmp_dir}
            --max_train_steps=10
            --num_warmup_steps=2
            --learning_rate=2e-4
            --per_device_train_batch_size=2
            --per_device_eval_batch_size=1
            --checkpointing_steps epoch
        '''.split()

											run_command(self._launch_args + testargs       )
											A      						=    get_results(__UpperCamelCase       )
											self.assertGreaterEqual(result['eval_overall_accuracy']						, 0.1_0       )


				@mock.patch.dict(os.environ						, {'WANDB_MODE': 'offline'}       )
				def __UpperCamelCase						(							self      :  Optional[int]       )		->     Optional[int]:
											A      						=    self.get_auto_remove_tmp_dir()
											A      						=    f'''
            {self.examples_dir}/pytorch/image-classification/run_image_classification_no_trainer.py
            --model_name_or_path google/vit-base-patch16-224-in21k
            --dataset_name hf-internal-testing/cats_vs_dogs_sample
            --learning_rate 1e-4
            --per_device_train_batch_size 2
            --per_device_eval_batch_size 1
            --max_train_steps 2
            --train_val_split 0.1
            --seed 42
            --output_dir {tmp_dir}
            --with_tracking
            --checkpointing_steps 1
        '''.split()

											if is_cuda_and_apex_available():
																		testargs.append('--fp16'       )

											run_command(self._launch_args + testargs       )
											A      						=    get_results(__UpperCamelCase       )
											# The base model scores a 25%
											self.assertGreaterEqual(result['eval_accuracy']						, 0.6       )
											self.assertTrue(os.path.exists(os.path.join(__UpperCamelCase						, 'step_1'       )       )       )
											self.assertTrue(os.path.exists(os.path.join(__UpperCamelCase						, 'image_classification_no_trainer'       )       )       )




import os
import sys
import tempfile
import unittest
import unittest.mock as mock
from pathlib import Path

from huggingface_hub import HfFolder, delete_repo
from huggingface_hub.file_download import http_get
from requests.exceptions import HTTPError

from transformers import (
    AlbertTokenizer,
    AutoTokenizer,
    BertTokenizer,
    BertTokenizerFast,
    GPTaTokenizerFast,
    is_tokenizers_available,
)
from transformers.testing_utils import TOKEN, USER, is_staging_test, require_tokenizers
from transformers.tokenization_utils import Trie


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

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 __UpperCamelCase						(							self      :  Any       )		->     Tuple:
											# A mock response for an HTTP head request to emulate server down
											A      						=    mock.Mock()
											A      						=    500
											A      						=    {}
											A      						=    HTTPError
											A      						=    {}

											# Download this model to make sure it's in the cache.
											A      						=    BertTokenizer.from_pretrained('hf-internal-testing/tiny-random-bert'       )

											# Under the mock environment we get a 500 error when trying to reach the tokenizer.
											with mock.patch('requests.Session.request'						, return_value=__UpperCamelCase       ) as mock_head:
																		A      						=    BertTokenizer.from_pretrained('hf-internal-testing/tiny-random-bert'       )
																		# This check we did call the fake head request
																		mock_head.assert_called()


				@require_tokenizers
				def __UpperCamelCase						(							self      :  Union[str, Any]       )		->     Union[str, Any]:
											# A mock response for an HTTP head request to emulate server down
											A      						=    mock.Mock()
											A      						=    500
											A      						=    {}
											A      						=    HTTPError
											A      						=    {}

											# Download this model to make sure it's in the cache.
											A      						=    GPTaTokenizerFast.from_pretrained('gpt2'       )

											# Under the mock environment we get a 500 error when trying to reach the tokenizer.
											with mock.patch('requests.Session.request'						, return_value=__UpperCamelCase       ) as mock_head:
																		A      						=    GPTaTokenizerFast.from_pretrained('gpt2'       )
																		# This check we did call the fake head request
																		mock_head.assert_called()


				def __UpperCamelCase						(							self      :  Optional[Any]       )		->     List[str]:
											# This test is for deprecated behavior and can be removed in v5
											try:
																		A      						=    tempfile.mktemp()
																		with open(__UpperCamelCase						, 'wb'       ) as f:
																									http_get('https://huggingface.co/albert-base-v1/resolve/main/spiece.model'						, __UpperCamelCase       )

																		A      						=    AlbertTokenizer.from_pretrained(__UpperCamelCase       )
											finally:
																		os.remove(__UpperCamelCase       )

											# Supporting this legacy load introduced a weird bug where the tokenizer would load local files if they are in
											# the current folder and have the right name.
											if os.path.isfile('tokenizer.json'       ):
																		# We skip the test if the user has a `tokenizer.json` in this folder to avoid deleting it.
																		return
											try:
																		with open('tokenizer.json'						, 'wb'       ) as f:
																									http_get('https://huggingface.co/hf-internal-testing/tiny-random-bert/blob/main/tokenizer.json'						, __UpperCamelCase       )
																		A      						=    AutoTokenizer.from_pretrained('hf-internal-testing/tiny-random-gpt2'       )
																		# The tiny random BERT has a vocab size of 1024, tiny gpt2 as a vocab size of 1000
																		self.assertEqual(tokenizer.vocab_size						, 1_000       )
																		# Tokenizer should depend on the remote checkpoint, not the local tokenizer.json file.

											finally:
																		os.remove('tokenizer.json'       )


				def __UpperCamelCase						(							self      :  str       )		->     int:
											# This test is for deprecated behavior and can be removed in v5
											A      						=    AlbertTokenizer.from_pretrained('https://huggingface.co/albert-base-v1/resolve/main/spiece.model'       )





@is_staging_test
class        lowerCAmelCase__					(  unittest.TestCase       ):
				A_   :     str								=     ['[UNK]', '[CLS]', '[SEP]', '[PAD]', '[MASK]', 'bla', 'blou']


				@classmethod
				def __UpperCamelCase						(							cls      :  Tuple       )		->     Dict:
											A      						=    TOKEN
											HfFolder.save_token(__UpperCamelCase       )


				@classmethod
				def __UpperCamelCase						(							cls      :  Any       )		->     Dict:
											try:
																		delete_repo(token=cls._token						, repo_id='test-tokenizer'       )
											except HTTPError:
																		pass

											try:
																		delete_repo(token=cls._token						, repo_id='valid_org/test-tokenizer-org'       )
											except HTTPError:
																		pass

											try:
																		delete_repo(token=cls._token						, repo_id='test-dynamic-tokenizer'       )
											except HTTPError:
																		pass


				def __UpperCamelCase						(							self      :  Optional[Any]       )		->     List[str]:
											with tempfile.TemporaryDirectory() as tmp_dir:
																		A      						=    os.path.join(__UpperCamelCase						, 'vocab.txt'       )
																		with open(__UpperCamelCase						, 'w'						, encoding='utf-8'       ) as vocab_writer:
																									vocab_writer.write(''.join([x + '\n' for x in self.vocab_tokens]       )       )
																		A      						=    BertTokenizer(__UpperCamelCase       )

											tokenizer.push_to_hub('test-tokenizer'						, use_auth_token=self._token       )
											A      						=    BertTokenizer.from_pretrained(f'''{USER}/test-tokenizer'''       )
											self.assertDictEqual(new_tokenizer.vocab						, tokenizer.vocab       )

											# Reset repo
											delete_repo(token=self._token						, repo_id='test-tokenizer'       )

											# Push to hub via save_pretrained
											with tempfile.TemporaryDirectory() as tmp_dir:
																		tokenizer.save_pretrained(__UpperCamelCase						, repo_id='test-tokenizer'						, push_to_hub=__UpperCamelCase						, use_auth_token=self._token       )

											A      						=    BertTokenizer.from_pretrained(f'''{USER}/test-tokenizer'''       )
											self.assertDictEqual(new_tokenizer.vocab						, tokenizer.vocab       )


				def __UpperCamelCase						(							self      :  List[str]       )		->     Tuple:
											with tempfile.TemporaryDirectory() as tmp_dir:
																		A      						=    os.path.join(__UpperCamelCase						, 'vocab.txt'       )
																		with open(__UpperCamelCase						, 'w'						, encoding='utf-8'       ) as vocab_writer:
																									vocab_writer.write(''.join([x + '\n' for x in self.vocab_tokens]       )       )
																		A      						=    BertTokenizer(__UpperCamelCase       )

											tokenizer.push_to_hub('valid_org/test-tokenizer-org'						, use_auth_token=self._token       )
											A      						=    BertTokenizer.from_pretrained('valid_org/test-tokenizer-org'       )
											self.assertDictEqual(new_tokenizer.vocab						, tokenizer.vocab       )

											# Reset repo
											delete_repo(token=self._token						, repo_id='valid_org/test-tokenizer-org'       )

											# Push to hub via save_pretrained
											with tempfile.TemporaryDirectory() as tmp_dir:
																		tokenizer.save_pretrained(
																		    __UpperCamelCase						, repo_id='valid_org/test-tokenizer-org'						, push_to_hub=__UpperCamelCase						, use_auth_token=self._token       )

											A      						=    BertTokenizer.from_pretrained('valid_org/test-tokenizer-org'       )
											self.assertDictEqual(new_tokenizer.vocab						, tokenizer.vocab       )


				@require_tokenizers
				def __UpperCamelCase						(							self      :  Any       )		->     Union[str, Any]:
											CustomTokenizer.register_for_auto_class()
											with tempfile.TemporaryDirectory() as tmp_dir:
																		A      						=    os.path.join(__UpperCamelCase						, 'vocab.txt'       )
																		with open(__UpperCamelCase						, 'w'						, encoding='utf-8'       ) as vocab_writer:
																									vocab_writer.write(''.join([x + '\n' for x in self.vocab_tokens]       )       )
																		A      						=    CustomTokenizer(__UpperCamelCase       )

											# No fast custom tokenizer
											tokenizer.push_to_hub('test-dynamic-tokenizer'						, use_auth_token=self._token       )

											A      						=    AutoTokenizer.from_pretrained(f'''{USER}/test-dynamic-tokenizer'''						, trust_remote_code=__UpperCamelCase       )
											# Can't make an isinstance check because the new_model.config is from the CustomTokenizer class of a dynamic module
											self.assertEqual(tokenizer.__class__.__name__						, 'CustomTokenizer'       )

											# Fast and slow custom tokenizer
											CustomTokenizerFast.register_for_auto_class()
											with tempfile.TemporaryDirectory() as tmp_dir:
																		A      						=    os.path.join(__UpperCamelCase						, 'vocab.txt'       )
																		with open(__UpperCamelCase						, 'w'						, encoding='utf-8'       ) as vocab_writer:
																									vocab_writer.write(''.join([x + '\n' for x in self.vocab_tokens]       )       )

																		A      						=    BertTokenizerFast.from_pretrained(__UpperCamelCase       )
																		bert_tokenizer.save_pretrained(__UpperCamelCase       )
																		A      						=    CustomTokenizerFast.from_pretrained(__UpperCamelCase       )

											tokenizer.push_to_hub('test-dynamic-tokenizer'						, use_auth_token=self._token       )

											A      						=    AutoTokenizer.from_pretrained(f'''{USER}/test-dynamic-tokenizer'''						, trust_remote_code=__UpperCamelCase       )
											# Can't make an isinstance check because the new_model.config is from the FakeConfig class of a dynamic module
											self.assertEqual(tokenizer.__class__.__name__						, 'CustomTokenizerFast'       )
											A      						=    AutoTokenizer.from_pretrained(
											    f'''{USER}/test-dynamic-tokenizer'''						, use_fast=__UpperCamelCase						, trust_remote_code=__UpperCamelCase       )
											# Can't make an isinstance check because the new_model.config is from the FakeConfig class of a dynamic module
											self.assertEqual(tokenizer.__class__.__name__						, 'CustomTokenizer'       )





class        lowerCAmelCase__					(  unittest.TestCase       ):


				def __UpperCamelCase						(							self      :  List[Any]       )		->     Any:
											A      						=    Trie()
											trie.add('Hello 友達'       )
											self.assertEqual(trie.data						, {'H': {'e': {'l': {'l': {'o': {' ': {'友': {'達': {'': 1}}}}}}}}}       )
											trie.add('Hello'       )
											trie.data
											self.assertEqual(trie.data						, {'H': {'e': {'l': {'l': {'o': {'': 1, ' ': {'友': {'達': {'': 1}}}}}}}}}       )


				def __UpperCamelCase						(							self      :  Dict       )		->     Tuple:
											A      						=    Trie()
											self.assertEqual(trie.split('[CLS] This is a extra_id_100'       )						, ['[CLS] This is a extra_id_100']       )
											trie.add('[CLS]'       )
											trie.add('extra_id_1'       )
											trie.add('extra_id_100'       )
											self.assertEqual(trie.split('[CLS] This is a extra_id_100'       )						, ['[CLS]', ' This is a ', 'extra_id_100']       )


				def __UpperCamelCase						(							self      :  Any       )		->     Optional[int]:
											A      						=    Trie()
											trie.add('A'       )
											self.assertEqual(trie.split('ABC'       )						, ['A', 'BC']       )
											self.assertEqual(trie.split('BCA'       )						, ['BC', 'A']       )


				def __UpperCamelCase						(							self      :  Union[str, Any]       )		->     str:
											A      						=    Trie()
											trie.add('TOKEN]'       )
											trie.add('[SPECIAL_TOKEN]'       )
											self.assertEqual(trie.split('This is something [SPECIAL_TOKEN]'       )						, ['This is something ', '[SPECIAL_TOKEN]']       )


				def __UpperCamelCase						(							self      :  Union[str, Any]       )		->     Tuple:
											A      						=    Trie()
											trie.add('A'       )
											trie.add('P'       )
											trie.add('[SPECIAL_TOKEN]'       )
											self.assertEqual(trie.split('This is something [SPECIAL_TOKEN]'       )						, ['This is something ', '[SPECIAL_TOKEN]']       )


				def __UpperCamelCase						(							self      :  List[str]       )		->     Tuple:
											A      						=    Trie()
											trie.add('AB'       )
											trie.add('B'       )
											trie.add('C'       )
											self.assertEqual(trie.split('ABC'       )						, ['AB', 'C']       )


				def __UpperCamelCase						(							self      :  Union[str, Any]       )		->     List[Any]:
											A      						=    Trie()
											trie.add('ABC'       )
											trie.add('B'       )
											trie.add('CD'       )
											self.assertEqual(trie.split('ABCD'       )						, ['ABC', 'D']       )


				def __UpperCamelCase						(							self      :  Union[str, Any]       )		->     List[Any]:
											# Even if the offsets are wrong, we necessarily output correct string
											# parts.
											A      						=    Trie()
											A      						=    trie.cut_text('ABC'						, [0, 0, 2, 1, 2, 3]       )
											self.assertEqual(__UpperCamelCase						, ['AB', 'C']       )