






import os
import pickle
import unittest

from transformers import AutoTokenizer
from transformers.models.bert.tokenization_bert import BertTokenizer
from transformers.models.bert_japanese.tokenization_bert_japanese import (
    VOCAB_FILES_NAMES,
    BertJapaneseTokenizer,
    CharacterTokenizer,
    JumanppTokenizer,
    MecabTokenizer,
    SudachiTokenizer,
    WordpieceTokenizer,
)
from transformers.testing_utils import custom_tokenizers, require_jumanpp, require_sudachi

from ...test_tokenization_common import TokenizerTesterMixin
@custom_tokenizers
class  _UpperCAmelCase   (			A__						,unittest.TestCase      ):

				"""simple docstring"""




				lowercase__											=			BertJapaneseTokenizer
				lowercase__											=			False
				lowercase__											=			True




				def 							lowercase__  (	self		:       List[str]    ):

								'''simple docstring'''
								super().setUp()

								lowercase__  					=     [
								    '''[UNK]''',
								    '''[CLS]''',
								    '''[SEP]''',
								    '''こんにちは''',
								    '''こん''',
								    '''にちは''',
								    '''ばんは''',
								    '''##こん''',
								    '''##にちは''',
								    '''##ばんは''',
								    '''世界''',
								    '''##世界''',
								    '''、''',
								    '''##、''',
								    '''。''',
								    '''##。''',
								]

								lowercase__  					=     os.path.join(self.tmpdirname,    VOCAB_FILES_NAMES['''vocab_file''']    )
								with open(self.vocab_file,    '''w''',    encoding='''utf-8'''    ) as vocab_writer:
												vocab_writer.write(''''''.join([x + '''\n''' for x in vocab_tokens]    )    )




				def 							lowercase__  (	self		:       Optional[int],    lowerCamelCase		:       List[Any]    ):

								'''simple docstring'''
								lowercase__  					=     '''こんにちは、世界。 \nこんばんは、世界。'''
								lowercase__  					=     '''こんにちは 、 世界 。 こんばんは 、 世界 。'''
								return input_text, output_text




				def 							lowercase__  (	self		:       Any,    lowerCamelCase		:       List[Any]    ):

								'''simple docstring'''
								lowercase__					,		lowercase__  					=     self.get_input_output_texts(lowerCamelCase    )
								lowercase__  					=     tokenizer.encode(lowerCamelCase,    add_special_tokens=lowerCamelCase    )
								lowercase__  					=     tokenizer.decode(lowerCamelCase,    clean_up_tokenization_spaces=lowerCamelCase    )
								return text, ids




				def 							lowercase__  (	self		:       Tuple    ):

								'''simple docstring'''
								pass  # TODO add if relevant




				def 							lowercase__  (	self		:       str    ):

								'''simple docstring'''
								pass  # TODO add if relevant




				def 							lowercase__  (	self		:       Optional[int]    ):

								'''simple docstring'''
								pass  # TODO add if relevant




				def 							lowercase__  (	self		:       Optional[Any]    ):

								'''simple docstring'''
								lowercase__  					=     self.tokenizer_class(self.vocab_file    )

								lowercase__  					=     tokenizer.tokenize('''こんにちは、世界。\nこんばんは、世界。'''    )
								self.assertListEqual(lowerCamelCase,    ['''こんにちは''', '''、''', '''世界''', '''。''', '''こん''', '''##ばんは''', '''、''', '''世界''', '''。''']    )
								self.assertListEqual(tokenizer.convert_tokens_to_ids(lowerCamelCase    ),    [3, 12, 10, 14, 4, 9, 12, 10, 14]    )




				def 							lowercase__  (	self		:       str    ):

								'''simple docstring'''
								lowercase__  					=     self.tokenizer_class(self.vocab_file,    word_tokenizer_type='''mecab'''    )
								self.assertIsNotNone(lowerCamelCase    )

								lowercase__  					=     '''こんにちは、世界。\nこんばんは、世界。'''
								lowercase__  					=     tokenizer.tokenize(lowerCamelCase    )
								self.assertListEqual(lowerCamelCase,    ['''こんにちは''', '''、''', '''世界''', '''。''', '''こん''', '''##ばんは''', '''、''', '''世界''', '''。''']    )
								self.assertListEqual(tokenizer.convert_tokens_to_ids(lowerCamelCase    ),    [3, 12, 10, 14, 4, 9, 12, 10, 14]    )

								lowercase__  					=     os.path.join(self.tmpdirname,    '''tokenizer.bin'''    )
								with open(lowerCamelCase,    '''wb'''    ) as handle:
												pickle.dump(lowerCamelCase,    lowerCamelCase    )

								with open(lowerCamelCase,    '''rb'''    ) as handle:
												lowercase__  					=     pickle.load(lowerCamelCase    )

								lowercase__  					=     tokenizer_new.tokenize(lowerCamelCase    )

								self.assertListEqual(lowerCamelCase,    lowerCamelCase    )




				def 							lowercase__  (	self		:       Any    ):

								'''simple docstring'''
								lowercase__  					=     MecabTokenizer(mecab_dic='''ipadic'''    )

								self.assertListEqual(
								    tokenizer.tokenize(''' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '''    ),    ['''アップルストア''', '''で''', '''iPhone''', '''8''', '''が''', '''発売''', '''さ''', '''れ''', '''た''', '''。'''],    )




				def 							lowercase__  (	self		:       int    ):

								'''simple docstring'''
								try:
												lowercase__  					=     MecabTokenizer(mecab_dic='''unidic_lite'''    )
								except ModuleNotFoundError:
												return

								self.assertListEqual(
								    tokenizer.tokenize(''' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '''    ),    ['''アップル''', '''ストア''', '''で''', '''iPhone''', '''8''', '''が''', '''発売''', '''さ''', '''れ''', '''た''', '''。'''],    )




				def 							lowercase__  (	self		:       Dict    ):

								'''simple docstring'''
								try:
												lowercase__  					=     MecabTokenizer(mecab_dic='''unidic'''    )
								except ModuleNotFoundError:
												return

								self.assertListEqual(
								    tokenizer.tokenize(''' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '''    ),    ['''アップル''', '''ストア''', '''で''', '''iPhone''', '''8''', '''が''', '''発売''', '''さ''', '''れ''', '''た''', '''。'''],    )




				def 							lowercase__  (	self		:       Optional[Any]    ):

								'''simple docstring'''
								lowercase__  					=     MecabTokenizer(do_lower_case=lowerCamelCase,    mecab_dic='''ipadic'''    )

								self.assertListEqual(
								    tokenizer.tokenize(''' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '''    ),    ['''アップルストア''', '''で''', '''iphone''', '''8''', '''が''', '''発売''', '''さ''', '''れ''', '''た''', '''。'''],    )




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

								'''simple docstring'''
								try:
												lowercase__  					=     MecabTokenizer(
												    do_lower_case=lowerCamelCase,    normalize_text=lowerCamelCase,    mecab_option='''-d /usr/local/lib/mecab/dic/jumandic'''    )
								except RuntimeError:
												# if dict doesn't exist in the system, previous code raises this error.
												return

								self.assertListEqual(
								    tokenizer.tokenize(''' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '''    ),    ['''ｱｯﾌﾟﾙストア''', '''で''', '''iPhone''', '''８''', '''が''', '''発売''', '''さ''', '''れた''', '''\u3000''', '''。'''],    )




				def 							lowercase__  (	self		:       List[str]    ):

								'''simple docstring'''
								lowercase__  					=     MecabTokenizer(normalize_text=lowerCamelCase,    mecab_dic='''ipadic'''    )

								self.assertListEqual(
								    tokenizer.tokenize(''' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '''    ),    ['''ｱｯﾌﾟﾙストア''', '''で''', '''iPhone''', '''８''', '''が''', '''発売''', '''さ''', '''れ''', '''た''', '''　''', '''。'''],    )




				@require_sudachi
				def 							lowercase__  (	self		:       Any    ):

								'''simple docstring'''
								lowercase__  					=     self.tokenizer_class(self.vocab_file,    word_tokenizer_type='''sudachi'''    )
								self.assertIsNotNone(lowerCamelCase    )

								lowercase__  					=     '''こんにちは、世界。\nこんばんは、世界。'''
								lowercase__  					=     tokenizer.tokenize(lowerCamelCase    )
								self.assertListEqual(lowerCamelCase,    ['''こんにちは''', '''、''', '''世界''', '''。''', '''こん''', '''##ばんは''', '''、''', '''世界''', '''。''']    )
								self.assertListEqual(tokenizer.convert_tokens_to_ids(lowerCamelCase    ),    [3, 12, 10, 14, 4, 9, 12, 10, 14]    )

								lowercase__  					=     os.path.join(self.tmpdirname,    '''tokenizer.bin'''    )
								with open(lowerCamelCase,    '''wb'''    ) as handle:
												pickle.dump(lowerCamelCase,    lowerCamelCase    )

								with open(lowerCamelCase,    '''rb'''    ) as handle:
												lowercase__  					=     pickle.load(lowerCamelCase    )

								lowercase__  					=     tokenizer_new.tokenize(lowerCamelCase    )

								self.assertListEqual(lowerCamelCase,    lowerCamelCase    )




				@require_sudachi
				def 							lowercase__  (	self		:       str    ):

								'''simple docstring'''
								lowercase__  					=     SudachiTokenizer(sudachi_dict_type='''core'''    )

								self.assertListEqual(
								    tokenizer.tokenize(''' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '''    ),    [''' ''', '''\t''', '''アップル''', '''ストア''', '''で''', '''iPhone''', '''8''', ''' ''', '''が''', ''' ''', ''' ''', '''\n ''', '''発売''', '''さ''', '''れ''', '''た''', ''' ''', '''。''', ''' ''', ''' '''],    )




				@require_sudachi
				def 							lowercase__  (	self		:       Union[str, Any]    ):

								'''simple docstring'''
								lowercase__  					=     SudachiTokenizer(sudachi_dict_type='''core''',    sudachi_split_mode='''A'''    )

								self.assertListEqual(tokenizer.tokenize('''外国人参政権'''    ),    ['''外国''', '''人''', '''参政''', '''権''']    )




				@require_sudachi
				def 							lowercase__  (	self		:       Dict    ):

								'''simple docstring'''
								lowercase__  					=     SudachiTokenizer(sudachi_dict_type='''core''',    sudachi_split_mode='''B'''    )

								self.assertListEqual(tokenizer.tokenize('''外国人参政権'''    ),    ['''外国人''', '''参政権''']    )




				@require_sudachi
				def 							lowercase__  (	self		:       List[Any]    ):

								'''simple docstring'''
								lowercase__  					=     SudachiTokenizer(sudachi_dict_type='''core''',    sudachi_split_mode='''C'''    )

								self.assertListEqual(tokenizer.tokenize('''外国人参政権'''    ),    ['''外国人参政権''']    )




				@require_sudachi
				def 							lowercase__  (	self		:       Any    ):

								'''simple docstring'''
								lowercase__  					=     SudachiTokenizer(do_lower_case=lowerCamelCase,    sudachi_dict_type='''core'''    )

								self.assertListEqual(
								    tokenizer.tokenize(''' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '''    ),    [''' ''', '''\t''', '''アップル''', '''ストア''', '''で''', '''iphone''', '''8''', ''' ''', '''が''', ''' ''', ''' ''', '''\n ''', '''発売''', '''さ''', '''れ''', '''た''', ''' ''', '''。''', ''' ''', ''' '''],    )




				@require_sudachi
				def 							lowercase__  (	self		:       int    ):

								'''simple docstring'''
								lowercase__  					=     SudachiTokenizer(normalize_text=lowerCamelCase,    sudachi_dict_type='''core'''    )

								self.assertListEqual(
								    tokenizer.tokenize(''' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '''    ),    [''' ''', '''\t''', '''ｱｯﾌﾟﾙ''', '''ストア''', '''で''', '''iPhone''', '''８''', ''' ''', '''が''', ''' ''', ''' ''', '''\n ''', '''発売''', '''さ''', '''れ''', '''た''', '''\u3000''', '''。''', ''' ''', ''' '''],    )




				@require_sudachi
				def 							lowercase__  (	self		:       int    ):

								'''simple docstring'''
								lowercase__  					=     SudachiTokenizer(trim_whitespace=lowerCamelCase,    sudachi_dict_type='''core'''    )

								self.assertListEqual(
								    tokenizer.tokenize(''' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '''    ),    ['''アップル''', '''ストア''', '''で''', '''iPhone''', '''8''', '''が''', '''発売''', '''さ''', '''れ''', '''た''', '''。'''],    )




				@require_jumanpp
				def 							lowercase__  (	self		:       Tuple    ):

								'''simple docstring'''
								lowercase__  					=     self.tokenizer_class(self.vocab_file,    word_tokenizer_type='''jumanpp'''    )
								self.assertIsNotNone(lowerCamelCase    )

								lowercase__  					=     '''こんにちは、世界。\nこんばんは、世界。'''
								lowercase__  					=     tokenizer.tokenize(lowerCamelCase    )
								self.assertListEqual(lowerCamelCase,    ['''こんにちは''', '''、''', '''世界''', '''。''', '''こん''', '''##ばんは''', '''、''', '''世界''', '''。''']    )
								self.assertListEqual(tokenizer.convert_tokens_to_ids(lowerCamelCase    ),    [3, 12, 10, 14, 4, 9, 12, 10, 14]    )

								lowercase__  					=     os.path.join(self.tmpdirname,    '''tokenizer.bin'''    )
								with open(lowerCamelCase,    '''wb'''    ) as handle:
												pickle.dump(lowerCamelCase,    lowerCamelCase    )

								with open(lowerCamelCase,    '''rb'''    ) as handle:
												lowercase__  					=     pickle.load(lowerCamelCase    )

								lowercase__  					=     tokenizer_new.tokenize(lowerCamelCase    )

								self.assertListEqual(lowerCamelCase,    lowerCamelCase    )




				@require_jumanpp
				def 							lowercase__  (	self		:       List[Any]    ):

								'''simple docstring'''
								lowercase__  					=     JumanppTokenizer()

								self.assertListEqual(
								    tokenizer.tokenize(''' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '''    ),    ['''アップル''', '''ストア''', '''で''', '''iPhone''', '''8''', '''\u3000''', '''が''', '''\u3000''', '''\u3000''', '''\u3000''', '''発売''', '''さ''', '''れた''', '''\u3000''', '''。'''],    )




				@require_jumanpp
				def 							lowercase__  (	self		:       str    ):

								'''simple docstring'''
								lowercase__  					=     JumanppTokenizer(do_lower_case=lowerCamelCase    )

								self.assertListEqual(
								    tokenizer.tokenize(''' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '''    ),    ['''アップル''', '''ストア''', '''で''', '''iphone''', '''8''', '''\u3000''', '''が''', '''\u3000''', '''\u3000''', '''\u3000''', '''発売''', '''さ''', '''れた''', '''\u3000''', '''。'''],    )




				@require_jumanpp
				def 							lowercase__  (	self		:       str    ):

								'''simple docstring'''
								lowercase__  					=     JumanppTokenizer(normalize_text=lowerCamelCase    )

								self.assertListEqual(
								    tokenizer.tokenize(''' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '''    ),    ['''ｱ''', '''ｯ''', '''ﾌ''', '''ﾟ''', '''ﾙ''', '''ストア''', '''で''', '''iPhone''', '''８''', '''\u3000''', '''が''', '''\u3000''', '''\u3000''', '''\u3000''', '''発売''', '''さ''', '''れた''', '''\u3000''', '''。'''],    )




				@require_jumanpp
				def 							lowercase__  (	self		:       Optional[Any]    ):

								'''simple docstring'''
								lowercase__  					=     JumanppTokenizer(trim_whitespace=lowerCamelCase    )

								self.assertListEqual(
								    tokenizer.tokenize(''' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '''    ),    ['''アップル''', '''ストア''', '''で''', '''iPhone''', '''8''', '''が''', '''発売''', '''さ''', '''れた''', '''。'''],    )




				@require_jumanpp
				def 							lowercase__  (	self		:       Optional[Any]    ):

								'''simple docstring'''
								lowercase__  					=     JumanppTokenizer()

								self.assertListEqual(
								    tokenizer.tokenize('''ありがとうございますm(_ _)ｍ見つけるのが大変です。'''    ),    ['''ありがとう''', '''ございます''', '''m(_ _)m''', '''見つける''', '''の''', '''が''', '''大変です''', '''。'''],    )




				def 							lowercase__  (	self		:       Dict    ):

								'''simple docstring'''
								lowercase__  					=     ['''[UNK]''', '''[CLS]''', '''[SEP]''', '''こんにちは''', '''こん''', '''にちは''', '''ばんは''', '''##こん''', '''##にちは''', '''##ばんは''']

								lowercase__  					=     {}
								for i, token in enumerate(lowerCamelCase    ):
												lowercase__  					=     i
								lowercase__  					=     WordpieceTokenizer(vocab=lowerCamelCase,    unk_token='''[UNK]'''    )

								self.assertListEqual(tokenizer.tokenize(''''''    ),    []    )

								self.assertListEqual(tokenizer.tokenize('''こんにちは'''    ),    ['''こんにちは''']    )

								self.assertListEqual(tokenizer.tokenize('''こんばんは'''    ),    ['''こん''', '''##ばんは''']    )

								self.assertListEqual(tokenizer.tokenize('''こんばんは こんばんにちは こんにちは'''    ),    ['''こん''', '''##ばんは''', '''[UNK]''', '''こんにちは''']    )




				def 							lowercase__  (	self		:       Optional[int]    ):

								'''simple docstring'''
								lowercase__  					=     BertJapaneseTokenizer.from_pretrained('''nlp-waseda/roberta-base-japanese-with-auto-jumanpp'''    )
								lowercase__  					=     tokenizer.subword_tokenizer

								lowercase__  					=     subword_tokenizer.tokenize('''国境 の 長い トンネル を 抜ける と 雪国 であった 。'''    )
								self.assertListEqual(lowerCamelCase,    ['''▁国境''', '''▁の''', '''▁長い''', '''▁トンネル''', '''▁を''', '''▁抜ける''', '''▁と''', '''▁雪''', '''国''', '''▁であった''', '''▁。''']    )

								lowercase__  					=     subword_tokenizer.tokenize('''こんばんは こんばん にち は こんにちは'''    )
								self.assertListEqual(lowerCamelCase,    ['''▁こん''', '''ばん''', '''は''', '''▁こん''', '''ばん''', '''▁に''', '''ち''', '''▁は''', '''▁こんにちは''']    )




				def 							lowercase__  (	self		:       Any    ):

								'''simple docstring'''
								lowercase__  					=     self.tokenizer_class.from_pretrained('''cl-tohoku/bert-base-japanese'''    )

								lowercase__  					=     tokenizer.encode('''ありがとう。''',    add_special_tokens=lowerCamelCase    )
								lowercase__  					=     tokenizer.encode('''どういたしまして。''',    add_special_tokens=lowerCamelCase    )

								lowercase__  					=     tokenizer.build_inputs_with_special_tokens(lowerCamelCase    )
								lowercase__  					=     tokenizer.build_inputs_with_special_tokens(lowerCamelCase,    lowerCamelCase    )

								# 2 is for "[CLS]", 3 is for "[SEP]"
								assert encoded_sentence == [2] + text + [3]
								assert encoded_pair == [2] + text + [3] + text_a + [3]



