
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 				SCREAMING_SNAKE_CASE__			(							SCREAMING_SNAKE_CASE_      ,						unittest.TestCase			):

							"""simple docstring"""






							_snake_case   						=     BertJapaneseTokenizer
							_snake_case   						=     False
							_snake_case   						=     True



							def 			A__						(     self	)->      Any:





													'''simple docstring'''






													super().setUp()

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

													__UpperCamelCase        =	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 			A__						(     self   ,		SCREAMING_SNAKE_CASE_	)->      List[str]:





													'''simple docstring'''






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



							def 			A__						(     self   ,		SCREAMING_SNAKE_CASE_	)->      Optional[Any]:





													'''simple docstring'''






													__UpperCamelCase     ,							__UpperCamelCase        =	self.get_input_output_texts(_snake_case	)
													__UpperCamelCase        =	tokenizer.encode(_snake_case   ,		add_special_tokens=_snake_case	)
													__UpperCamelCase        =	tokenizer.decode(_snake_case   ,		clean_up_tokenization_spaces=_snake_case	)
													return text, ids



							def 			A__						(     self	)->      Any:





													'''simple docstring'''






													pass  # TODO add if relevant



							def 			A__						(     self	)->      Optional[Any]:





													'''simple docstring'''






													pass  # TODO add if relevant



							def 			A__						(     self	)->      Tuple:





													'''simple docstring'''






													pass  # TODO add if relevant



							def 			A__						(     self	)->      List[Any]:





													'''simple docstring'''






													__UpperCamelCase        =	self.tokenizer_class(self.vocab_file	)

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



							def 			A__						(     self	)->      List[Any]:





													'''simple docstring'''






													__UpperCamelCase        =	self.tokenizer_class(self.vocab_file   ,		word_tokenizer_type='''mecab'''	)
													self.assertIsNotNone(_snake_case	)

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

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

													with open(_snake_case   ,		'''rb'''	) as handle:
																			__UpperCamelCase        =	pickle.load(_snake_case	)

													__UpperCamelCase        =	tokenizer_new.tokenize(_snake_case	)

													self.assertListEqual(_snake_case   ,		_snake_case	)



							def 			A__						(     self	)->      List[str]:





													'''simple docstring'''






													__UpperCamelCase        =	MecabTokenizer(mecab_dic='''ipadic'''	)

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



							def 			A__						(     self	)->      Any:





													'''simple docstring'''






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

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



							def 			A__						(     self	)->      Optional[Any]:





													'''simple docstring'''






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

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



							def 			A__						(     self	)->      Any:





													'''simple docstring'''






													__UpperCamelCase        =	MecabTokenizer(do_lower_case=_snake_case   ,		mecab_dic='''ipadic'''	)

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



							def 			A__						(     self	)->      Any:





													'''simple docstring'''






													try:
																			__UpperCamelCase        =	MecabTokenizer(
																			    do_lower_case=_snake_case   ,		normalize_text=_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 			A__						(     self	)->      Any:





													'''simple docstring'''






													__UpperCamelCase        =	MecabTokenizer(normalize_text=_snake_case   ,		mecab_dic='''ipadic'''	)

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



							@require_sudachi
							def 			A__						(     self	)->      Optional[Any]:





													'''simple docstring'''






													__UpperCamelCase        =	self.tokenizer_class(self.vocab_file   ,		word_tokenizer_type='''sudachi'''	)
													self.assertIsNotNone(_snake_case	)

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

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

													with open(_snake_case   ,		'''rb'''	) as handle:
																			__UpperCamelCase        =	pickle.load(_snake_case	)

													__UpperCamelCase        =	tokenizer_new.tokenize(_snake_case	)

													self.assertListEqual(_snake_case   ,		_snake_case	)



							@require_sudachi
							def 			A__						(     self	)->      List[Any]:





													'''simple docstring'''






													__UpperCamelCase        =	SudachiTokenizer(sudachi_dict_type='''core'''	)

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



							@require_sudachi
							def 			A__						(     self	)->      List[str]:





													'''simple docstring'''






													__UpperCamelCase        =	SudachiTokenizer(sudachi_dict_type='''core'''   ,		sudachi_split_mode='''A'''	)

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



							@require_sudachi
							def 			A__						(     self	)->      Any:





													'''simple docstring'''






													__UpperCamelCase        =	SudachiTokenizer(sudachi_dict_type='''core'''   ,		sudachi_split_mode='''B'''	)

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



							@require_sudachi
							def 			A__						(     self	)->      str:





													'''simple docstring'''






													__UpperCamelCase        =	SudachiTokenizer(sudachi_dict_type='''core'''   ,		sudachi_split_mode='''C'''	)

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



							@require_sudachi
							def 			A__						(     self	)->      Tuple:





													'''simple docstring'''






													__UpperCamelCase        =	SudachiTokenizer(do_lower_case=_snake_case   ,		sudachi_dict_type='''core'''	)

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



							@require_sudachi
							def 			A__						(     self	)->      str:





													'''simple docstring'''






													__UpperCamelCase        =	SudachiTokenizer(normalize_text=_snake_case   ,		sudachi_dict_type='''core'''	)

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



							@require_sudachi
							def 			A__						(     self	)->      Dict:





													'''simple docstring'''






													__UpperCamelCase        =	SudachiTokenizer(trim_whitespace=_snake_case   ,		sudachi_dict_type='''core'''	)

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



							@require_jumanpp
							def 			A__						(     self	)->      List[str]:





													'''simple docstring'''






													__UpperCamelCase        =	self.tokenizer_class(self.vocab_file   ,		word_tokenizer_type='''jumanpp'''	)
													self.assertIsNotNone(_snake_case	)

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

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

													with open(_snake_case   ,		'''rb'''	) as handle:
																			__UpperCamelCase        =	pickle.load(_snake_case	)

													__UpperCamelCase        =	tokenizer_new.tokenize(_snake_case	)

													self.assertListEqual(_snake_case   ,		_snake_case	)



							@require_jumanpp
							def 			A__						(     self	)->      Dict:





													'''simple docstring'''






													__UpperCamelCase        =	JumanppTokenizer()

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



							@require_jumanpp
							def 			A__						(     self	)->      str:





													'''simple docstring'''






													__UpperCamelCase        =	JumanppTokenizer(do_lower_case=_snake_case	)

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



							@require_jumanpp
							def 			A__						(     self	)->      List[Any]:





													'''simple docstring'''






													__UpperCamelCase        =	JumanppTokenizer(normalize_text=_snake_case	)

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



							@require_jumanpp
							def 			A__						(     self	)->      str:





													'''simple docstring'''






													__UpperCamelCase        =	JumanppTokenizer(trim_whitespace=_snake_case	)

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



							@require_jumanpp
							def 			A__						(     self	)->      Dict:





													'''simple docstring'''






													__UpperCamelCase        =	JumanppTokenizer()

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



							def 			A__						(     self	)->      str:





													'''simple docstring'''






													__UpperCamelCase        =	['''[UNK]''', '''[CLS]''', '''[SEP]''', '''こんにちは''', '''こん''', '''にちは''', '''ばんは''', '''##こん''', '''##にちは''', '''##ばんは''']

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

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

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

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

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



							def 			A__						(     self	)->      Tuple:





													'''simple docstring'''






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

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

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



							def 			A__						(     self	)->      Optional[Any]:





													'''simple docstring'''






													__UpperCamelCase        =	self.tokenizer_class.from_pretrained('''cl-tohoku/bert-base-japanese'''	)

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

													__UpperCamelCase        =	tokenizer.build_inputs_with_special_tokens(_snake_case	)
													__UpperCamelCase        =	tokenizer.build_inputs_with_special_tokens(_snake_case   ,		_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 				SCREAMING_SNAKE_CASE__			(							SCREAMING_SNAKE_CASE_      ,						unittest.TestCase			):

							"""simple docstring"""






							_snake_case   						=     BertJapaneseTokenizer
							_snake_case   						=     False



							def 			A__						(     self	)->      str:





													'''simple docstring'''






													super().setUp()

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

													__UpperCamelCase        =	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 			A__						(     self   ,		**SCREAMING_SNAKE_CASE_	)->      Dict:





													'''simple docstring'''






													return BertJapaneseTokenizer.from_pretrained(self.tmpdirname   ,		subword_tokenizer_type='''character'''   ,		**_snake_case	)



							def 			A__						(     self   ,		SCREAMING_SNAKE_CASE_	)->      Dict:





													'''simple docstring'''






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



							def 			A__						(     self	)->      Optional[Any]:





													'''simple docstring'''






													pass  # TODO add if relevant



							def 			A__						(     self	)->      Optional[int]:





													'''simple docstring'''






													pass  # TODO add if relevant



							def 			A__						(     self	)->      int:





													'''simple docstring'''






													pass  # TODO add if relevant



							def 			A__						(     self	)->      Optional[int]:





													'''simple docstring'''






													__UpperCamelCase        =	self.tokenizer_class(self.vocab_file   ,		subword_tokenizer_type='''character'''	)

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



							def 			A__						(     self	)->      List[str]:





													'''simple docstring'''






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

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

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

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

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



							def 			A__						(     self	)->      str:





													'''simple docstring'''






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

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

													__UpperCamelCase        =	tokenizer.build_inputs_with_special_tokens(_snake_case	)
													__UpperCamelCase        =	tokenizer.build_inputs_with_special_tokens(_snake_case   ,		_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 				SCREAMING_SNAKE_CASE__			(							unittest.TestCase			):

							"""simple docstring"""






							def 			A__						(     self	)->      Union[str, Any]:





													'''simple docstring'''






													__UpperCamelCase        =	'''cl-tohoku/bert-base-japanese'''
													__UpperCamelCase        =	AutoTokenizer.from_pretrained(_snake_case	)
													self.assertIsInstance(_snake_case   ,		_snake_case	)






class 				SCREAMING_SNAKE_CASE__			(							unittest.TestCase			):

							"""simple docstring"""






							def 			A__						(     self	)->      int:





													'''simple docstring'''






													__UpperCamelCase        =	'''cl-tohoku/bert-base-japanese'''
													with self.assertLogs('''transformers'''   ,		level='''WARNING'''	) as cm:
																			BertTokenizer.from_pretrained(_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.'''	)	)
													__UpperCamelCase        =	'''bert-base-cased'''
													with self.assertLogs('''transformers'''   ,		level='''WARNING'''	) as cm:
																			BertJapaneseTokenizer.from_pretrained(_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.'''	)	)










import argparse
import os
import pickle
import sys

import torch

from transformers import TransfoXLConfig, TransfoXLLMHeadModel, load_tf_weights_in_transfo_xl
from transformers.models.transfo_xl import tokenization_transfo_xl as data_utils
from transformers.models.transfo_xl.tokenization_transfo_xl import CORPUS_NAME, VOCAB_FILES_NAMES
from transformers.utils import CONFIG_NAME, WEIGHTS_NAME, logging


logging.set_verbosity_info()

# We do this to be able to load python 2 datasets pickles
# See e.g. https://stackoverflow.com/questions/2121874/python-pickling-after-changing-a-modules-directory/2121918#2121918
snake_case_ : List[Any]    		=       data_utils.TransfoXLTokenizer
snake_case_ : int    		=       data_utils.TransfoXLCorpus
snake_case_ : List[Any]    		=       data_utils
snake_case_ : int    		=       data_utils


def    A						(__A   :    Dict   ,				__A   :    List[Any]   ,				__A   :    Union[str, Any]   ,				__A   :    Tuple       )   ->      Union[str, Any]:







     """simple docstring"""


     if transfo_xl_dataset_file:
          # Convert a pre-processed corpus (see original TensorFlow repo)
          with open(__A   ,				'''rb'''       ) as fp:
               UpperCAmelCase_          =							pickle.load(__A   ,				encoding='''latin1'''       )
          # Save vocabulary and dataset cache as Dictionaries (should be better than pickles for the long-term)
          UpperCAmelCase_          =							pytorch_dump_folder_path + '''/''' + VOCAB_FILES_NAMES['''pretrained_vocab_file''']
          print(F"""Save vocabulary to {pytorch_vocab_dump_path}"""       )
          UpperCAmelCase_          =							corpus.vocab.__dict__
          torch.save(__A   ,				__A       )

          UpperCAmelCase_          =							corpus.__dict__
          corpus_dict_no_vocab.pop('''vocab'''   ,				__A       )
          UpperCAmelCase_          =							pytorch_dump_folder_path + '''/''' + CORPUS_NAME
          print(F"""Save dataset to {pytorch_dataset_dump_path}"""       )
          torch.save(__A   ,				__A       )

     if tf_checkpoint_path:
          # Convert a pre-trained TensorFlow model
          UpperCAmelCase_          =							os.path.abspath(__A       )
          UpperCAmelCase_          =							os.path.abspath(__A       )

          print(F"""Converting Transformer XL checkpoint from {tf_path} with config at {config_path}."""       )
          # Initialise PyTorch model
          if transfo_xl_config_file == "":
               UpperCAmelCase_          =							TransfoXLConfig()
          else:
               UpperCAmelCase_          =							TransfoXLConfig.from_json_file(__A       )
          print(F"""Building PyTorch model from configuration: {config}"""       )
          UpperCAmelCase_          =							TransfoXLLMHeadModel(__A       )

          UpperCAmelCase_          =							load_tf_weights_in_transfo_xl(__A   ,				__A   ,				__A       )
          # Save pytorch-model
          UpperCAmelCase_          =							os.path.join(__A   ,				__A       )
          UpperCAmelCase_          =							os.path.join(__A   ,				__A       )
          print(F"""Save PyTorch model to {os.path.abspath(__A       )}"""       )
          torch.save(model.state_dict()   ,				__A       )
          print(F"""Save configuration file to {os.path.abspath(__A       )}"""       )
          with open(__A   ,				'''w'''   ,				encoding='''utf-8'''       ) as f:
               f.write(config.to_json_string()       )


if __name__ == "__main__":
    snake_case_ : List[str]    		=       argparse.ArgumentParser()
    parser.add_argument(
        "--pytorch_dump_folder_path",
        default=None,
        type=str,
        required=True,
        help="Path to the folder to store the PyTorch model or dataset/vocab.",
    )
    parser.add_argument(
        "--tf_checkpoint_path",
        default="",
        type=str,
        help="An optional path to a TensorFlow checkpoint path to be converted.",
    )
    parser.add_argument(
        "--transfo_xl_config_file",
        default="",
        type=str,
        help=(
            "An optional config json file corresponding to the pre-trained BERT model. \n"
            "This specifies the model architecture."
        ),
    )
    parser.add_argument(
        "--transfo_xl_dataset_file",
        default="",
        type=str,
        help="An optional dataset file to be converted in a vocabulary.",
    )
    snake_case_ : int    		=       parser.parse_args()
    convert_transfo_xl_checkpoint_to_pytorch(
        args.tf_checkpoint_path,
        args.transfo_xl_config_file,
        args.pytorch_dump_folder_path,
        args.transfo_xl_dataset_file,
    )






