




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






    """simple docstring"""





    lowerCAmelCase        =				BertJapaneseTokenizer
    lowerCAmelCase        =				False
    lowerCAmelCase        =				True





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

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

         UpperCAmelCase_      :							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 							a__				(				self       ,_SCREAMING_SNAKE_CASE  )			->		Optional[int]:
         UpperCAmelCase_      :							Optional[Any]       =      '''こんにちは、世界。 \nこんばんは、世界。'''
         UpperCAmelCase_      :							List[Any]       =      '''こんにちは 、 世界 。 こんばんは 、 世界 。'''
         return input_text, output_text





    def 							a__				(				self       ,_SCREAMING_SNAKE_CASE  )			->		Dict:
         UpperCAmelCase_,   UpperCAmelCase_      :							Dict       =      self.get_input_output_texts(_SCREAMING_SNAKE_CASE  )
         UpperCAmelCase_      :							Any       =      tokenizer.encode(_SCREAMING_SNAKE_CASE       ,add_special_tokens=_SCREAMING_SNAKE_CASE  )
         UpperCAmelCase_      :							Optional[Any]       =      tokenizer.decode(_SCREAMING_SNAKE_CASE       ,clean_up_tokenization_spaces=_SCREAMING_SNAKE_CASE  )
         return text, ids





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





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





    def 							a__				(				self  )			->		List[str]:
         pass  # TODO add if relevant





    def 							a__				(				self  )			->		str:
         UpperCAmelCase_      :							List[Any]       =      self.tokenizer_class(self.vocab_file  )

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





    def 							a__				(				self  )			->		Union[str, Any]:
         UpperCAmelCase_      :							Optional[int]       =      self.tokenizer_class(self.vocab_file       ,word_tokenizer_type='''mecab'''  )
         self.assertIsNotNone(_SCREAMING_SNAKE_CASE  )

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

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

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

         UpperCAmelCase_      :							List[Any]       =      tokenizer_new.tokenize(_SCREAMING_SNAKE_CASE  )

         self.assertListEqual(_SCREAMING_SNAKE_CASE       ,_SCREAMING_SNAKE_CASE  )





    def 							a__				(				self  )			->		Optional[int]:
         UpperCAmelCase_      :							Tuple       =      MecabTokenizer(mecab_dic='''ipadic'''  )

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





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


         try:
              UpperCAmelCase_      :							Optional[int]       =      MecabTokenizer(mecab_dic='''unidic_lite'''  )
         except ModuleNotFoundError:
              return

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





    def 							a__				(				self  )			->		str:


         try:
              UpperCAmelCase_      :							List[Any]       =      MecabTokenizer(mecab_dic='''unidic'''  )
         except ModuleNotFoundError:
              return

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





    def 							a__				(				self  )			->		Dict:
         UpperCAmelCase_      :							List[str]       =      MecabTokenizer(do_lower_case=_SCREAMING_SNAKE_CASE       ,mecab_dic='''ipadic'''  )

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





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


         try:
              UpperCAmelCase_      :							Tuple       =      MecabTokenizer(
                  do_lower_case=_SCREAMING_SNAKE_CASE       ,normalize_text=_SCREAMING_SNAKE_CASE       ,mecab_option='''-d /usr/local/lib/mecab/dic/jumandic'''  )
         except RuntimeError:
              # if dict doesn't exist in the system, previous code raises this error.
              return

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





    def 							a__				(				self  )			->		Any:
         UpperCAmelCase_      :							Tuple       =      MecabTokenizer(normalize_text=_SCREAMING_SNAKE_CASE       ,mecab_dic='''ipadic'''  )

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





    @require_sudachi
    def 							a__				(				self  )			->		Optional[int]:
         UpperCAmelCase_      :							Any       =      self.tokenizer_class(self.vocab_file       ,word_tokenizer_type='''sudachi'''  )
         self.assertIsNotNone(_SCREAMING_SNAKE_CASE  )

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

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

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

         UpperCAmelCase_      :							Union[str, Any]       =      tokenizer_new.tokenize(_SCREAMING_SNAKE_CASE  )

         self.assertListEqual(_SCREAMING_SNAKE_CASE       ,_SCREAMING_SNAKE_CASE  )





    @require_sudachi
    def 							a__				(				self  )			->		Dict:
         UpperCAmelCase_      :							Any       =      SudachiTokenizer(sudachi_dict_type='''core'''  )

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





    @require_sudachi
    def 							a__				(				self  )			->		Dict:
         UpperCAmelCase_      :							Optional[int]       =      SudachiTokenizer(sudachi_dict_type='''core'''       ,sudachi_split_mode='''A'''  )

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





    @require_sudachi
    def 							a__				(				self  )			->		Any:
         UpperCAmelCase_      :							Any       =      SudachiTokenizer(sudachi_dict_type='''core'''       ,sudachi_split_mode='''B'''  )

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





    @require_sudachi
    def 							a__				(				self  )			->		int:
         UpperCAmelCase_      :							int       =      SudachiTokenizer(sudachi_dict_type='''core'''       ,sudachi_split_mode='''C'''  )

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





    @require_sudachi
    def 							a__				(				self  )			->		Tuple:
         UpperCAmelCase_      :							Union[str, Any]       =      SudachiTokenizer(do_lower_case=_SCREAMING_SNAKE_CASE       ,sudachi_dict_type='''core'''  )

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





    @require_sudachi
    def 							a__				(				self  )			->		int:
         UpperCAmelCase_      :							str       =      SudachiTokenizer(normalize_text=_SCREAMING_SNAKE_CASE       ,sudachi_dict_type='''core'''  )

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





    @require_sudachi
    def 							a__				(				self  )			->		Dict:
         UpperCAmelCase_      :							Any       =      SudachiTokenizer(trim_whitespace=_SCREAMING_SNAKE_CASE       ,sudachi_dict_type='''core'''  )

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





    @require_jumanpp
    def 							a__				(				self  )			->		Any:
         UpperCAmelCase_      :							Tuple       =      self.tokenizer_class(self.vocab_file       ,word_tokenizer_type='''jumanpp'''  )
         self.assertIsNotNone(_SCREAMING_SNAKE_CASE  )

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

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

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

         UpperCAmelCase_      :							int       =      tokenizer_new.tokenize(_SCREAMING_SNAKE_CASE  )

         self.assertListEqual(_SCREAMING_SNAKE_CASE       ,_SCREAMING_SNAKE_CASE  )





    @require_jumanpp
    def 							a__				(				self  )			->		List[Any]:
         UpperCAmelCase_      :							List[Any]       =      JumanppTokenizer()

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





    @require_jumanpp
    def 							a__				(				self  )			->		Union[str, Any]:
         UpperCAmelCase_      :							str       =      JumanppTokenizer(do_lower_case=_SCREAMING_SNAKE_CASE  )

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





    @require_jumanpp
    def 							a__				(				self  )			->		str:
         UpperCAmelCase_      :							Any       =      JumanppTokenizer(normalize_text=_SCREAMING_SNAKE_CASE  )

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





    @require_jumanpp
    def 							a__				(				self  )			->		Optional[int]:
         UpperCAmelCase_      :							Optional[Any]       =      JumanppTokenizer(trim_whitespace=_SCREAMING_SNAKE_CASE  )

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





    @require_jumanpp
    def 							a__				(				self  )			->		List[str]:
         UpperCAmelCase_      :							Tuple       =      JumanppTokenizer()

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





    def 							a__				(				self  )			->		str:
         UpperCAmelCase_      :							int       =      ['''[UNK]''', '''[CLS]''', '''[SEP]''', '''こんにちは''', '''こん''', '''にちは''', '''ばんは''', '''##こん''', '''##にちは''', '''##ばんは''']

         UpperCAmelCase_      :							Tuple       =      {}
         for i, token in enumerate(_SCREAMING_SNAKE_CASE  ):
              UpperCAmelCase_      :							Union[str, Any]       =      i
         UpperCAmelCase_      :							Optional[int]       =      WordpieceTokenizer(vocab=_SCREAMING_SNAKE_CASE       ,unk_token='''[UNK]'''  )

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

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

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

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





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

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

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





    def 							a__				(				self  )			->		Dict:
         UpperCAmelCase_      :							Optional[int]       =      self.tokenizer_class.from_pretrained('''cl-tohoku/bert-base-japanese'''  )

         UpperCAmelCase_      :							Optional[int]       =      tokenizer.encode('''ありがとう。'''       ,add_special_tokens=_SCREAMING_SNAKE_CASE  )
         UpperCAmelCase_      :							Dict       =      tokenizer.encode('''どういたしまして。'''       ,add_special_tokens=_SCREAMING_SNAKE_CASE  )

         UpperCAmelCase_      :							Union[str, Any]       =      tokenizer.build_inputs_with_special_tokens(_SCREAMING_SNAKE_CASE  )
         UpperCAmelCase_      :							Optional[Any]       =      tokenizer.build_inputs_with_special_tokens(_SCREAMING_SNAKE_CASE       ,_SCREAMING_SNAKE_CASE  )

         # 2 is for "[CLS]", 3 is for "[SEP]"
         assert encoded_sentence == [2] + text + [3]
         assert encoded_pair == [2] + text + [3] + text_a + [3]