@custom_tokenizers
class  _UpperCAmelCase   (			A__						,unittest.TestCase      ):

				"""simple docstring"""




				lowercase__											=			BertJapaneseTokenizer
				lowercase__											=			False




				def 							lowercase__  (	self		:       Tuple    ):

								'''simple docstring'''
								super().setUp()

								lowercase__  					=     ['''[UNK]''', '''[CLS]''', '''[SEP]''', '''こ''', '''ん''', '''に''', '''ち''', '''は''', '''ば''', '''世''', '''界''', '''、''', '''。''']

								lowercase__  					=     os.path.join(self.tmpdirname,    VOCAB_FILES_NAMES['''vocab_file''']    )
								with open(self.vocab_file,    '''w''',    encoding='''utf-8'''    ) as vocab_writer:
												vocab_writer.write(''''''.join([x + '''\n''' for x in vocab_tokens]    )    )




				def 							lowercase__  (	self		:       List[str],    **lowerCamelCase		:       Optional[int]    ):

								'''simple docstring'''
								return BertJapaneseTokenizer.from_pretrained(self.tmpdirname,    subword_tokenizer_type='''character''',    **lowerCamelCase    )




				def 							lowercase__  (	self		:       Any,    lowerCamelCase		:       Optional[Any]    ):

								'''simple docstring'''
								lowercase__  					=     '''こんにちは、世界。 \nこんばんは、世界。'''
								lowercase__  					=     '''こ ん に ち は 、 世 界 。 こ ん ば ん は 、 世 界 。'''
								return input_text, output_text




				def 							lowercase__  (	self		:       Tuple    ):

								'''simple docstring'''
								pass  # TODO add if relevant




				def 							lowercase__  (	self		:       Optional[Any]    ):

								'''simple docstring'''
								pass  # TODO add if relevant




				def 							lowercase__  (	self		:       List[Any]    ):

								'''simple docstring'''
								pass  # TODO add if relevant




				def 							lowercase__  (	self		:       List[Any]    ):

								'''simple docstring'''
								lowercase__  					=     self.tokenizer_class(self.vocab_file,    subword_tokenizer_type='''character'''    )

								lowercase__  					=     tokenizer.tokenize('''こんにちは、世界。 \nこんばんは、世界。'''    )
								self.assertListEqual(
								    lowerCamelCase,    ['''こ''', '''ん''', '''に''', '''ち''', '''は''', '''、''', '''世''', '''界''', '''。''', '''こ''', '''ん''', '''ば''', '''ん''', '''は''', '''、''', '''世''', '''界''', '''。''']    )
								self.assertListEqual(
								    tokenizer.convert_tokens_to_ids(lowerCamelCase    ),    [3, 4, 5, 6, 7, 11, 9, 10, 12, 3, 4, 8, 4, 7, 11, 9, 10, 12]    )




				def 							lowercase__  (	self		:       int    ):

								'''simple docstring'''
								lowercase__  					=     ['''[UNK]''', '''[CLS]''', '''[SEP]''', '''こ''', '''ん''', '''に''', '''ち''', '''は''', '''ば''', '''世''', '''界''', '''、''', '''。''']

								lowercase__  					=     {}
								for i, token in enumerate(lowerCamelCase    ):
												lowercase__  					=     i
								lowercase__  					=     CharacterTokenizer(vocab=lowerCamelCase,    unk_token='''[UNK]'''    )

								self.assertListEqual(tokenizer.tokenize(''''''    ),    []    )

								self.assertListEqual(tokenizer.tokenize('''こんにちは'''    ),    ['''こ''', '''ん''', '''に''', '''ち''', '''は''']    )

								self.assertListEqual(tokenizer.tokenize('''こんにちほ'''    ),    ['''こ''', '''ん''', '''に''', '''ち''', '''[UNK]''']    )




				def 							lowercase__  (	self		:       Optional[int]    ):

								'''simple docstring'''
								lowercase__  					=     self.tokenizer_class.from_pretrained('''cl-tohoku/bert-base-japanese-char'''    )

								lowercase__  					=     tokenizer.encode('''ありがとう。''',    add_special_tokens=lowerCamelCase    )
								lowercase__  					=     tokenizer.encode('''どういたしまして。''',    add_special_tokens=lowerCamelCase    )

								lowercase__  					=     tokenizer.build_inputs_with_special_tokens(lowerCamelCase    )
								lowercase__  					=     tokenizer.build_inputs_with_special_tokens(lowerCamelCase,    lowerCamelCase    )

								# 2 is for "[CLS]", 3 is for "[SEP]"
								assert encoded_sentence == [2] + text + [3]
								assert encoded_pair == [2] + text + [3] + text_a + [3]



