

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







			'''simple docstring'''

			SCREAMING_SNAKE_CASE     :   List[str]									=				BertJapaneseTokenizer
			SCREAMING_SNAKE_CASE     :   Dict									=				False
			SCREAMING_SNAKE_CASE     :   str									=				True







			def 				snake_case__(     self :				str							)      ->Tuple:
									super().setUp()

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

									snake_case_   =	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 :				Optional[Any]							,   _UpperCamelCase :				List[Any]							)      ->List[str]:
									snake_case_   =	'''こんにちは、世界。 \nこんばんは、世界。'''
									snake_case_   =	'''こんにちは 、 世界 。 こんばんは 、 世界 。'''
									return input_text, output_text







			def 				snake_case__(     self :				Optional[Any]							,   _UpperCamelCase :				Dict							)      ->Tuple:
									snake_case_,    snake_case_   =	self.get_input_output_texts(_UpperCamelCase							)
									snake_case_   =	tokenizer.encode(_UpperCamelCase							,   add_special_tokens=_UpperCamelCase							)
									snake_case_   =	tokenizer.decode(_UpperCamelCase							,   clean_up_tokenization_spaces=_UpperCamelCase							)
									return text, ids







			def 				snake_case__(     self :				Any							)      ->Dict:
									pass  # TODO add if relevant







			def 				snake_case__(     self :				Optional[Any]							)      ->Optional[Any]:
									pass  # TODO add if relevant







			def 				snake_case__(     self :				Optional[Any]							)      ->Any:
									pass  # TODO add if relevant







			def 				snake_case__(     self :				Optional[int]							)      ->int:
									snake_case_   =	self.tokenizer_class(self.vocab_file							)

									snake_case_   =	tokenizer.tokenize('''こんにちは、世界。\nこんばんは、世界。'''							)
									self.assertListEqual(_UpperCamelCase							,   ['''こんにちは''', '''、''', '''世界''', '''。''', '''こん''', '''##ばんは''', '''、''', '''世界''', '''。''']							)
									self.assertListEqual(tokenizer.convert_tokens_to_ids(_UpperCamelCase							)							,   [3, 1_2, 1_0, 1_4, 4, 9, 1_2, 1_0, 1_4]							)







			def 				snake_case__(     self :				Dict							)      ->Any:
									snake_case_   =	self.tokenizer_class(self.vocab_file							,   word_tokenizer_type='''mecab'''							)
									self.assertIsNotNone(_UpperCamelCase							)

									snake_case_   =	'''こんにちは、世界。\nこんばんは、世界。'''
									snake_case_   =	tokenizer.tokenize(_UpperCamelCase							)
									self.assertListEqual(_UpperCamelCase							,   ['''こんにちは''', '''、''', '''世界''', '''。''', '''こん''', '''##ばんは''', '''、''', '''世界''', '''。''']							)
									self.assertListEqual(tokenizer.convert_tokens_to_ids(_UpperCamelCase							)							,   [3, 1_2, 1_0, 1_4, 4, 9, 1_2, 1_0, 1_4]							)

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

									with open(_UpperCamelCase							,   '''rb'''							) as handle:
															snake_case_   =	pickle.load(_UpperCamelCase							)

									snake_case_   =	tokenizer_new.tokenize(_UpperCamelCase							)

									self.assertListEqual(_UpperCamelCase							,   _UpperCamelCase							)







			def 				snake_case__(     self :				List[Any]							)      ->Tuple:
									snake_case_   =	MecabTokenizer(mecab_dic='''ipadic'''							)

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







			def 				snake_case__(     self :				int							)      ->List[Any]:
									try:
															snake_case_   =	MecabTokenizer(mecab_dic='''unidic_lite'''							)
									except ModuleNotFoundError:
															return

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







			def 				snake_case__(     self :				Union[str, Any]							)      ->str:
									try:
															snake_case_   =	MecabTokenizer(mecab_dic='''unidic'''							)
									except ModuleNotFoundError:
															return

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







			def 				snake_case__(     self :				List[str]							)      ->Dict:
									snake_case_   =	MecabTokenizer(do_lower_case=_UpperCamelCase							,   mecab_dic='''ipadic'''							)

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







			def 				snake_case__(     self :				Optional[int]							)      ->List[str]:
									try:
															snake_case_   =	MecabTokenizer(
															    do_lower_case=_UpperCamelCase							,   normalize_text=_UpperCamelCase							,   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]							)      ->Union[str, Any]:
									snake_case_   =	MecabTokenizer(normalize_text=_UpperCamelCase							,   mecab_dic='''ipadic'''							)

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







			@require_sudachi
			def 				snake_case__(     self :				Optional[Any]							)      ->str:
									snake_case_   =	self.tokenizer_class(self.vocab_file							,   word_tokenizer_type='''sudachi'''							)
									self.assertIsNotNone(_UpperCamelCase							)

									snake_case_   =	'''こんにちは、世界。\nこんばんは、世界。'''
									snake_case_   =	tokenizer.tokenize(_UpperCamelCase							)
									self.assertListEqual(_UpperCamelCase							,   ['''こんにちは''', '''、''', '''世界''', '''。''', '''こん''', '''##ばんは''', '''、''', '''世界''', '''。''']							)
									self.assertListEqual(tokenizer.convert_tokens_to_ids(_UpperCamelCase							)							,   [3, 1_2, 1_0, 1_4, 4, 9, 1_2, 1_0, 1_4]							)

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

									with open(_UpperCamelCase							,   '''rb'''							) as handle:
															snake_case_   =	pickle.load(_UpperCamelCase							)

									snake_case_   =	tokenizer_new.tokenize(_UpperCamelCase							)

									self.assertListEqual(_UpperCamelCase							,   _UpperCamelCase							)







			@require_sudachi
			def 				snake_case__(     self :				Tuple							)      ->Optional[int]:
									snake_case_   =	SudachiTokenizer(sudachi_dict_type='''core'''							)

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







			@require_sudachi
			def 				snake_case__(     self :				str							)      ->Tuple:
									snake_case_   =	SudachiTokenizer(sudachi_dict_type='''core'''							,   sudachi_split_mode='''A'''							)

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







			@require_sudachi
			def 				snake_case__(     self :				Dict							)      ->List[Any]:
									snake_case_   =	SudachiTokenizer(sudachi_dict_type='''core'''							,   sudachi_split_mode='''B'''							)

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







			@require_sudachi
			def 				snake_case__(     self :				Optional[int]							)      ->Tuple:
									snake_case_   =	SudachiTokenizer(sudachi_dict_type='''core'''							,   sudachi_split_mode='''C'''							)

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







			@require_sudachi
			def 				snake_case__(     self :				Optional[Any]							)      ->int:
									snake_case_   =	SudachiTokenizer(do_lower_case=_UpperCamelCase							,   sudachi_dict_type='''core'''							)

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







			@require_sudachi
			def 				snake_case__(     self :				Dict							)      ->List[str]:
									snake_case_   =	SudachiTokenizer(normalize_text=_UpperCamelCase							,   sudachi_dict_type='''core'''							)

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







			@require_sudachi
			def 				snake_case__(     self :				List[str]							)      ->List[Any]:
									snake_case_   =	SudachiTokenizer(trim_whitespace=_UpperCamelCase							,   sudachi_dict_type='''core'''							)

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







			@require_jumanpp
			def 				snake_case__(     self :				int							)      ->Union[str, Any]:
									snake_case_   =	self.tokenizer_class(self.vocab_file							,   word_tokenizer_type='''jumanpp'''							)
									self.assertIsNotNone(_UpperCamelCase							)

									snake_case_   =	'''こんにちは、世界。\nこんばんは、世界。'''
									snake_case_   =	tokenizer.tokenize(_UpperCamelCase							)
									self.assertListEqual(_UpperCamelCase							,   ['''こんにちは''', '''、''', '''世界''', '''。''', '''こん''', '''##ばんは''', '''、''', '''世界''', '''。''']							)
									self.assertListEqual(tokenizer.convert_tokens_to_ids(_UpperCamelCase							)							,   [3, 1_2, 1_0, 1_4, 4, 9, 1_2, 1_0, 1_4]							)

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

									with open(_UpperCamelCase							,   '''rb'''							) as handle:
															snake_case_   =	pickle.load(_UpperCamelCase							)

									snake_case_   =	tokenizer_new.tokenize(_UpperCamelCase							)

									self.assertListEqual(_UpperCamelCase							,   _UpperCamelCase							)







			@require_jumanpp
			def 				snake_case__(     self :				List[str]							)      ->Dict:
									snake_case_   =	JumanppTokenizer()

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







			@require_jumanpp
			def 				snake_case__(     self :				Any							)      ->Any:
									snake_case_   =	JumanppTokenizer(do_lower_case=_UpperCamelCase							)

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







			@require_jumanpp
			def 				snake_case__(     self :				int							)      ->Dict:
									snake_case_   =	JumanppTokenizer(normalize_text=_UpperCamelCase							)

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







			@require_jumanpp
			def 				snake_case__(     self :				int							)      ->Optional[Any]:
									snake_case_   =	JumanppTokenizer(trim_whitespace=_UpperCamelCase							)

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







			@require_jumanpp
			def 				snake_case__(     self :				Any							)      ->Optional[int]:
									snake_case_   =	JumanppTokenizer()

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







			def 				snake_case__(     self :				Any							)      ->List[Any]:
									snake_case_   =	['''[UNK]''', '''[CLS]''', '''[SEP]''', '''こんにちは''', '''こん''', '''にちは''', '''ばんは''', '''##こん''', '''##にちは''', '''##ばんは''']

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

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

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

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

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







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

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

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







			def 				snake_case__(     self :				str							)      ->Tuple:
									snake_case_   =	self.tokenizer_class.from_pretrained('''cl-tohoku/bert-base-japanese'''							)

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

									snake_case_   =	tokenizer.build_inputs_with_special_tokens(_UpperCamelCase							)
									snake_case_   =	tokenizer.build_inputs_with_special_tokens(_UpperCamelCase							,   _UpperCamelCase							)

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







			'''simple docstring'''

			SCREAMING_SNAKE_CASE     :   Union[str, Any]									=				BertJapaneseTokenizer
			SCREAMING_SNAKE_CASE     :   int									=				False







			def 				snake_case__(     self :				List[str]							)      ->int:
									super().setUp()

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

									snake_case_   =	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 :				Optional[Any]							,   **_UpperCamelCase :				Union[str, Any]							)      ->int:
									return BertJapaneseTokenizer.from_pretrained(self.tmpdirname							,   subword_tokenizer_type='''character'''							,   **_UpperCamelCase							)







			def 				snake_case__(     self :				Any							,   _UpperCamelCase :				Union[str, Any]							)      ->List[Any]:
									snake_case_   =	'''こんにちは、世界。 \nこんばんは、世界。'''
									snake_case_   =	'''こ ん に ち は 、 世 界 。 こ ん ば ん は 、 世 界 。'''
									return input_text, output_text







			def 				snake_case__(     self :				Dict							)      ->Union[str, Any]:
									pass  # TODO add if relevant







			def 				snake_case__(     self :				Any							)      ->Union[str, Any]:
									pass  # TODO add if relevant







			def 				snake_case__(     self :				Tuple							)      ->Tuple:
									pass  # TODO add if relevant







			def 				snake_case__(     self :				List[Any]							)      ->int:
									snake_case_   =	self.tokenizer_class(self.vocab_file							,   subword_tokenizer_type='''character'''							)

									snake_case_   =	tokenizer.tokenize('''こんにちは、世界。 \nこんばんは、世界。'''							)
									self.assertListEqual(
									    _UpperCamelCase							,   ['''こ''', '''ん''', '''に''', '''ち''', '''は''', '''、''', '''世''', '''界''', '''。''', '''こ''', '''ん''', '''ば''', '''ん''', '''は''', '''、''', '''世''', '''界''', '''。''']							)
									self.assertListEqual(
									    tokenizer.convert_tokens_to_ids(_UpperCamelCase							)							,   [3, 4, 5, 6, 7, 1_1, 9, 1_0, 1_2, 3, 4, 8, 4, 7, 1_1, 9, 1_0, 1_2]							)







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

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

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

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

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







			def 				snake_case__(     self :				Dict							)      ->Tuple:
									snake_case_   =	self.tokenizer_class.from_pretrained('''cl-tohoku/bert-base-japanese-char'''							)

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

									snake_case_   =	tokenizer.build_inputs_with_special_tokens(_UpperCamelCase							)
									snake_case_   =	tokenizer.build_inputs_with_special_tokens(_UpperCamelCase							,   _UpperCamelCase							)

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







			'''simple docstring'''

			def 				snake_case__(     self :				str							)      ->int:
									snake_case_   =	'''cl-tohoku/bert-base-japanese'''
									snake_case_   =	AutoTokenizer.from_pretrained(_UpperCamelCase							)
									self.assertIsInstance(_UpperCamelCase							,   _UpperCamelCase							)






