






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  lowerCAmelCase_       (				snake_case__     ,    unittest.TestCase					):
							UpperCamelCase_		:int		      =    BertJapaneseTokenizer
							UpperCamelCase_		:Dict		      =    False
							UpperCamelCase_		:int		      =    True




							def 						__snake_case					(   self     :   Tuple	):
											super().setUp()

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

											lowerCAmelCase__      			=						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 						__snake_case					(   self     :   int ,							SCREAMING_SNAKE_CASE_     :   int	):
											lowerCAmelCase__      			=						'''こんにちは、世界。 \nこんばんは、世界。'''
											lowerCAmelCase__      			=						'''こんにちは 、 世界 。 こんばんは 、 世界 。'''
											return input_text, output_text




							def 						__snake_case					(   self     :   Union[str, Any] ,							SCREAMING_SNAKE_CASE_     :   Optional[int]	):
											lowerCAmelCase__			,		lowerCAmelCase__      			=						self.get_input_output_texts(SCREAMING_SNAKE_CASE_	)
											lowerCAmelCase__      			=						tokenizer.encode(SCREAMING_SNAKE_CASE_ ,							add_special_tokens=SCREAMING_SNAKE_CASE_	)
											lowerCAmelCase__      			=						tokenizer.decode(SCREAMING_SNAKE_CASE_ ,							clean_up_tokenization_spaces=SCREAMING_SNAKE_CASE_	)
											return text, ids




							def 						__snake_case					(   self     :   List[str]	):
											pass  # TODO add if relevant




							def 						__snake_case					(   self     :   Tuple	):
											pass  # TODO add if relevant




							def 						__snake_case					(   self     :   Optional[Any]	):
											pass  # TODO add if relevant




							def 						__snake_case					(   self     :   Union[str, Any]	):
											lowerCAmelCase__      			=						self.tokenizer_class(self.vocab_file	)

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




							def 						__snake_case					(   self     :   int	):
											lowerCAmelCase__      			=						self.tokenizer_class(self.vocab_file ,							word_tokenizer_type='''mecab'''	)
											self.assertIsNotNone(SCREAMING_SNAKE_CASE_	)

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

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

											with open(SCREAMING_SNAKE_CASE_ ,							'''rb'''	) as handle:
															lowerCAmelCase__      			=						pickle.load(SCREAMING_SNAKE_CASE_	)

											lowerCAmelCase__      			=						tokenizer_new.tokenize(SCREAMING_SNAKE_CASE_	)

											self.assertListEqual(SCREAMING_SNAKE_CASE_ ,							SCREAMING_SNAKE_CASE_	)




							def 						__snake_case					(   self     :   List[str]	):
											lowerCAmelCase__      			=						MecabTokenizer(mecab_dic='''ipadic'''	)

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




							def 						__snake_case					(   self     :   Optional[Any]	):

											try:
															lowerCAmelCase__      			=						MecabTokenizer(mecab_dic='''unidic_lite'''	)
											except ModuleNotFoundError:
															return

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




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

											try:
															lowerCAmelCase__      			=						MecabTokenizer(mecab_dic='''unidic'''	)
											except ModuleNotFoundError:
															return

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




							def 						__snake_case					(   self     :   Any	):
											lowerCAmelCase__      			=						MecabTokenizer(do_lower_case=SCREAMING_SNAKE_CASE_ ,							mecab_dic='''ipadic'''	)

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




							def 						__snake_case					(   self     :   Optional[int]	):

											try:
															lowerCAmelCase__      			=						MecabTokenizer(
															    do_lower_case=SCREAMING_SNAKE_CASE_ ,							normalize_text=SCREAMING_SNAKE_CASE_ ,							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 						__snake_case					(   self     :   Optional[int]	):
											lowerCAmelCase__      			=						MecabTokenizer(normalize_text=SCREAMING_SNAKE_CASE_ ,							mecab_dic='''ipadic'''	)

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




							@require_sudachi
							def 						__snake_case					(   self     :   Optional[Any]	):
											lowerCAmelCase__      			=						self.tokenizer_class(self.vocab_file ,							word_tokenizer_type='''sudachi'''	)
											self.assertIsNotNone(SCREAMING_SNAKE_CASE_	)

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

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

											with open(SCREAMING_SNAKE_CASE_ ,							'''rb'''	) as handle:
															lowerCAmelCase__      			=						pickle.load(SCREAMING_SNAKE_CASE_	)

											lowerCAmelCase__      			=						tokenizer_new.tokenize(SCREAMING_SNAKE_CASE_	)

											self.assertListEqual(SCREAMING_SNAKE_CASE_ ,							SCREAMING_SNAKE_CASE_	)




							@require_sudachi
							def 						__snake_case					(   self     :   Any	):
											lowerCAmelCase__      			=						SudachiTokenizer(sudachi_dict_type='''core'''	)

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




							@require_sudachi
							def 						__snake_case					(   self     :   int	):
											lowerCAmelCase__      			=						SudachiTokenizer(sudachi_dict_type='''core''' ,							sudachi_split_mode='''A'''	)

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




							@require_sudachi
							def 						__snake_case					(   self     :   Optional[int]	):
											lowerCAmelCase__      			=						SudachiTokenizer(sudachi_dict_type='''core''' ,							sudachi_split_mode='''B'''	)

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




							@require_sudachi
							def 						__snake_case					(   self     :   Dict	):
											lowerCAmelCase__      			=						SudachiTokenizer(sudachi_dict_type='''core''' ,							sudachi_split_mode='''C'''	)

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




							@require_sudachi
							def 						__snake_case					(   self     :   List[str]	):
											lowerCAmelCase__      			=						SudachiTokenizer(do_lower_case=SCREAMING_SNAKE_CASE_ ,							sudachi_dict_type='''core'''	)

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




							@require_sudachi
							def 						__snake_case					(   self     :   List[Any]	):
											lowerCAmelCase__      			=						SudachiTokenizer(normalize_text=SCREAMING_SNAKE_CASE_ ,							sudachi_dict_type='''core'''	)

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




							@require_sudachi
							def 						__snake_case					(   self     :   Any	):
											lowerCAmelCase__      			=						SudachiTokenizer(trim_whitespace=SCREAMING_SNAKE_CASE_ ,							sudachi_dict_type='''core'''	)

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




							@require_jumanpp
							def 						__snake_case					(   self     :   List[Any]	):
											lowerCAmelCase__      			=						self.tokenizer_class(self.vocab_file ,							word_tokenizer_type='''jumanpp'''	)
											self.assertIsNotNone(SCREAMING_SNAKE_CASE_	)

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

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

											with open(SCREAMING_SNAKE_CASE_ ,							'''rb'''	) as handle:
															lowerCAmelCase__      			=						pickle.load(SCREAMING_SNAKE_CASE_	)

											lowerCAmelCase__      			=						tokenizer_new.tokenize(SCREAMING_SNAKE_CASE_	)

											self.assertListEqual(SCREAMING_SNAKE_CASE_ ,							SCREAMING_SNAKE_CASE_	)




							@require_jumanpp
							def 						__snake_case					(   self     :   Any	):
											lowerCAmelCase__      			=						JumanppTokenizer()

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




							@require_jumanpp
							def 						__snake_case					(   self     :   List[str]	):
											lowerCAmelCase__      			=						JumanppTokenizer(do_lower_case=SCREAMING_SNAKE_CASE_	)

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




							@require_jumanpp
							def 						__snake_case					(   self     :   Tuple	):
											lowerCAmelCase__      			=						JumanppTokenizer(normalize_text=SCREAMING_SNAKE_CASE_	)

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




							@require_jumanpp
							def 						__snake_case					(   self     :   Union[str, Any]	):
											lowerCAmelCase__      			=						JumanppTokenizer(trim_whitespace=SCREAMING_SNAKE_CASE_	)

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




							@require_jumanpp
							def 						__snake_case					(   self     :   Optional[int]	):
											lowerCAmelCase__      			=						JumanppTokenizer()

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




							def 						__snake_case					(   self     :   int	):
											lowerCAmelCase__      			=						['''[UNK]''', '''[CLS]''', '''[SEP]''', '''こんにちは''', '''こん''', '''にちは''', '''ばんは''', '''##こん''', '''##にちは''', '''##ばんは''']

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

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

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

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

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




							def 						__snake_case					(   self     :   Dict	):
											lowerCAmelCase__      			=						BertJapaneseTokenizer.from_pretrained('''nlp-waseda/roberta-base-japanese-with-auto-jumanpp'''	)
											lowerCAmelCase__      			=						tokenizer.subword_tokenizer

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

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




							def 						__snake_case					(   self     :   Dict	):
											lowerCAmelCase__      			=						self.tokenizer_class.from_pretrained('''cl-tohoku/bert-base-japanese'''	)

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

											lowerCAmelCase__      			=						tokenizer.build_inputs_with_special_tokens(SCREAMING_SNAKE_CASE_	)
											lowerCAmelCase__      			=						tokenizer.build_inputs_with_special_tokens(SCREAMING_SNAKE_CASE_ ,							SCREAMING_SNAKE_CASE_	)

											# 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  lowerCAmelCase_       (				snake_case__     ,    unittest.TestCase					):
							UpperCamelCase_		:List[str]		      =    BertJapaneseTokenizer
							UpperCamelCase_		:List[str]		      =    False




							def 						__snake_case					(   self     :   int	):
											super().setUp()

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

											lowerCAmelCase__      			=						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 						__snake_case					(   self     :   List[Any] ,							**SCREAMING_SNAKE_CASE_     :   Tuple	):
											return BertJapaneseTokenizer.from_pretrained(self.tmpdirname ,							subword_tokenizer_type='''character''' ,							**SCREAMING_SNAKE_CASE_	)




							def 						__snake_case					(   self     :   Optional[Any] ,							SCREAMING_SNAKE_CASE_     :   int	):
											lowerCAmelCase__      			=						'''こんにちは、世界。 \nこんばんは、世界。'''
											lowerCAmelCase__      			=						'''こ ん に ち は 、 世 界 。 こ ん ば ん は 、 世 界 。'''
											return input_text, output_text




							def 						__snake_case					(   self     :   Any	):
											pass  # TODO add if relevant




							def 						__snake_case					(   self     :   List[Any]	):
											pass  # TODO add if relevant




							def 						__snake_case					(   self     :   Any	):
											pass  # TODO add if relevant




							def 						__snake_case					(   self     :   Optional[Any]	):
											lowerCAmelCase__      			=						self.tokenizer_class(self.vocab_file ,							subword_tokenizer_type='''character'''	)

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




							def 						__snake_case					(   self     :   List[str]	):
											lowerCAmelCase__      			=						['''[UNK]''', '''[CLS]''', '''[SEP]''', '''こ''', '''ん''', '''に''', '''ち''', '''は''', '''ば''', '''世''', '''界''', '''、''', '''。''']

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

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

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

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




							def 						__snake_case					(   self     :   str	):
											lowerCAmelCase__      			=						self.tokenizer_class.from_pretrained('''cl-tohoku/bert-base-japanese-char'''	)

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

											lowerCAmelCase__      			=						tokenizer.build_inputs_with_special_tokens(SCREAMING_SNAKE_CASE_	)
											lowerCAmelCase__      			=						tokenizer.build_inputs_with_special_tokens(SCREAMING_SNAKE_CASE_ ,							SCREAMING_SNAKE_CASE_	)

											# 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  lowerCAmelCase_       (				unittest.TestCase					):




							def 						__snake_case					(   self     :   Any	):
											lowerCAmelCase__      			=						'''cl-tohoku/bert-base-japanese'''
											lowerCAmelCase__      			=						AutoTokenizer.from_pretrained(SCREAMING_SNAKE_CASE_	)
											self.assertIsInstance(SCREAMING_SNAKE_CASE_ ,							SCREAMING_SNAKE_CASE_	)



class  lowerCAmelCase_       (				unittest.TestCase					):




							def 						__snake_case					(   self     :   Optional[Any]	):
											lowerCAmelCase__      			=						'''cl-tohoku/bert-base-japanese'''
											with self.assertLogs('''transformers''' ,							level='''WARNING'''	) as cm:
															BertTokenizer.from_pretrained(SCREAMING_SNAKE_CASE_	)
															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.'''	)	)
											lowerCAmelCase__      			=						'''bert-base-cased'''
											with self.assertLogs('''transformers''' ,							level='''WARNING'''	) as cm:
															BertJapaneseTokenizer.from_pretrained(SCREAMING_SNAKE_CASE_	)
															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.'''	)	)













