






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






      '''simple docstring'''




      __snake_case       =  BertJapaneseTokenizer
      __snake_case       =  False
      __snake_case       =  True







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




       """simple docstring"""


       super().setUp()

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

       a		  =      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 ,					__UpperCAmelCase      :						Optional[int]  )    ->Union[str, Any]:




       """simple docstring"""


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







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




       """simple docstring"""


       a  ,     a		  =      self.get_input_output_texts(__UpperCAmelCase  )
       a		  =      tokenizer.encode(__UpperCAmelCase ,					add_special_tokens=__UpperCAmelCase  )
       a		  =      tokenizer.decode(__UpperCAmelCase ,					clean_up_tokenization_spaces=__UpperCAmelCase  )
       return text, ids







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




       """simple docstring"""


       pass  # TODO add if relevant







      def       __lowerCAmelCase					(      self      :						int  )    ->int:




       """simple docstring"""


       pass  # TODO add if relevant







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




       """simple docstring"""


       pass  # TODO add if relevant







      def       __lowerCAmelCase					(      self      :						Dict  )    ->Any:




       """simple docstring"""


       a		  =      self.tokenizer_class(self.vocab_file  )

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







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




       """simple docstring"""


       a		  =      self.tokenizer_class(self.vocab_file ,					word_tokenizer_type='''mecab'''  )
       self.assertIsNotNone(__UpperCAmelCase  )

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

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

       with open(__UpperCAmelCase ,					'''rb'''  ) as handle:
        a		  =      pickle.load(__UpperCAmelCase  )

       a		  =      tokenizer_new.tokenize(__UpperCAmelCase  )

       self.assertListEqual(__UpperCAmelCase ,					__UpperCAmelCase  )







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




       """simple docstring"""


       a		  =      MecabTokenizer(mecab_dic='''ipadic'''  )

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







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




       """simple docstring"""


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

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







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




       """simple docstring"""


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

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







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




       """simple docstring"""


       a		  =      MecabTokenizer(do_lower_case=__UpperCAmelCase ,					mecab_dic='''ipadic'''  )

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







      def       __lowerCAmelCase					(      self      :						str  )    ->Tuple:




       """simple docstring"""


       try:
        a		  =      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       __lowerCAmelCase					(      self      :						List[Any]  )    ->Dict:




       """simple docstring"""


       a		  =      MecabTokenizer(normalize_text=__UpperCAmelCase ,					mecab_dic='''ipadic'''  )

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







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




       """simple docstring"""


       a		  =      self.tokenizer_class(self.vocab_file ,					word_tokenizer_type='''sudachi'''  )
       self.assertIsNotNone(__UpperCAmelCase  )

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

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

       with open(__UpperCAmelCase ,					'''rb'''  ) as handle:
        a		  =      pickle.load(__UpperCAmelCase  )

       a		  =      tokenizer_new.tokenize(__UpperCAmelCase  )

       self.assertListEqual(__UpperCAmelCase ,					__UpperCAmelCase  )







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




       """simple docstring"""


       a		  =      SudachiTokenizer(sudachi_dict_type='''core'''  )

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







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




       """simple docstring"""


       a		  =      SudachiTokenizer(sudachi_dict_type='''core''' ,					sudachi_split_mode='''A'''  )

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







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




       """simple docstring"""


       a		  =      SudachiTokenizer(sudachi_dict_type='''core''' ,					sudachi_split_mode='''B'''  )

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







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




       """simple docstring"""


       a		  =      SudachiTokenizer(sudachi_dict_type='''core''' ,					sudachi_split_mode='''C'''  )

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







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




       """simple docstring"""


       a		  =      SudachiTokenizer(do_lower_case=__UpperCAmelCase ,					sudachi_dict_type='''core'''  )

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







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




       """simple docstring"""


       a		  =      SudachiTokenizer(normalize_text=__UpperCAmelCase ,					sudachi_dict_type='''core'''  )

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







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




       """simple docstring"""


       a		  =      SudachiTokenizer(trim_whitespace=__UpperCAmelCase ,					sudachi_dict_type='''core'''  )

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







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




       """simple docstring"""


       a		  =      self.tokenizer_class(self.vocab_file ,					word_tokenizer_type='''jumanpp'''  )
       self.assertIsNotNone(__UpperCAmelCase  )

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

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

       with open(__UpperCAmelCase ,					'''rb'''  ) as handle:
        a		  =      pickle.load(__UpperCAmelCase  )

       a		  =      tokenizer_new.tokenize(__UpperCAmelCase  )

       self.assertListEqual(__UpperCAmelCase ,					__UpperCAmelCase  )







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




       """simple docstring"""


       a		  =      JumanppTokenizer()

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







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




       """simple docstring"""


       a		  =      JumanppTokenizer(do_lower_case=__UpperCAmelCase  )

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







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




       """simple docstring"""


       a		  =      JumanppTokenizer(normalize_text=__UpperCAmelCase  )

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







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




       """simple docstring"""


       a		  =      JumanppTokenizer(trim_whitespace=__UpperCAmelCase  )

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







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




       """simple docstring"""


       a		  =      JumanppTokenizer()

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







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




       """simple docstring"""


       a		  =      ['''[UNK]''', '''[CLS]''', '''[SEP]''', '''こんにちは''', '''こん''', '''にちは''', '''ばんは''', '''##こん''', '''##にちは''', '''##ばんは''']

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

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

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

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

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







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




       """simple docstring"""


       a		  =      BertJapaneseTokenizer.from_pretrained('''nlp-waseda/roberta-base-japanese-with-auto-jumanpp'''  )
       a		  =      tokenizer.subword_tokenizer

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

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







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




       """simple docstring"""


       a		  =      self.tokenizer_class.from_pretrained('''cl-tohoku/bert-base-japanese'''  )

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

       a		  =      tokenizer.build_inputs_with_special_tokens(__UpperCAmelCase  )
       a		  =      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 		lowercase_					(	lowercase ,  unittest.TestCase   ):






      '''simple docstring'''




      __snake_case       =  BertJapaneseTokenizer
      __snake_case       =  False







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




       """simple docstring"""


       super().setUp()

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

       a		  =      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      :						List[str] ,					**__UpperCAmelCase      :						str  )    ->List[Any]:




       """simple docstring"""


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







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




       """simple docstring"""


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







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




       """simple docstring"""


       pass  # TODO add if relevant







      def       __lowerCAmelCase					(      self      :						Tuple  )    ->int:




       """simple docstring"""


       pass  # TODO add if relevant







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




       """simple docstring"""


       pass  # TODO add if relevant







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




       """simple docstring"""


       a		  =      self.tokenizer_class(self.vocab_file ,					subword_tokenizer_type='''character'''  )

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







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




       """simple docstring"""


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

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

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

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

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







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




       """simple docstring"""


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

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

       a		  =      tokenizer.build_inputs_with_special_tokens(__UpperCAmelCase  )
       a		  =      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 		lowercase_					(	unittest.TestCase   ):






      '''simple docstring'''




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




       """simple docstring"""


       a		  =      '''cl-tohoku/bert-base-japanese'''
       a		  =      AutoTokenizer.from_pretrained(__UpperCAmelCase  )
       self.assertIsInstance(__UpperCAmelCase ,					__UpperCAmelCase  )






class 		lowercase_					(	unittest.TestCase   ):






      '''simple docstring'''




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




       """simple docstring"""


       a		  =      '''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.'''  )  )
       a		  =      '''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.'''  )  )










def 						_a    (      a :int )							->			bool:
 a		  =      n ** (1 / 3)
 return (val * val * val) == n


if __name__ == "__main__":
     print(perfect_cube(27))
     print(perfect_cube(4))


