





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 			__A       (      a__ ,unittest.TestCase  ):




						"""simple docstring"""







						UpperCAmelCase__						=      BertJapaneseTokenizer
						UpperCAmelCase__						=      False
						UpperCAmelCase__						=      True


						def 				__snake_case			(		self):



													"""simple docstring"""





													super().setUp()

													_lowerCamelCase							:     Optional[Any]	=		[
													    '''[UNK]''',
													    '''[CLS]''',
													    '''[SEP]''',
													    '''こんにちは''',
													    '''こん''',
													    '''にちは''',
													    '''ばんは''',
													    '''##こん''',
													    '''##にちは''',
													    '''##ばんは''',
													    '''世界''',
													    '''##世界''',
													    '''、''',
													    '''##、''',
													    '''。''',
													    '''##。''',
													]

													_lowerCamelCase							:     str	=		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      ,							a__):



													"""simple docstring"""





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


						def 				__snake_case			(		self      ,							a__):



													"""simple docstring"""





													_lowerCamelCase,  _lowerCamelCase							:     str	=		self.get_input_output_texts(lowerCamelCase_)
													_lowerCamelCase							:     List[str]	=		tokenizer.encode(lowerCamelCase_      ,							add_special_tokens=lowerCamelCase_)
													_lowerCamelCase							:     Optional[Any]	=		tokenizer.decode(lowerCamelCase_      ,							clean_up_tokenization_spaces=lowerCamelCase_)
													return text, ids


						def 				__snake_case			(		self):



													"""simple docstring"""





													pass  # TODO add if relevant


						def 				__snake_case			(		self):



													"""simple docstring"""





													pass  # TODO add if relevant


						def 				__snake_case			(		self):



													"""simple docstring"""





													pass  # TODO add if relevant


						def 				__snake_case			(		self):



													"""simple docstring"""





													_lowerCamelCase							:     List[str]	=		self.tokenizer_class(self.vocab_file)

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


						def 				__snake_case			(		self):



													"""simple docstring"""





													_lowerCamelCase							:     Union[str, Any]	=		self.tokenizer_class(self.vocab_file      ,							word_tokenizer_type='''mecab''')
													self.assertIsNotNone(lowerCamelCase_)

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

													_lowerCamelCase							:     Optional[Any]	=		os.path.join(self.tmpdirname      ,							'''tokenizer.bin''')
													with open(lowerCamelCase_      ,							'''wb''') as handle:
																				pickle.dump(lowerCamelCase_      ,							lowerCamelCase_)

													with open(lowerCamelCase_      ,							'''rb''') as handle:
																				_lowerCamelCase							:     Any	=		pickle.load(lowerCamelCase_)

													_lowerCamelCase							:     Union[str, Any]	=		tokenizer_new.tokenize(lowerCamelCase_)

													self.assertListEqual(lowerCamelCase_      ,							lowerCamelCase_)


						def 				__snake_case			(		self):



													"""simple docstring"""





													_lowerCamelCase							:     List[str]	=		MecabTokenizer(mecab_dic='''ipadic''')

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


						def 				__snake_case			(		self):



													"""simple docstring"""





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

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


						def 				__snake_case			(		self):



													"""simple docstring"""





													try:
																				_lowerCamelCase							:     Optional[int]	=		MecabTokenizer(mecab_dic='''unidic''')
													except ModuleNotFoundError:
																				return

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


						def 				__snake_case			(		self):



													"""simple docstring"""





													_lowerCamelCase							:     List[str]	=		MecabTokenizer(do_lower_case=lowerCamelCase_      ,							mecab_dic='''ipadic''')

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


						def 				__snake_case			(		self):



													"""simple docstring"""





													try:
																				_lowerCamelCase							:     Dict	=		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 				__snake_case			(		self):



													"""simple docstring"""





													_lowerCamelCase							:     Tuple	=		MecabTokenizer(normalize_text=lowerCamelCase_      ,							mecab_dic='''ipadic''')

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


						@require_sudachi
						def 				__snake_case			(		self):



													"""simple docstring"""





													_lowerCamelCase							:     Any	=		self.tokenizer_class(self.vocab_file      ,							word_tokenizer_type='''sudachi''')
													self.assertIsNotNone(lowerCamelCase_)

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

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

													with open(lowerCamelCase_      ,							'''rb''') as handle:
																				_lowerCamelCase							:     Union[str, Any]	=		pickle.load(lowerCamelCase_)

													_lowerCamelCase							:     Optional[Any]	=		tokenizer_new.tokenize(lowerCamelCase_)

													self.assertListEqual(lowerCamelCase_      ,							lowerCamelCase_)


						@require_sudachi
						def 				__snake_case			(		self):



													"""simple docstring"""





													_lowerCamelCase							:     Optional[Any]	=		SudachiTokenizer(sudachi_dict_type='''core''')

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


						@require_sudachi
						def 				__snake_case			(		self):



													"""simple docstring"""





													_lowerCamelCase							:     List[str]	=		SudachiTokenizer(sudachi_dict_type='''core'''      ,							sudachi_split_mode='''A''')

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


						@require_sudachi
						def 				__snake_case			(		self):



													"""simple docstring"""





													_lowerCamelCase							:     Union[str, Any]	=		SudachiTokenizer(sudachi_dict_type='''core'''      ,							sudachi_split_mode='''B''')

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


						@require_sudachi
						def 				__snake_case			(		self):



													"""simple docstring"""





													_lowerCamelCase							:     Union[str, Any]	=		SudachiTokenizer(sudachi_dict_type='''core'''      ,							sudachi_split_mode='''C''')

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


						@require_sudachi
						def 				__snake_case			(		self):



													"""simple docstring"""





													_lowerCamelCase							:     List[Any]	=		SudachiTokenizer(do_lower_case=lowerCamelCase_      ,							sudachi_dict_type='''core''')

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


						@require_sudachi
						def 				__snake_case			(		self):



													"""simple docstring"""





													_lowerCamelCase							:     Union[str, Any]	=		SudachiTokenizer(normalize_text=lowerCamelCase_      ,							sudachi_dict_type='''core''')

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


						@require_sudachi
						def 				__snake_case			(		self):



													"""simple docstring"""





													_lowerCamelCase							:     Union[str, Any]	=		SudachiTokenizer(trim_whitespace=lowerCamelCase_      ,							sudachi_dict_type='''core''')

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


						@require_jumanpp
						def 				__snake_case			(		self):



													"""simple docstring"""





													_lowerCamelCase							:     List[str]	=		self.tokenizer_class(self.vocab_file      ,							word_tokenizer_type='''jumanpp''')
													self.assertIsNotNone(lowerCamelCase_)

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

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

													with open(lowerCamelCase_      ,							'''rb''') as handle:
																				_lowerCamelCase							:     Optional[int]	=		pickle.load(lowerCamelCase_)

													_lowerCamelCase							:     Optional[int]	=		tokenizer_new.tokenize(lowerCamelCase_)

													self.assertListEqual(lowerCamelCase_      ,							lowerCamelCase_)


						@require_jumanpp
						def 				__snake_case			(		self):



													"""simple docstring"""





													_lowerCamelCase							:     List[Any]	=		JumanppTokenizer()

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


						@require_jumanpp
						def 				__snake_case			(		self):



													"""simple docstring"""





													_lowerCamelCase							:     List[Any]	=		JumanppTokenizer(do_lower_case=lowerCamelCase_)

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


						@require_jumanpp
						def 				__snake_case			(		self):



													"""simple docstring"""





													_lowerCamelCase							:     List[Any]	=		JumanppTokenizer(normalize_text=lowerCamelCase_)

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


						@require_jumanpp
						def 				__snake_case			(		self):



													"""simple docstring"""





													_lowerCamelCase							:     int	=		JumanppTokenizer(trim_whitespace=lowerCamelCase_)

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


						@require_jumanpp
						def 				__snake_case			(		self):



													"""simple docstring"""





													_lowerCamelCase							:     str	=		JumanppTokenizer()

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


						def 				__snake_case			(		self):



													"""simple docstring"""





													_lowerCamelCase							:     List[Any]	=		['''[UNK]''', '''[CLS]''', '''[SEP]''', '''こんにちは''', '''こん''', '''にちは''', '''ばんは''', '''##こん''', '''##にちは''', '''##ばんは''']

													_lowerCamelCase							:     Optional[int]	=		{}
													for i, token in enumerate(lowerCamelCase_):
																				_lowerCamelCase							:     Optional[int]	=		i
													_lowerCamelCase							:     Optional[int]	=		WordpieceTokenizer(vocab=lowerCamelCase_      ,							unk_token='''[UNK]''')

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

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

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

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


						def 				__snake_case			(		self):



													"""simple docstring"""





													_lowerCamelCase							:     Optional[Any]	=		BertJapaneseTokenizer.from_pretrained('''nlp-waseda/roberta-base-japanese-with-auto-jumanpp''')
													_lowerCamelCase							:     int	=		tokenizer.subword_tokenizer

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

													_lowerCamelCase							:     int	=		subword_tokenizer.tokenize('''こんばんは こんばん にち は こんにちは''')
													self.assertListEqual(lowerCamelCase_      ,							['''▁こん''', '''ばん''', '''は''', '''▁こん''', '''ばん''', '''▁に''', '''ち''', '''▁は''', '''▁こんにちは'''])



						def 				__snake_case			(		self):



													"""simple docstring"""





													_lowerCamelCase							:     Optional[Any]	=		self.tokenizer_class.from_pretrained('''cl-tohoku/bert-base-japanese''')

													_lowerCamelCase							:     Dict	=		tokenizer.encode('''ありがとう。'''      ,							add_special_tokens=lowerCamelCase_)
													_lowerCamelCase							:     int	=		tokenizer.encode('''どういたしまして。'''      ,							add_special_tokens=lowerCamelCase_)

													_lowerCamelCase							:     str	=		tokenizer.build_inputs_with_special_tokens(lowerCamelCase_)
													_lowerCamelCase							:     List[Any]	=		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 			__A       (      a__ ,unittest.TestCase  ):




						"""simple docstring"""







						UpperCAmelCase__						=      BertJapaneseTokenizer
						UpperCAmelCase__						=      False


						def 				__snake_case			(		self):



													"""simple docstring"""





													super().setUp()

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

													_lowerCamelCase							:     List[Any]	=		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      ,							**a__):



													"""simple docstring"""





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


						def 				__snake_case			(		self      ,							a__):



													"""simple docstring"""





													_lowerCamelCase							:     str	=		'''こんにちは、世界。 \nこんばんは、世界。'''
													_lowerCamelCase							:     Any	=		'''こ ん に ち は 、 世 界 。 こ ん ば ん は 、 世 界 。'''
													return input_text, output_text


						def 				__snake_case			(		self):



													"""simple docstring"""





													pass  # TODO add if relevant


						def 				__snake_case			(		self):



													"""simple docstring"""





													pass  # TODO add if relevant


						def 				__snake_case			(		self):



													"""simple docstring"""





													pass  # TODO add if relevant


						def 				__snake_case			(		self):



													"""simple docstring"""





													_lowerCamelCase							:     Dict	=		self.tokenizer_class(self.vocab_file      ,							subword_tokenizer_type='''character''')

													_lowerCamelCase							:     Optional[int]	=		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 				__snake_case			(		self):



													"""simple docstring"""





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

													_lowerCamelCase							:     Any	=		{}
													for i, token in enumerate(lowerCamelCase_):
																				_lowerCamelCase							:     Tuple	=		i
													_lowerCamelCase							:     Any	=		CharacterTokenizer(vocab=lowerCamelCase_      ,							unk_token='''[UNK]''')

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

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

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



						def 				__snake_case			(		self):



													"""simple docstring"""





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

													_lowerCamelCase							:     Tuple	=		tokenizer.encode('''ありがとう。'''      ,							add_special_tokens=lowerCamelCase_)
													_lowerCamelCase							:     Tuple	=		tokenizer.encode('''どういたしまして。'''      ,							add_special_tokens=lowerCamelCase_)

													_lowerCamelCase							:     Optional[Any]	=		tokenizer.build_inputs_with_special_tokens(lowerCamelCase_)
													_lowerCamelCase							:     Optional[int]	=		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 			__A       (      unittest.TestCase  ):




						"""simple docstring"""







						def 				__snake_case			(		self):



													"""simple docstring"""





													_lowerCamelCase							:     List[Any]	=		'''cl-tohoku/bert-base-japanese'''
													_lowerCamelCase							:     List[str]	=		AutoTokenizer.from_pretrained(lowerCamelCase_)
													self.assertIsInstance(lowerCamelCase_      ,							lowerCamelCase_)