from ...configuration_utils import PretrainedConfig
class  lowerCAmelCase_       (				snake_case__					):
							UpperCamelCase_		:List[str]		      =    'bert-generation'




							def __init__(   self     :   Tuple ,							SCREAMING_SNAKE_CASE_     :   List[str]=50_358 ,							SCREAMING_SNAKE_CASE_     :   List[Any]=1_024 ,							SCREAMING_SNAKE_CASE_     :   Optional[Any]=24 ,							SCREAMING_SNAKE_CASE_     :   Any=16 ,							SCREAMING_SNAKE_CASE_     :   Tuple=4_096 ,							SCREAMING_SNAKE_CASE_     :   str="gelu" ,							SCREAMING_SNAKE_CASE_     :   List[str]=0.1 ,							SCREAMING_SNAKE_CASE_     :   Tuple=0.1 ,							SCREAMING_SNAKE_CASE_     :   List[Any]=512 ,							SCREAMING_SNAKE_CASE_     :   List[Any]=0.02 ,							SCREAMING_SNAKE_CASE_     :   Union[str, Any]=1e-12 ,							SCREAMING_SNAKE_CASE_     :   List[Any]=0 ,							SCREAMING_SNAKE_CASE_     :   Union[str, Any]=2 ,							SCREAMING_SNAKE_CASE_     :   int=1 ,							SCREAMING_SNAKE_CASE_     :   str="absolute" ,							SCREAMING_SNAKE_CASE_     :   Tuple=True ,							**SCREAMING_SNAKE_CASE_     :   str ,							):
											super().__init__(pad_token_id=SCREAMING_SNAKE_CASE_ ,							bos_token_id=SCREAMING_SNAKE_CASE_ ,							eos_token_id=SCREAMING_SNAKE_CASE_ ,							**SCREAMING_SNAKE_CASE_	)

											lowerCAmelCase__      			=						vocab_size
											lowerCAmelCase__      			=						hidden_size
											lowerCAmelCase__      			=						num_hidden_layers
											lowerCAmelCase__      			=						num_attention_heads
											lowerCAmelCase__      			=						hidden_act
											lowerCAmelCase__      			=						intermediate_size
											lowerCAmelCase__      			=						hidden_dropout_prob
											lowerCAmelCase__      			=						attention_probs_dropout_prob
											lowerCAmelCase__      			=						max_position_embeddings
											lowerCAmelCase__      			=						initializer_range
											lowerCAmelCase__      			=						layer_norm_eps
											lowerCAmelCase__      			=						position_embedding_type
											lowerCAmelCase__      			=						use_cache





