
"""simple docstring"""






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 				lowercase__(				_UpperCAmelCase		,						unittest.TestCase   ):
	'''simple docstring'''

	UpperCamelCase				=  BertJapaneseTokenizer
	UpperCamelCase				=  False
	UpperCamelCase				=  True





	def   __lowerCAmelCase (						self    :Any					)							->			str:







			'''simple docstring'''




			super().setUp()

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

			SCREAMING_SNAKE_CASE       :     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   __lowerCAmelCase (						self    :int		, lowerCamelCase_    :Tuple					)							->			Optional[Any]:







			'''simple docstring'''




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





	def   __lowerCAmelCase (						self    :Dict		, lowerCamelCase_    :Union[str, Any]					)							->			Tuple:







			'''simple docstring'''




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





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







			'''simple docstring'''




			pass  # TODO add if relevant





	def   __lowerCAmelCase (						self    :Tuple					)							->			str:







			'''simple docstring'''




			pass  # TODO add if relevant





	def   __lowerCAmelCase (						self    :Dict					)							->			Any:







			'''simple docstring'''




			pass  # TODO add if relevant





	def   __lowerCAmelCase (						self    :Optional[int]					)							->			Union[str, Any]:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     List[Any]				= self.tokenizer_class(self.vocab_file					)

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





	def   __lowerCAmelCase (						self    :Optional[Any]					)							->			List[str]:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     Any				= self.tokenizer_class(self.vocab_file		, word_tokenizer_type='''mecab'''					)
			self.assertIsNotNone(lowerCamelCase_					)

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

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

			with open(lowerCamelCase_		, '''rb'''					) as handle:
					SCREAMING_SNAKE_CASE       :     Dict				= pickle.load(lowerCamelCase_					)

			SCREAMING_SNAKE_CASE       :     int				= tokenizer_new.tokenize(lowerCamelCase_					)

			self.assertListEqual(lowerCamelCase_		, lowerCamelCase_					)





	def   __lowerCAmelCase (						self    :Any					)							->			str:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     Optional[Any]				= MecabTokenizer(mecab_dic='''ipadic'''					)

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





	def   __lowerCAmelCase (						self    :List[str]					)							->			Tuple:







			'''simple docstring'''




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

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





	def   __lowerCAmelCase (						self    :Optional[int]					)							->			List[Any]:







			'''simple docstring'''




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

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





	def   __lowerCAmelCase (						self    :Optional[int]					)							->			str:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     Optional[int]				= MecabTokenizer(do_lower_case=lowerCamelCase_		, mecab_dic='''ipadic'''					)

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





	def   __lowerCAmelCase (						self    :int					)							->			Optional[Any]:







			'''simple docstring'''




			try:
					SCREAMING_SNAKE_CASE       :     str				= 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   __lowerCAmelCase (						self    :int					)							->			List[str]:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     Union[str, Any]				= MecabTokenizer(normalize_text=lowerCamelCase_		, mecab_dic='''ipadic'''					)

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





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







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     int				= self.tokenizer_class(self.vocab_file		, word_tokenizer_type='''sudachi'''					)
			self.assertIsNotNone(lowerCamelCase_					)

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

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

			with open(lowerCamelCase_		, '''rb'''					) as handle:
					SCREAMING_SNAKE_CASE       :     int				= pickle.load(lowerCamelCase_					)

			SCREAMING_SNAKE_CASE       :     Dict				= tokenizer_new.tokenize(lowerCamelCase_					)

			self.assertListEqual(lowerCamelCase_		, lowerCamelCase_					)





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







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     int				= SudachiTokenizer(sudachi_dict_type='''core'''					)

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





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







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     Optional[int]				= SudachiTokenizer(sudachi_dict_type='''core'''		, sudachi_split_mode='''A'''					)

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





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







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     Optional[int]				= SudachiTokenizer(sudachi_dict_type='''core'''		, sudachi_split_mode='''B'''					)

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





	@require_sudachi
	def   __lowerCAmelCase (						self    :Optional[int]					)							->			List[Any]:







			'''simple docstring'''




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

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





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







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     Tuple				= SudachiTokenizer(do_lower_case=lowerCamelCase_		, sudachi_dict_type='''core'''					)

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





	@require_sudachi
	def   __lowerCAmelCase (						self    :str					)							->			str:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     Dict				= SudachiTokenizer(normalize_text=lowerCamelCase_		, sudachi_dict_type='''core'''					)

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





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







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     Optional[Any]				= SudachiTokenizer(trim_whitespace=lowerCamelCase_		, sudachi_dict_type='''core'''					)

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





	@require_jumanpp
	def   __lowerCAmelCase (						self    :Dict					)							->			str:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     int				= self.tokenizer_class(self.vocab_file		, word_tokenizer_type='''jumanpp'''					)
			self.assertIsNotNone(lowerCamelCase_					)

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

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

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

			SCREAMING_SNAKE_CASE       :     str				= tokenizer_new.tokenize(lowerCamelCase_					)

			self.assertListEqual(lowerCamelCase_		, lowerCamelCase_					)





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







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     Dict				= JumanppTokenizer()

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





	@require_jumanpp
	def   __lowerCAmelCase (						self    :Any					)							->			Dict:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     Tuple				= JumanppTokenizer(do_lower_case=lowerCamelCase_					)

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





	@require_jumanpp
	def   __lowerCAmelCase (						self    :Tuple					)							->			str:







			'''simple docstring'''




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

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





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







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     Tuple				= JumanppTokenizer(trim_whitespace=lowerCamelCase_					)

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





	@require_jumanpp
	def   __lowerCAmelCase (						self    :Any					)							->			Optional[Any]:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     Dict				= JumanppTokenizer()

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





	def   __lowerCAmelCase (						self    :int					)							->			int:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     Dict				= ['''[UNK]''', '''[CLS]''', '''[SEP]''', '''こんにちは''', '''こん''', '''にちは''', '''ばんは''', '''##こん''', '''##にちは''', '''##ばんは''']

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

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

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

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

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





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







			'''simple docstring'''




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

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

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







	def   __lowerCAmelCase (						self    :Optional[int]					)							->			Dict:







			'''simple docstring'''




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

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

			SCREAMING_SNAKE_CASE       :     str				= tokenizer.build_inputs_with_special_tokens(lowerCamelCase_					)
			SCREAMING_SNAKE_CASE       :     Tuple				= 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 				lowercase__(				_UpperCAmelCase		,						unittest.TestCase   ):
	'''simple docstring'''

	UpperCamelCase				=  BertJapaneseTokenizer
	UpperCamelCase				=  False





	def   __lowerCAmelCase (						self    :List[str]					)							->			Dict:







			'''simple docstring'''




			super().setUp()

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

			SCREAMING_SNAKE_CASE       :     Tuple				= 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   __lowerCAmelCase (						self    :Tuple		, **lowerCamelCase_    :List[str]					)							->			Tuple:







			'''simple docstring'''




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





	def   __lowerCAmelCase (						self    :Any		, lowerCamelCase_    :Tuple					)							->			str:







			'''simple docstring'''




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





	def   __lowerCAmelCase (						self    :Any					)							->			Tuple:







			'''simple docstring'''




			pass  # TODO add if relevant





	def   __lowerCAmelCase (						self    :int					)							->			Any:







			'''simple docstring'''




			pass  # TODO add if relevant





	def   __lowerCAmelCase (						self    :Optional[Any]					)							->			List[str]:







			'''simple docstring'''




			pass  # TODO add if relevant





	def   __lowerCAmelCase (						self    :Any					)							->			Optional[int]:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     int				= self.tokenizer_class(self.vocab_file		, subword_tokenizer_type='''character'''					)

			SCREAMING_SNAKE_CASE       :     str				= 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   __lowerCAmelCase (						self    :List[str]					)							->			Any:







			'''simple docstring'''




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

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

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

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

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







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







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     Union[str, Any]				= self.tokenizer_class.from_pretrained('''cl-tohoku/bert-base-japanese-char'''					)

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

			SCREAMING_SNAKE_CASE       :     Tuple				= tokenizer.build_inputs_with_special_tokens(lowerCamelCase_					)
			SCREAMING_SNAKE_CASE       :     Tuple				= 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 				lowercase__(				unittest.TestCase   ):
	'''simple docstring'''

	def   __lowerCAmelCase (						self    :Any					)							->			str:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     Any				= '''cl-tohoku/bert-base-japanese'''
			SCREAMING_SNAKE_CASE       :     int				= AutoTokenizer.from_pretrained(lowerCamelCase_					)
			self.assertIsInstance(lowerCamelCase_		, lowerCamelCase_					)





