






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_     (    __lowercase			, unittest.TestCase      ):






 '''simple docstring'''




 _SCREAMING_SNAKE_CASE				:      Dict			=       BertJapaneseTokenizer
 _SCREAMING_SNAKE_CASE				:      Optional[Any]			=       False
 _SCREAMING_SNAKE_CASE				:      Optional[Any]			=       True


 def 			snake_case__					(						self)			->		Any:

     """simple docstring"""



     super().setUp()

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

     _UpperCAmelCase					:   Optional[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)			->		List[str]:

     """simple docstring"""



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


 def 			snake_case__					(						self				,	_A)			->		Dict:

     """simple docstring"""



     _UpperCAmelCase					:   List[str]      	=					self.get_input_output_texts(_A)
     _UpperCAmelCase					:   Dict      	=					tokenizer.encode(_A				,	add_special_tokens=_A)
     _UpperCAmelCase					:   int      	=					tokenizer.decode(_A				,	clean_up_tokenization_spaces=_A)
     return text, ids


 def 			snake_case__					(						self)			->		int:

     """simple docstring"""



     pass  # TODO add if relevant


 def 			snake_case__					(						self)			->		Tuple:

     """simple docstring"""



     pass  # TODO add if relevant


 def 			snake_case__					(						self)			->		Dict:

     """simple docstring"""



     pass  # TODO add if relevant


 def 			snake_case__					(						self)			->		Dict:

     """simple docstring"""



     _UpperCAmelCase					:   int      	=					self.tokenizer_class(self.vocab_file)

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


 def 			snake_case__					(						self)			->		Dict:

     """simple docstring"""



     _UpperCAmelCase					:   int      	=					self.tokenizer_class(self.vocab_file				,	word_tokenizer_type='''mecab''')
     self.assertIsNotNone(_A)

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

     _UpperCAmelCase					:   Union[str, Any]      	=					os.path.join(self.tmpdirname				,	'''tokenizer.bin''')
     with open(_A				,	'''wb''') as handle:
         pickle.dump(_A				,	_A)

     with open(_A				,	'''rb''') as handle:
         _UpperCAmelCase					:   Any      	=					pickle.load(_A)

     _UpperCAmelCase					:   str      	=					tokenizer_new.tokenize(_A)

     self.assertListEqual(_A				,	_A)


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

     """simple docstring"""



     _UpperCAmelCase					:   int      	=					MecabTokenizer(mecab_dic='''ipadic''')

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


 def 			snake_case__					(						self)			->		str:

     """simple docstring"""



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

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


 def 			snake_case__					(						self)			->		Dict:

     """simple docstring"""



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

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


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

     """simple docstring"""



     _UpperCAmelCase					:   Any      	=					MecabTokenizer(do_lower_case=_A				,	mecab_dic='''ipadic''')

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


 def 			snake_case__					(						self)			->		Any:

     """simple docstring"""



     try:
         _UpperCAmelCase					:   Optional[int]      	=					MecabTokenizer(
             do_lower_case=_A				,	normalize_text=_A				,	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)			->		int:

     """simple docstring"""



     _UpperCAmelCase					:   Union[str, Any]      	=					MecabTokenizer(normalize_text=_A				,	mecab_dic='''ipadic''')

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


 @require_sudachi
 def 			snake_case__					(						self)			->		Dict:

     """simple docstring"""



     _UpperCAmelCase					:   Union[str, Any]      	=					self.tokenizer_class(self.vocab_file				,	word_tokenizer_type='''sudachi''')
     self.assertIsNotNone(_A)

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

     _UpperCAmelCase					:   List[str]      	=					os.path.join(self.tmpdirname				,	'''tokenizer.bin''')
     with open(_A				,	'''wb''') as handle:
         pickle.dump(_A				,	_A)

     with open(_A				,	'''rb''') as handle:
         _UpperCAmelCase					:   int      	=					pickle.load(_A)

     _UpperCAmelCase					:   Any      	=					tokenizer_new.tokenize(_A)

     self.assertListEqual(_A				,	_A)


 @require_sudachi
 def 			snake_case__					(						self)			->		Optional[int]:

     """simple docstring"""



     _UpperCAmelCase					:   Tuple      	=					SudachiTokenizer(sudachi_dict_type='''core''')

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


 @require_sudachi
 def 			snake_case__					(						self)			->		Dict:

     """simple docstring"""



     _UpperCAmelCase					:   List[Any]      	=					SudachiTokenizer(sudachi_dict_type='''core'''				,	sudachi_split_mode='''A''')

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


 @require_sudachi
 def 			snake_case__					(						self)			->		Union[str, Any]:

     """simple docstring"""



     _UpperCAmelCase					:   Any      	=					SudachiTokenizer(sudachi_dict_type='''core'''				,	sudachi_split_mode='''B''')

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


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

     """simple docstring"""



     _UpperCAmelCase					:   List[str]      	=					SudachiTokenizer(sudachi_dict_type='''core'''				,	sudachi_split_mode='''C''')

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


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

     """simple docstring"""



     _UpperCAmelCase					:   Optional[int]      	=					SudachiTokenizer(do_lower_case=_A				,	sudachi_dict_type='''core''')

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


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

     """simple docstring"""



     _UpperCAmelCase					:   Dict      	=					SudachiTokenizer(normalize_text=_A				,	sudachi_dict_type='''core''')

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


 @require_sudachi
 def 			snake_case__					(						self)			->		int:

     """simple docstring"""



     _UpperCAmelCase					:   Optional[int]      	=					SudachiTokenizer(trim_whitespace=_A				,	sudachi_dict_type='''core''')

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


 @require_jumanpp
 def 			snake_case__					(						self)			->		Union[str, Any]:

     """simple docstring"""



     _UpperCAmelCase					:   Union[str, Any]      	=					self.tokenizer_class(self.vocab_file				,	word_tokenizer_type='''jumanpp''')
     self.assertIsNotNone(_A)

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

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

     with open(_A				,	'''rb''') as handle:
         _UpperCAmelCase					:   List[Any]      	=					pickle.load(_A)

     _UpperCAmelCase					:   List[Any]      	=					tokenizer_new.tokenize(_A)

     self.assertListEqual(_A				,	_A)


 @require_jumanpp
 def 			snake_case__					(						self)			->		Union[str, Any]:

     """simple docstring"""



     _UpperCAmelCase					:   Optional[int]      	=					JumanppTokenizer()

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


 @require_jumanpp
 def 			snake_case__					(						self)			->		Tuple:

     """simple docstring"""



     _UpperCAmelCase					:   int      	=					JumanppTokenizer(do_lower_case=_A)

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


 @require_jumanpp
 def 			snake_case__					(						self)			->		Tuple:

     """simple docstring"""



     _UpperCAmelCase					:   int      	=					JumanppTokenizer(normalize_text=_A)

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


 @require_jumanpp
 def 			snake_case__					(						self)			->		int:

     """simple docstring"""



     _UpperCAmelCase					:   int      	=					JumanppTokenizer(trim_whitespace=_A)

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


 @require_jumanpp
 def 			snake_case__					(						self)			->		Union[str, Any]:

     """simple docstring"""



     _UpperCAmelCase					:   Tuple      	=					JumanppTokenizer()

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


 def 			snake_case__					(						self)			->		Any:

     """simple docstring"""



     _UpperCAmelCase					:   Union[str, Any]      	=					['''[UNK]''', '''[CLS]''', '''[SEP]''', '''こんにちは''', '''こん''', '''にちは''', '''ばんは''', '''##こん''', '''##にちは''', '''##ばんは''']

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

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

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

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

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


 def 			snake_case__					(						self)			->		int:

     """simple docstring"""



     _UpperCAmelCase					:   List[Any]      	=					BertJapaneseTokenizer.from_pretrained('''nlp-waseda/roberta-base-japanese-with-auto-jumanpp''')
     _UpperCAmelCase					:   List[str]      	=					tokenizer.subword_tokenizer

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

     _UpperCAmelCase					:   List[Any]      	=					subword_tokenizer.tokenize('''こんばんは こんばん にち は こんにちは''')
     self.assertListEqual(_A				,	['''▁こん''', '''ばん''', '''は''', '''▁こん''', '''ばん''', '''▁に''', '''ち''', '''▁は''', '''▁こんにちは'''])


 def 			snake_case__					(						self)			->		int:

     """simple docstring"""



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

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

     _UpperCAmelCase					:   Any      	=					tokenizer.build_inputs_with_special_tokens(_A)
     _UpperCAmelCase					:   List[str]      	=					tokenizer.build_inputs_with_special_tokens(_A				,	_A)

     # 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_     (    __lowercase			, unittest.TestCase      ):






 '''simple docstring'''




 _SCREAMING_SNAKE_CASE				:      Dict			=       BertJapaneseTokenizer
 _SCREAMING_SNAKE_CASE				:      Tuple			=       False


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

     """simple docstring"""



     super().setUp()

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

     _UpperCAmelCase					:   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)			->		Optional[Any]:

     """simple docstring"""



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


 def 			snake_case__					(						self				,	_A)			->		List[str]:

     """simple docstring"""



     _UpperCAmelCase					:   Optional[int]      	=					'''こんにちは、世界。 \nこんばんは、世界。'''
     _UpperCAmelCase					:   Any      	=					'''こ ん に ち は 、 世 界 。 こ ん ば ん は 、 世 界 。'''
     return input_text, output_text


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

     """simple docstring"""



     pass  # TODO add if relevant


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

     """simple docstring"""



     pass  # TODO add if relevant


 def 			snake_case__					(						self)			->		Any:

     """simple docstring"""



     pass  # TODO add if relevant


 def 			snake_case__					(						self)			->		str:

     """simple docstring"""



     _UpperCAmelCase					:   Tuple      	=					self.tokenizer_class(self.vocab_file				,	subword_tokenizer_type='''character''')

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


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

     """simple docstring"""



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

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

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

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

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


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

     """simple docstring"""



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

     _UpperCAmelCase					:   Tuple      	=					tokenizer.encode('''ありがとう。'''				,	add_special_tokens=_A)
     _UpperCAmelCase					:   Optional[Any]      	=					tokenizer.encode('''どういたしまして。'''				,	add_special_tokens=_A)

     _UpperCAmelCase					:   Tuple      	=					tokenizer.build_inputs_with_special_tokens(_A)
     _UpperCAmelCase					:   Dict      	=					tokenizer.build_inputs_with_special_tokens(_A				,	_A)

     # 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)			->		Optional[int]:

     """simple docstring"""



     _UpperCAmelCase					:   Optional[Any]      	=					'''cl-tohoku/bert-base-japanese'''
     _UpperCAmelCase					:   int      	=					AutoTokenizer.from_pretrained(_A)
     self.assertIsInstance(_A				,	_A)