@custom_tokenizers
class  _UpperCAmelCase   (			unittest.TestCase      ):

				"""simple docstring"""




				def 							lowercase__  (	self		:       Dict    ):

								'''simple docstring'''
								lowercase__  					=     '''cl-tohoku/bert-base-japanese'''
								lowercase__  					=     AutoTokenizer.from_pretrained(lowerCamelCase    )
								self.assertIsInstance(lowerCamelCase,    lowerCamelCase    )



class  _UpperCAmelCase   (			unittest.TestCase      ):

				"""simple docstring"""




				def 							lowercase__  (	self		:       Optional[int]    ):

								'''simple docstring'''
								lowercase__  					=     '''cl-tohoku/bert-base-japanese'''
								with self.assertLogs('''transformers''',    level='''WARNING'''    ) as cm:
												BertTokenizer.from_pretrained(lowerCamelCase    )
												self.assertTrue(
												    cm.records[0].message.startswith(
												        '''The tokenizer class you load from this checkpoint is not the same type as the class this function'''
												        ''' is called from.'''    )    )
								lowercase__  					=     '''bert-base-cased'''
								with self.assertLogs('''transformers''',    level='''WARNING'''    ) as cm:
												BertJapaneseTokenizer.from_pretrained(lowerCamelCase    )
												self.assertTrue(
												    cm.records[0].message.startswith(
												        '''The tokenizer class you load from this checkpoint is not the same type as the class this function'''
												        ''' is called from.'''    )    )