class 				lowercase__(				unittest.TestCase   ):
	'''simple docstring'''

	def   __lowerCAmelCase (						self    :Tuple					)							->			List[str]:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     str				= '''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.'''					)					)
			SCREAMING_SNAKE_CASE       :     List[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.'''					)					)







"""simple docstring"""






import math





def __A						(   a_ :							list		,		a_ :							int     )->							int:




		'''simple docstring'''






		SCREAMING_SNAKE_CASE       :     Optional[int]				= len(a_     )
		SCREAMING_SNAKE_CASE       :     Optional[Any]				= int(math.floor(math.sqrt(a_     )     )     )
		SCREAMING_SNAKE_CASE       :     List[str]				= 0
		while arr[min(a_		,		a_     ) - 1] < x:
				SCREAMING_SNAKE_CASE       :     Optional[Any]				= step
				step += int(math.floor(math.sqrt(a_     )     )     )
				if prev >= n:
						return -1

		while arr[prev] < x:
				SCREAMING_SNAKE_CASE       :     Any				= prev + 1
				if prev == min(a_		,		a_     ):
						return -1
		if arr[prev] == x:
				return prev
		return -1


if __name__ == "__main__":
					lowerCamelCase__ :       Union[str, Any]						     =			input("Enter numbers separated by a comma:\n").strip()
					lowerCamelCase__ :       List[str]						     =			[int(item) for item in user_input.split(",")]
					lowerCamelCase__ :       Dict						     =			int(input("Enter the number to be searched:\n"))
					lowerCamelCase__ :       Tuple						     =			jump_search(arr, x)
					if res == -1:
										print("Number not found!")
					else:
										print(f'''Number {x} is at index {res}''')