@custom_tokenizers
class   __a(					_lowerCamelCase    ,						unittest.TestCase       ):






    """simple docstring"""





    lowerCAmelCase        =				BertJapaneseTokenizer
    lowerCAmelCase        =				False





    def 							a__				(				self  )			->		int:
         super().setUp()

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

         UpperCAmelCase_      :							List[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 							a__				(				self       ,**_SCREAMING_SNAKE_CASE  )			->		int:
         return BertJapaneseTokenizer.from_pretrained(self.tmpdirname       ,subword_tokenizer_type='''character'''       ,**_SCREAMING_SNAKE_CASE  )





    def 							a__				(				self       ,_SCREAMING_SNAKE_CASE  )			->		Tuple:
         UpperCAmelCase_      :							str       =      '''こんにちは、世界。 \nこんばんは、世界。'''
         UpperCAmelCase_      :							Tuple       =      '''こ ん に ち は 、 世 界 。 こ ん ば ん は 、 世 界 。'''
         return input_text, output_text





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





    def 							a__				(				self  )			->		List[str]:
         pass  # TODO add if relevant





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





    def 							a__				(				self  )			->		Tuple:
         UpperCAmelCase_      :							Any       =      self.tokenizer_class(self.vocab_file       ,subword_tokenizer_type='''character'''  )

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





    def 							a__				(				self  )			->		Union[str, Any]:
         UpperCAmelCase_      :							Union[str, Any]       =      ['''[UNK]''', '''[CLS]''', '''[SEP]''', '''こ''', '''ん''', '''に''', '''ち''', '''は''', '''ば''', '''世''', '''界''', '''、''', '''。''']

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

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

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

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





    def 							a__				(				self  )			->		int:
         UpperCAmelCase_      :							List[str]       =      self.tokenizer_class.from_pretrained('''cl-tohoku/bert-base-japanese-char'''  )

         UpperCAmelCase_      :							Tuple       =      tokenizer.encode('''ありがとう。'''       ,add_special_tokens=_SCREAMING_SNAKE_CASE  )
         UpperCAmelCase_      :							List[str]       =      tokenizer.encode('''どういたしまして。'''       ,add_special_tokens=_SCREAMING_SNAKE_CASE  )

         UpperCAmelCase_      :							Any       =      tokenizer.build_inputs_with_special_tokens(_SCREAMING_SNAKE_CASE  )
         UpperCAmelCase_      :							Dict       =      tokenizer.build_inputs_with_special_tokens(_SCREAMING_SNAKE_CASE       ,_SCREAMING_SNAKE_CASE  )

         # 2 is for "[CLS]", 3 is for "[SEP]"
         assert encoded_sentence == [2] + text + [3]
         assert encoded_pair == [2] + text + [3] + text_a + [3]


@custom_tokenizers
class   __a(					unittest.TestCase       ):






    """simple docstring"""





    def 							a__				(				self  )			->		Any:
         UpperCAmelCase_      :							List[str]       =      '''cl-tohoku/bert-base-japanese'''
         UpperCAmelCase_      :							Tuple       =      AutoTokenizer.from_pretrained(_SCREAMING_SNAKE_CASE  )
         self.assertIsInstance(_SCREAMING_SNAKE_CASE       ,_SCREAMING_SNAKE_CASE  )


class   __a(					unittest.TestCase       ):






    """simple docstring"""





    def 							a__				(				self  )			->		Optional[Any]:
         UpperCAmelCase_      :							Optional[int]       =      '''cl-tohoku/bert-base-japanese'''
         with self.assertLogs('''transformers'''       ,level='''WARNING'''  ) as cm:
              BertTokenizer.from_pretrained(_SCREAMING_SNAKE_CASE  )
              self.assertTrue(
                  cm.records[0].message.startswith(
                      '''The tokenizer class you load from this checkpoint is not the same type as the class this function'''
                      ''' is called from.'''  )  )
         UpperCAmelCase_      :							Optional[Any]       =      '''bert-base-cased'''
         with self.assertLogs('''transformers'''       ,level='''WARNING'''  ) as cm:
              BertJapaneseTokenizer.from_pretrained(_SCREAMING_SNAKE_CASE  )
              self.assertTrue(
                  cm.records[0].message.startswith(
                      '''The tokenizer class you load from this checkpoint is not the same type as the class this function'''
                      ''' is called from.'''  )  )





from math import ceil







def lowerCamelCase__       (      _lowercase = 1001				):

     '''simple docstring'''


     UpperCAmelCase_      :							Optional[Any]       =      1

     for i in range(1			,						int(ceil(n / 2.0				)				)				):
          UpperCAmelCase_      :							List[Any]       =      2 * i + 1
          UpperCAmelCase_      :							Optional[int]       =      2 * i
          UpperCAmelCase_      :							Any       =      total + 4 * odd**2 - 6 * even

     return total


if __name__ == "__main__":
     import sys

     if len(sys.argv) == 1:
          print(solution())
     else:
          try:
               __a          =			int(sys.argv[1])
               print(solution(n))
          except ValueError:
               print('Invalid entry - please enter a number')