class 			__A       (      unittest.TestCase  ):




						"""simple docstring"""







						def 				__snake_case			(		self):



													"""simple docstring"""





													_lowerCamelCase							:     Dict	=		'''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.'''))
													_lowerCamelCase							:     Optional[Any]	=		'''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.'''))








import importlib.util
import os
import platform
from argparse import ArgumentParser

import huggingface_hub

from .. import __version__ as version
from ..utils import (
    is_accelerate_available,
    is_flax_available,
    is_safetensors_available,
    is_tf_available,
    is_torch_available,
)
from . import BaseTransformersCLICommand




def    __UpperCAmelCase(      lowercase_      ):
       return EnvironmentCommand()




def    __UpperCAmelCase(      lowercase_      ):
       return EnvironmentCommand(args.accelerate_config_file      )







class 			__A       (      lowerCamelCase__  ):




      """simple docstring"""







      @staticmethod
      def 				__snake_case			(		a__):



             """simple docstring"""





             _lowerCamelCase							:     List[Any]	=		parser.add_parser('''env''')
             download_parser.set_defaults(func=a__)
             download_parser.add_argument(
                 '''--accelerate-config_file'''      ,							default=a__      ,							help='''The accelerate config file to use for the default values in the launching script.'''      ,							)
             download_parser.set_defaults(func=a__)


      def __init__(		self      ,							a__      ,							*a__):



             """simple docstring"""





             _lowerCamelCase							:     str	=		accelerate_config_file


      def 				__snake_case			(		self):



             """simple docstring"""





             _lowerCamelCase							:     Union[str, Any]	=		'''not installed'''
             if is_safetensors_available():
                    import safetensors

                    _lowerCamelCase							:     Optional[Any]	=		safetensors.__version__
             elif importlib.util.find_spec('''safetensors''') is not None:
                    import safetensors

                    _lowerCamelCase							:     Optional[int]	=		F"""{safetensors.__version__} but is ignored because of PyTorch version too old."""

             _lowerCamelCase							:     Union[str, Any]	=		'''not installed'''
             _lowerCamelCase							:     Any	=		'''not found'''
             if is_accelerate_available():
                    import accelerate
                    from accelerate.commands.config import default_config_file, load_config_from_file

                    _lowerCamelCase							:     Optional[int]	=		accelerate.__version__
                    # Get the default from the config file.
                    if self._accelerate_config_file is not None or os.path.isfile(a__):
                           _lowerCamelCase							:     Optional[int]	=		load_config_from_file(self._accelerate_config_file).to_dict()

                    _lowerCamelCase							:     str	=		(
                        '''\n'''.join([F"""\t- {prop}: {val}""" for prop, val in accelerate_config.items()])
                        if isinstance(a__      ,							a__)
                        else F"""\t{accelerate_config}"""
                    )

             _lowerCamelCase							:     List[Any]	=		'''not installed'''
             _lowerCamelCase							:     Tuple	=		'''NA'''
             if is_torch_available():
                    import torch

                    _lowerCamelCase							:     int	=		torch.__version__
                    _lowerCamelCase							:     List[str]	=		torch.cuda.is_available()

             _lowerCamelCase							:     str	=		'''not installed'''
             _lowerCamelCase							:     Union[str, Any]	=		'''NA'''
             if is_tf_available():
                    import tensorflow as tf

                    _lowerCamelCase							:     List[str]	=		tf.__version__
                    try:
                           # deprecated in v2.1
                           _lowerCamelCase							:     Optional[int]	=		tf.test.is_gpu_available()
                    except AttributeError:
                           # returns list of devices, convert to bool
                           _lowerCamelCase							:     Optional[int]	=		bool(tf.config.list_physical_devices('''GPU'''))

             _lowerCamelCase							:     str	=		'''not installed'''
             _lowerCamelCase							:     List[Any]	=		'''not installed'''
             _lowerCamelCase							:     List[Any]	=		'''not installed'''
             _lowerCamelCase							:     Optional[int]	=		'''NA'''
             if is_flax_available():
                    import flax
                    import jax
                    import jaxlib

                    _lowerCamelCase							:     Any	=		flax.__version__
                    _lowerCamelCase							:     str	=		jax.__version__
                    _lowerCamelCase							:     Any	=		jaxlib.__version__
                    _lowerCamelCase							:     int	=		jax.lib.xla_bridge.get_backend().platform

             _lowerCamelCase							:     int	=		{
                 '''`transformers` version''': version,
                 '''Platform''': platform.platform(),
                 '''Python version''': platform.python_version(),
                 '''Huggingface_hub version''': huggingface_hub.__version__,
                 '''Safetensors version''': F"""{safetensors_version}""",
                 '''Accelerate version''': F"""{accelerate_version}""",
                 '''Accelerate config''': F"""{accelerate_config_str}""",
                 '''PyTorch version (GPU?)''': F"""{pt_version} ({pt_cuda_available})""",
                 '''Tensorflow version (GPU?)''': F"""{tf_version} ({tf_cuda_available})""",
                 '''Flax version (CPU?/GPU?/TPU?)''': F"""{flax_version} ({jax_backend})""",
                 '''Jax version''': F"""{jax_version}""",
                 '''JaxLib version''': F"""{jaxlib_version}""",
                 '''Using GPU in script?''': '''<fill in>''',
                 '''Using distributed or parallel set-up in script?''': '''<fill in>''',
             }

             print('''\nCopy-and-paste the text below in your GitHub issue and FILL OUT the two last points.\n''')
             print(self.format_dict(a__))

             return info



      @staticmethod
      def 				__snake_case			(		a__):



             """simple docstring"""





             return "\n".join([F"""- {prop}: {val}""" for prop, val in d.items()]) + "\n"

