



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



 '''simple docstring'''







 __lowerCamelCase					: str    = BertJapaneseTokenizer
 __lowerCamelCase					: Any    = False
 __lowerCamelCase					: Dict    = True



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


      """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       a__						(self				,     A )					->  List[Any]:


      """simple docstring"""



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



 def       a__						(self				,     A )					->  Optional[int]:


      """simple docstring"""



      _a						,					_a											=						self.get_input_output_texts(A )
      _a											=						tokenizer.encode(A				,     add_special_tokens=A )
      _a											=						tokenizer.decode(A				,     clean_up_tokenization_spaces=A )
      return text, ids



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


      """simple docstring"""



      pass  # TODO add if relevant



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


      """simple docstring"""



      pass  # TODO add if relevant



 def       a__						(self )					->  int:


      """simple docstring"""



      pass  # TODO add if relevant



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


      """simple docstring"""



      _a											=						self.tokenizer_class(self.vocab_file )

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



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


      """simple docstring"""



      _a											=						self.tokenizer_class(self.vocab_file				,     word_tokenizer_type='''mecab''' )
      self.assertIsNotNone(A )

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

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

      with open(A				,     '''rb''' ) as handle:
           _a											=						pickle.load(A )

      _a											=						tokenizer_new.tokenize(A )

      self.assertListEqual(A				,     A )



 def       a__						(self )					->  Tuple:


      """simple docstring"""



      _a											=						MecabTokenizer(mecab_dic='''ipadic''' )

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



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


      """simple docstring"""



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

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



 def       a__						(self )					->  int:


      """simple docstring"""



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

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



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


      """simple docstring"""



      _a											=						MecabTokenizer(do_lower_case=A				,     mecab_dic='''ipadic''' )

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



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


      """simple docstring"""



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

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



 def       a__						(self )					->  Dict:


      """simple docstring"""



      _a											=						MecabTokenizer(normalize_text=A				,     mecab_dic='''ipadic''' )

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



 @require_sudachi
 def       a__						(self )					->  Tuple:


      """simple docstring"""



      _a											=						self.tokenizer_class(self.vocab_file				,     word_tokenizer_type='''sudachi''' )
      self.assertIsNotNone(A )

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

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

      with open(A				,     '''rb''' ) as handle:
           _a											=						pickle.load(A )

      _a											=						tokenizer_new.tokenize(A )

      self.assertListEqual(A				,     A )



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


      """simple docstring"""



      _a											=						SudachiTokenizer(sudachi_dict_type='''core''' )

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



 @require_sudachi
 def       a__						(self )					->  Dict:


      """simple docstring"""



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

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



 @require_sudachi
 def       a__						(self )					->  str:


      """simple docstring"""



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

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



 @require_sudachi
 def       a__						(self )					->  Dict:


      """simple docstring"""



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

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



 @require_sudachi
 def       a__						(self )					->  int:


      """simple docstring"""



      _a											=						SudachiTokenizer(do_lower_case=A				,     sudachi_dict_type='''core''' )

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



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


      """simple docstring"""



      _a											=						SudachiTokenizer(normalize_text=A				,     sudachi_dict_type='''core''' )

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



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


      """simple docstring"""



      _a											=						SudachiTokenizer(trim_whitespace=A				,     sudachi_dict_type='''core''' )

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



 @require_jumanpp
 def       a__						(self )					->  str:


      """simple docstring"""



      _a											=						self.tokenizer_class(self.vocab_file				,     word_tokenizer_type='''jumanpp''' )
      self.assertIsNotNone(A )

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

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

      with open(A				,     '''rb''' ) as handle:
           _a											=						pickle.load(A )

      _a											=						tokenizer_new.tokenize(A )

      self.assertListEqual(A				,     A )



 @require_jumanpp
 def       a__						(self )					->  str:


      """simple docstring"""



      _a											=						JumanppTokenizer()

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



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


      """simple docstring"""



      _a											=						JumanppTokenizer(do_lower_case=A )

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



 @require_jumanpp
 def       a__						(self )					->  Any:


      """simple docstring"""



      _a											=						JumanppTokenizer(normalize_text=A )

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



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


      """simple docstring"""



      _a											=						JumanppTokenizer(trim_whitespace=A )

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



 @require_jumanpp
 def       a__						(self )					->  int:


      """simple docstring"""



      _a											=						JumanppTokenizer()

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



 def       a__						(self )					->  str:


      """simple docstring"""



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

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

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

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

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

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



 def       a__						(self )					->  int:


      """simple docstring"""



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

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

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



 def       a__						(self )					->  str:


      """simple docstring"""



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

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

      _a											=						tokenizer.build_inputs_with_special_tokens(A )
      _a											=						tokenizer.build_inputs_with_special_tokens(A				,     A )

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






@custom_tokenizers
class __A    (						A     ,     unittest.TestCase		):



 '''simple docstring'''







 __lowerCamelCase					: int    = BertJapaneseTokenizer
 __lowerCamelCase					: Optional[int]    = False



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


      """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       a__						(self				,     **A )					->  int:


      """simple docstring"""



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



 def       a__						(self				,     A )					->  str:


      """simple docstring"""



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



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


      """simple docstring"""



      pass  # TODO add if relevant



 def       a__						(self )					->  Dict:


      """simple docstring"""



      pass  # TODO add if relevant



 def       a__						(self )					->  int:


      """simple docstring"""



      pass  # TODO add if relevant



 def       a__						(self )					->  Dict:


      """simple docstring"""



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

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



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


      """simple docstring"""



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

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

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

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

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



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


      """simple docstring"""



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

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

      _a											=						tokenizer.build_inputs_with_special_tokens(A )
      _a											=						tokenizer.build_inputs_with_special_tokens(A				,     A )

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






@custom_tokenizers
class __A    (						unittest.TestCase		):



 '''simple docstring'''







 def       a__						(self )					->  Dict:


      """simple docstring"""



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






class __A    (						unittest.TestCase		):



 '''simple docstring'''







 def       a__						(self )					->  Tuple:


      """simple docstring"""



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








'''simple docstring'''





# This is the module that test_patching.py uses to test patch_submodule()

import os  # noqa: this is just for tests
import os as renamed_os  # noqa: this is just for tests
from os import path  # noqa: this is just for tests
from os import path as renamed_path  # noqa: this is just for tests
from os.path import join  # noqa: this is just for tests
from os.path import join as renamed_join  # noqa: this is just for tests


lowercase_	 =						open  # noqa: we just need to have a builtin inside this module to test it properly