class 	snake_case_   (		unittest.TestCase					):







			'''simple docstring'''

			def 				snake_case__(     self :				Optional[int]							)      ->Dict:
									snake_case_   =	'''cl-tohoku/bert-base-japanese'''
									with self.assertLogs('''transformers'''							,   level='''WARNING'''							) as cm:
															BertTokenizer.from_pretrained(_UpperCamelCase							)
															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.'''							)							)
									snake_case_   =	'''bert-base-cased'''
									with self.assertLogs('''transformers'''							,   level='''WARNING'''							) as cm:
															BertJapaneseTokenizer.from_pretrained(_UpperCamelCase							)
															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 math


def   __SCREAMING_SNAKE_CASE					(SCREAMING_SNAKE_CASE__       ):

						if 1 < number < 4:
												# 2 and 3 are primes
												return True
						elif number < 2 or number % 2 == 0 or number % 3 == 0:
												# Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
												return False

						# All primes number are in format of 6k +/- 1
						for i in range(5  ,		int(math.sqrt(SCREAMING_SNAKE_CASE__       ) + 1       )  ,		6       ):
												if number % i == 0 or number % (i + 2) == 0:
																		return False
						return True


def   __SCREAMING_SNAKE_CASE					(SCREAMING_SNAKE_CASE__ = 10001       ):

						try:
												snake_case_   =	int(SCREAMING_SNAKE_CASE__       )
						except (TypeError, ValueError):
												raise TypeError('''Parameter nth must be int or castable to int.'''       ) from None
						if nth <= 0:
												raise ValueError('''Parameter nth must be greater than or equal to one.'''       )
						snake_case_   =	[]
						snake_case_   =	2
						while len(SCREAMING_SNAKE_CASE__       ) < nth:
												if is_prime(SCREAMING_SNAKE_CASE__       ):
																		primes.append(SCREAMING_SNAKE_CASE__       )
																		num += 1
												else:
																		num += 1
						return primes[len(SCREAMING_SNAKE_CASE__       ) - 1]


if __name__ == "__main__":
					print(f"""{solution() = }""")