class 				A_     (    unittest.TestCase      ):






 '''simple docstring'''




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

     """simple docstring"""



     _UpperCAmelCase					:   int      	=					'''cl-tohoku/bert-base-japanese'''
     with self.assertLogs('''transformers'''				,	level='''WARNING''') as cm:
         BertTokenizer.from_pretrained(_A)
         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					:   List[str]      	=					'''bert-base-cased'''
     with self.assertLogs('''transformers'''				,	level='''WARNING''') as cm:
         BertJapaneseTokenizer.from_pretrained(_A)
         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.'''))












'''simple docstring'''





def __UpperCAmelCase   (					A					:			list		)    ->   list:
			if len(A		) <= 1:
						return lst

			UpperCAmelCase_      :       List[str]          =       1

			while i < len(A		):
						if lst[i - 1] <= lst[i]:
									i += 1
						else:
									UpperCAmelCase_    ,      UpperCAmelCase_      :       Dict          =       lst[i], lst[i - 1]
									i -= 1
									if i == 0:
												UpperCAmelCase_      :       Dict          =       1

			return lst


if __name__ == "__main__":
						_UpperCamelCase						:						int  =					input('Enter numbers separated by a comma:\n').strip()
						_UpperCamelCase						:						Union[str, Any]  =					[int(item) for item in user_input.split(',')]
						print(gnome_sort(unsorted))