# Copyright 2021 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import argparse
import os

from accelerate.test_utils import execute_subprocess_async






def     a     (		lowerCamelCase_=None							):






				'''simple docstring'''
				if subparsers is not None:
								lowercase__  					=     subparsers.add_parser('''test'''							)
				else:
								lowercase__  					=     argparse.ArgumentParser('''Accelerate test command'''							)

				parser.add_argument(
				    '''--config_file'''						,  default=lowerCamelCase_						,  help=(
				        '''The path to use to store the config file. Will default to a file named default_config.yaml in the cache '''
				        '''location, which is the content of the environment `HF_HOME` suffixed with \'accelerate\', or if you don\'t have '''
				        '''such an environment variable, your cache directory (\'~/.cache\' or the content of `XDG_CACHE_HOME`) suffixed '''
				        '''with \'huggingface\'.'''
				    )						,  )

				if subparsers is not None:
								parser.set_defaults(func=lowerCamelCase_							)
				return parser






def     a     (		lowerCamelCase_							):






				'''simple docstring'''
				lowercase__  					=     os.path.sep.join(__file__.split(os.path.sep							)[:-2] + ['''test_utils''', '''scripts''', '''test_script.py''']							)

				if args.config_file is None:
								lowercase__  					=     script_name
				else:
								lowercase__  					=     F"""--config_file={args.config_file} {script_name}"""

				lowercase__  					=     ['''accelerate-launch'''] + test_args.split()
				lowercase__  					=     execute_subprocess_async(lowerCamelCase_						,  env=os.environ.copy()							)
				if result.returncode == 0:
								print('''Test is a success! You are ready for your distributed training!'''							)






def     a     (		):






				'''simple docstring'''
				lowercase__  					=     test_command_parser()
				lowercase__  					=     parser.parse_args()
				test_command(lowerCamelCase_							)


if __name__ == "__main__":
							main()




