





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

   '''simple docstring'''


   a		:							List[str]     	=	BertJapaneseTokenizer
   a		:							List[str]     	=	False
   a		:							List[Any]     	=	True




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






       """simple docstring"""
       super().setUp()

       UpperCamelCase__							:       List[Any]      =   [
           '''[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    UpperCamelCase__						(					self,	__magic_name__							)				->   List[Any]:






       """simple docstring"""
       UpperCamelCase__							:       Dict      =   '''こんにちは、世界。 \nこんばんは、世界。'''
       UpperCamelCase__							:       str      =   '''こんにちは 、 世界 。 こんばんは 、 世界 。'''
       return input_text, output_text




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






       """simple docstring"""
       UpperCamelCase__     ,UpperCamelCase__							:       List[str]      =   self.get_input_output_texts(__magic_name__							)
       UpperCamelCase__							:       Tuple      =   tokenizer.encode(__magic_name__,	add_special_tokens=__magic_name__							)
       UpperCamelCase__							:       Dict      =   tokenizer.decode(__magic_name__,	clean_up_tokenization_spaces=__magic_name__							)
       return text, ids




   def    UpperCamelCase__						(					self							)				->   int:






       """simple docstring"""
       pass  # TODO add if relevant




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






       """simple docstring"""
       pass  # TODO add if relevant




   def    UpperCamelCase__						(					self							)				->   int:






       """simple docstring"""
       pass  # TODO add if relevant




   def    UpperCamelCase__						(					self							)				->   int:






       """simple docstring"""
       UpperCamelCase__							:       str      =   self.tokenizer_class(self.vocab_file							)

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




   def    UpperCamelCase__						(					self							)				->   Any:






       """simple docstring"""
       UpperCamelCase__							:       List[Any]      =   self.tokenizer_class(self.vocab_file,	word_tokenizer_type='''mecab'''							)
       self.assertIsNotNone(__magic_name__							)

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

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

       with open(__magic_name__,	'''rb'''							) as handle:
           UpperCamelCase__							:       Optional[Any]      =   pickle.load(__magic_name__							)

       UpperCamelCase__							:       int      =   tokenizer_new.tokenize(__magic_name__							)

       self.assertListEqual(__magic_name__,	__magic_name__							)




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






       """simple docstring"""
       UpperCamelCase__							:       List[str]      =   MecabTokenizer(mecab_dic='''ipadic'''							)

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




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






       """simple docstring"""
       try:
           UpperCamelCase__							:       List[Any]      =   MecabTokenizer(mecab_dic='''unidic_lite'''							)
       except ModuleNotFoundError:
           return

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




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






       """simple docstring"""
       try:
           UpperCamelCase__							:       List[Any]      =   MecabTokenizer(mecab_dic='''unidic'''							)
       except ModuleNotFoundError:
           return

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




   def    UpperCamelCase__						(					self							)				->   Tuple:






       """simple docstring"""
       UpperCamelCase__							:       List[Any]      =   MecabTokenizer(do_lower_case=__magic_name__,	mecab_dic='''ipadic'''							)

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




   def    UpperCamelCase__						(					self							)				->   Dict:






       """simple docstring"""
       try:
           UpperCamelCase__							:       Union[str, Any]      =   MecabTokenizer(
               do_lower_case=__magic_name__,	normalize_text=__magic_name__,	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    UpperCamelCase__						(					self							)				->   Optional[Any]:






       """simple docstring"""
       UpperCamelCase__							:       str      =   MecabTokenizer(normalize_text=__magic_name__,	mecab_dic='''ipadic'''							)

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




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






       """simple docstring"""
       UpperCamelCase__							:       Tuple      =   self.tokenizer_class(self.vocab_file,	word_tokenizer_type='''sudachi'''							)
       self.assertIsNotNone(__magic_name__							)

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

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

       with open(__magic_name__,	'''rb'''							) as handle:
           UpperCamelCase__							:       Optional[Any]      =   pickle.load(__magic_name__							)

       UpperCamelCase__							:       Union[str, Any]      =   tokenizer_new.tokenize(__magic_name__							)

       self.assertListEqual(__magic_name__,	__magic_name__							)




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






       """simple docstring"""
       UpperCamelCase__							:       List[Any]      =   SudachiTokenizer(sudachi_dict_type='''core'''							)

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




   @require_sudachi
   def    UpperCamelCase__						(					self							)				->   Dict:






       """simple docstring"""
       UpperCamelCase__							:       Dict      =   SudachiTokenizer(sudachi_dict_type='''core''',	sudachi_split_mode='''A'''							)

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




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






       """simple docstring"""
       UpperCamelCase__							:       Any      =   SudachiTokenizer(sudachi_dict_type='''core''',	sudachi_split_mode='''B'''							)

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




   @require_sudachi
   def    UpperCamelCase__						(					self							)				->   Dict:






       """simple docstring"""
       UpperCamelCase__							:       List[Any]      =   SudachiTokenizer(sudachi_dict_type='''core''',	sudachi_split_mode='''C'''							)

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




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






       """simple docstring"""
       UpperCamelCase__							:       Optional[int]      =   SudachiTokenizer(do_lower_case=__magic_name__,	sudachi_dict_type='''core'''							)

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




   @require_sudachi
   def    UpperCamelCase__						(					self							)				->   Tuple:






       """simple docstring"""
       UpperCamelCase__							:       List[Any]      =   SudachiTokenizer(normalize_text=__magic_name__,	sudachi_dict_type='''core'''							)

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




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






       """simple docstring"""
       UpperCamelCase__							:       Union[str, Any]      =   SudachiTokenizer(trim_whitespace=__magic_name__,	sudachi_dict_type='''core'''							)

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




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






       """simple docstring"""
       UpperCamelCase__							:       Tuple      =   self.tokenizer_class(self.vocab_file,	word_tokenizer_type='''jumanpp'''							)
       self.assertIsNotNone(__magic_name__							)

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

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

       with open(__magic_name__,	'''rb'''							) as handle:
           UpperCamelCase__							:       Tuple      =   pickle.load(__magic_name__							)

       UpperCamelCase__							:       Dict      =   tokenizer_new.tokenize(__magic_name__							)

       self.assertListEqual(__magic_name__,	__magic_name__							)




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






       """simple docstring"""
       UpperCamelCase__							:       Tuple      =   JumanppTokenizer()

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




   @require_jumanpp
   def    UpperCamelCase__						(					self							)				->   str:






       """simple docstring"""
       UpperCamelCase__							:       Dict      =   JumanppTokenizer(do_lower_case=__magic_name__							)

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




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






       """simple docstring"""
       UpperCamelCase__							:       Optional[Any]      =   JumanppTokenizer(normalize_text=__magic_name__							)

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




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






       """simple docstring"""
       UpperCamelCase__							:       List[Any]      =   JumanppTokenizer(trim_whitespace=__magic_name__							)

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




   @require_jumanpp
   def    UpperCamelCase__						(					self							)				->   Dict:






       """simple docstring"""
       UpperCamelCase__							:       List[Any]      =   JumanppTokenizer()

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




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






       """simple docstring"""
       UpperCamelCase__							:       Optional[int]      =   ['''[UNK]''', '''[CLS]''', '''[SEP]''', '''こんにちは''', '''こん''', '''にちは''', '''ばんは''', '''##こん''', '''##にちは''', '''##ばんは''']

       UpperCamelCase__							:       Union[str, Any]      =   {}
       for i, token in enumerate(__magic_name__							):
           UpperCamelCase__							:       Union[str, Any]      =   i
       UpperCamelCase__							:       Optional[Any]      =   WordpieceTokenizer(vocab=__magic_name__,	unk_token='''[UNK]'''							)

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

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

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

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




   def    UpperCamelCase__						(					self							)				->   str:






       """simple docstring"""
       UpperCamelCase__							:       List[str]      =   BertJapaneseTokenizer.from_pretrained('''nlp-waseda/roberta-base-japanese-with-auto-jumanpp'''							)
       UpperCamelCase__							:       Optional[Any]      =   tokenizer.subword_tokenizer

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

       UpperCamelCase__							:       List[str]      =   subword_tokenizer.tokenize('''こんばんは こんばん にち は こんにちは'''							)
       self.assertListEqual(__magic_name__,	['''▁こん''', '''ばん''', '''は''', '''▁こん''', '''ばん''', '''▁に''', '''ち''', '''▁は''', '''▁こんにちは''']							)




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






       """simple docstring"""
       UpperCamelCase__							:       Tuple      =   self.tokenizer_class.from_pretrained('''cl-tohoku/bert-base-japanese'''							)

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

       UpperCamelCase__							:       Any      =   tokenizer.build_inputs_with_special_tokens(__magic_name__							)
       UpperCamelCase__							:       Tuple      =   tokenizer.build_inputs_with_special_tokens(__magic_name__,	__magic_name__							)

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

   '''simple docstring'''


   a		:							Dict     	=	BertJapaneseTokenizer
   a		:							Dict     	=	False




   def    UpperCamelCase__						(					self							)				->   Tuple:






       """simple docstring"""
       super().setUp()

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

       UpperCamelCase__							:       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    UpperCamelCase__						(					self,	**__magic_name__							)				->   Dict:






       """simple docstring"""
       return BertJapaneseTokenizer.from_pretrained(self.tmpdirname,	subword_tokenizer_type='''character''',	**__magic_name__							)




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






       """simple docstring"""
       UpperCamelCase__							:       Tuple      =   '''こんにちは、世界。 \nこんばんは、世界。'''
       UpperCamelCase__							:       Optional[Any]      =   '''こ ん に ち は 、 世 界 。 こ ん ば ん は 、 世 界 。'''
       return input_text, output_text




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






       """simple docstring"""
       pass  # TODO add if relevant




   def    UpperCamelCase__						(					self							)				->   int:






       """simple docstring"""
       pass  # TODO add if relevant




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






       """simple docstring"""
       pass  # TODO add if relevant




   def    UpperCamelCase__						(					self							)				->   Any:






       """simple docstring"""
       UpperCamelCase__							:       Tuple      =   self.tokenizer_class(self.vocab_file,	subword_tokenizer_type='''character'''							)

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




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






       """simple docstring"""
       UpperCamelCase__							:       Dict      =   ['''[UNK]''', '''[CLS]''', '''[SEP]''', '''こ''', '''ん''', '''に''', '''ち''', '''は''', '''ば''', '''世''', '''界''', '''、''', '''。''']

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

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

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

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




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






       """simple docstring"""
       UpperCamelCase__							:       int      =   self.tokenizer_class.from_pretrained('''cl-tohoku/bert-base-japanese-char'''							)

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

       UpperCamelCase__							:       Optional[int]      =   tokenizer.build_inputs_with_special_tokens(__magic_name__							)
       UpperCamelCase__							:       str      =   tokenizer.build_inputs_with_special_tokens(__magic_name__,	__magic_name__							)

       # 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    UpperCamelCase__						(					self							)				->   str:






       """simple docstring"""
       UpperCamelCase__							:       Optional[int]      =   '''cl-tohoku/bert-base-japanese'''
       UpperCamelCase__							:       Dict      =   AutoTokenizer.from_pretrained(__magic_name__							)
       self.assertIsInstance(__magic_name__,	__magic_name__							)






class 					lowercase__ (			unittest.TestCase       ):

   '''simple docstring'''


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






       """simple docstring"""
       UpperCamelCase__							:       Tuple      =   '''cl-tohoku/bert-base-japanese'''
       with self.assertLogs('''transformers''',	level='''WARNING'''							) as cm:
           BertTokenizer.from_pretrained(__magic_name__							)
           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__							:       List[str]      =   '''bert-base-cased'''
       with self.assertLogs('''transformers''',	level='''WARNING'''							) as cm:
           BertJapaneseTokenizer.from_pretrained(__magic_name__							)
           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 typing import TYPE_CHECKING

# rely on isort to merge the imports
from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


UpperCAmelCase_  							=				{
    'configuration_informer': [
        'INFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP',
        'InformerConfig',
    ],
}

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  UpperCAmelCase_  							=				[
      'INFORMER_PRETRAINED_MODEL_ARCHIVE_LIST',
      'InformerForPrediction',
      'InformerModel',
      'InformerPreTrainedModel',
  ]


if TYPE_CHECKING:
  from .configuration_informer import INFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP, InformerConfig

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_informer import (
        INFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
        InformerForPrediction,
        InformerModel,
        InformerPreTrainedModel,
    )

else:
  import sys

  UpperCAmelCase_  							=				_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)

