





'''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 lowerCamelCase						(UpperCamelCase_						,      unittest.TestCase					):
  _lowercase  :	str       					=				BertJapaneseTokenizer
  _lowercase  :	Dict       					=				False
  _lowercase  :	Tuple       					=				True







  def 				UpperCAmelCase_				(		self		)		->						Dict:






        """simple docstring"""





        super().setUp()

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

        _snake_case		:	List[Any]					     =     os.path.join(self.tmpdirname     ,     VOCAB_FILES_NAMES['''vocab_file''']		)
        with open(self.vocab_file     ,     '''w'''     ,     encoding='''utf-8'''		) as vocab_writer:
              vocab_writer.write(''''''.join([x + '''\n''' for x in vocab_tokens]		)		)







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






        """simple docstring"""





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







  def 				UpperCAmelCase_				(		self     ,     lowercase__		)		->						Optional[int]:






        """simple docstring"""





        _snake_case		:	List[str]					     =     self.get_input_output_texts(UpperCamelCase__		)
        _snake_case		:	Tuple					     =     tokenizer.encode(UpperCamelCase__     ,     add_special_tokens=UpperCamelCase__		)
        _snake_case		:	Optional[Any]					     =     tokenizer.decode(UpperCamelCase__     ,     clean_up_tokenization_spaces=UpperCamelCase__		)
        return text, ids







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






        """simple docstring"""





        pass  # TODO add if relevant







  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		)		->						str:






        """simple docstring"""





        _snake_case		:	Union[str, Any]					     =     self.tokenizer_class(self.vocab_file		)

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







  def 				UpperCAmelCase_				(		self		)		->						Any:






        """simple docstring"""





        _snake_case		:	Optional[Any]					     =     self.tokenizer_class(self.vocab_file     ,     word_tokenizer_type='''mecab'''		)
        self.assertIsNotNone(UpperCamelCase__		)

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

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

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

        _snake_case		:	List[str]					     =     tokenizer_new.tokenize(UpperCamelCase__		)

        self.assertListEqual(UpperCamelCase__     ,     UpperCamelCase__		)







  def 				UpperCAmelCase_				(		self		)		->						Any:






        """simple docstring"""





        _snake_case		:	str					     =     MecabTokenizer(mecab_dic='''ipadic'''		)

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







  def 				UpperCAmelCase_				(		self		)		->						str:






        """simple docstring"""





        try:
              _snake_case		:	List[str]					     =     MecabTokenizer(mecab_dic='''unidic_lite'''		)
        except ModuleNotFoundError:
              return

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







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






        """simple docstring"""





        try:
              _snake_case		:	Optional[int]					     =     MecabTokenizer(mecab_dic='''unidic'''		)
        except ModuleNotFoundError:
              return

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







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






        """simple docstring"""





        _snake_case		:	List[Any]					     =     MecabTokenizer(do_lower_case=UpperCamelCase__     ,     mecab_dic='''ipadic'''		)

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







  def 				UpperCAmelCase_				(		self		)		->						Any:






        """simple docstring"""





        try:
              _snake_case		:	Dict					     =     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 				UpperCAmelCase_				(		self		)		->						Tuple:






        """simple docstring"""





        _snake_case		:	Any					     =     MecabTokenizer(normalize_text=UpperCamelCase__     ,     mecab_dic='''ipadic'''		)

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







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






        """simple docstring"""





        _snake_case		:	Dict					     =     self.tokenizer_class(self.vocab_file     ,     word_tokenizer_type='''sudachi'''		)
        self.assertIsNotNone(UpperCamelCase__		)

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

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

        with open(UpperCamelCase__     ,     '''rb'''		) as handle:
              _snake_case		:	str					     =     pickle.load(UpperCamelCase__		)

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

        self.assertListEqual(UpperCamelCase__     ,     UpperCamelCase__		)







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






        """simple docstring"""





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

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







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






        """simple docstring"""





        _snake_case		:	Optional[Any]					     =     SudachiTokenizer(sudachi_dict_type='''core'''     ,     sudachi_split_mode='''A'''		)

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







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






        """simple docstring"""





        _snake_case		:	Dict					     =     SudachiTokenizer(sudachi_dict_type='''core'''     ,     sudachi_split_mode='''B'''		)

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







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






        """simple docstring"""





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

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







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






        """simple docstring"""





        _snake_case		:	int					     =     SudachiTokenizer(do_lower_case=UpperCamelCase__     ,     sudachi_dict_type='''core'''		)

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







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






        """simple docstring"""





        _snake_case		:	List[str]					     =     SudachiTokenizer(normalize_text=UpperCamelCase__     ,     sudachi_dict_type='''core'''		)

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







  @require_sudachi
  def 				UpperCAmelCase_				(		self		)		->						Tuple:






        """simple docstring"""





        _snake_case		:	Optional[Any]					     =     SudachiTokenizer(trim_whitespace=UpperCamelCase__     ,     sudachi_dict_type='''core'''		)

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







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






        """simple docstring"""





        _snake_case		:	Dict					     =     self.tokenizer_class(self.vocab_file     ,     word_tokenizer_type='''jumanpp'''		)
        self.assertIsNotNone(UpperCamelCase__		)

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

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

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

        _snake_case		:	int					     =     tokenizer_new.tokenize(UpperCamelCase__		)

        self.assertListEqual(UpperCamelCase__     ,     UpperCamelCase__		)







  @require_jumanpp
  def 				UpperCAmelCase_				(		self		)		->						str:






        """simple docstring"""





        _snake_case		:	str					     =     JumanppTokenizer()

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







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






        """simple docstring"""





        _snake_case		:	str					     =     JumanppTokenizer(do_lower_case=UpperCamelCase__		)

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







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






        """simple docstring"""





        _snake_case		:	int					     =     JumanppTokenizer(normalize_text=UpperCamelCase__		)

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







  @require_jumanpp
  def 				UpperCAmelCase_				(		self		)		->						Any:






        """simple docstring"""





        _snake_case		:	str					     =     JumanppTokenizer(trim_whitespace=UpperCamelCase__		)

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







  @require_jumanpp
  def 				UpperCAmelCase_				(		self		)		->						Tuple:






        """simple docstring"""





        _snake_case		:	Tuple					     =     JumanppTokenizer()

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







  def 				UpperCAmelCase_				(		self		)		->						int:






        """simple docstring"""





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

        _snake_case		:	Any					     =     {}
        for i, token in enumerate(UpperCamelCase__		):
              _snake_case		:	Tuple					     =     i
        _snake_case		:	Optional[int]					     =     WordpieceTokenizer(vocab=UpperCamelCase__     ,     unk_token='''[UNK]'''		)

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

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

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

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







  def 				UpperCAmelCase_				(		self		)		->						Dict:






        """simple docstring"""





        _snake_case		:	Dict					     =     BertJapaneseTokenizer.from_pretrained('''nlp-waseda/roberta-base-japanese-with-auto-jumanpp'''		)
        _snake_case		:	str					     =     tokenizer.subword_tokenizer

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

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







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






        """simple docstring"""





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

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

        _snake_case		:	Optional[Any]					     =     tokenizer.build_inputs_with_special_tokens(UpperCamelCase__		)
        _snake_case		:	Union[str, Any]					     =     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 lowerCamelCase						(UpperCamelCase_						,      unittest.TestCase					):
  _lowercase  :	Optional[Any]       					=				BertJapaneseTokenizer
  _lowercase  :	Optional[Any]       					=				False







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






        """simple docstring"""





        super().setUp()

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

        _snake_case		:	List[Any]					     =     os.path.join(self.tmpdirname     ,     VOCAB_FILES_NAMES['''vocab_file''']		)
        with open(self.vocab_file     ,     '''w'''     ,     encoding='''utf-8'''		) as vocab_writer:
              vocab_writer.write(''''''.join([x + '''\n''' for x in vocab_tokens]		)		)







  def 				UpperCAmelCase_				(		self     ,     **lowercase__		)		->						Any:






        """simple docstring"""





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







  def 				UpperCAmelCase_				(		self     ,     lowercase__		)		->						int:






        """simple docstring"""





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







  def 				UpperCAmelCase_				(		self		)		->						Tuple:






        """simple docstring"""





        pass  # TODO add if relevant







  def 				UpperCAmelCase_				(		self		)		->						str:






        """simple docstring"""





        pass  # TODO add if relevant







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






        """simple docstring"""





        pass  # TODO add if relevant







  def 				UpperCAmelCase_				(		self		)		->						Dict:






        """simple docstring"""





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

        _snake_case		:	Optional[int]					     =     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 				UpperCAmelCase_				(		self		)		->						Union[str, Any]:






        """simple docstring"""





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

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

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

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

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







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






        """simple docstring"""





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

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

        _snake_case		:	Any					     =     tokenizer.build_inputs_with_special_tokens(UpperCamelCase__		)
        _snake_case		:	Any					     =     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 lowerCamelCase						(unittest.TestCase					):







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






        """simple docstring"""





        _snake_case		:	List[Any]					     =     '''cl-tohoku/bert-base-japanese'''
        _snake_case		:	List[Any]					     =     AutoTokenizer.from_pretrained(UpperCamelCase__		)
        self.assertIsInstance(UpperCamelCase__     ,     UpperCamelCase__		)





class lowerCamelCase						(unittest.TestCase					):







  def 				UpperCAmelCase_				(		self		)		->						Tuple:






        """simple docstring"""





        _snake_case		:	Union[str, Any]					     =     '''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.'''		)		)
        _snake_case		:	Dict					     =     '''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.'''		)		)









'''simple docstring'''

from __future__ import annotations

from collections.abc import Callable
from typing import Generic, TypeVar

UpperCAmelCase					:		Any		=							TypeVar('T')
UpperCAmelCase					:		str		=							TypeVar('U')





class lowerCamelCase						(Generic[T, U]					):







  def __init__(		self     ,     lowercase__     ,     lowercase__		)		->						List[Any]:






        """simple docstring"""





        _snake_case		:	str					     =     key
        _snake_case		:	Optional[int]					     =     val
        _snake_case		:	DoubleLinkedListNode[T, U] | None					     =     None
        _snake_case		:	DoubleLinkedListNode[T, U] | None					     =     None







  def __repr__(		self		)		->						str:






        """simple docstring"""





        return (
            F'''Node: key: {self.key}, val: {self.val}, '''
            F'''has next: {bool(self.next		)}, has prev: {bool(self.prev		)}'''
        )





class lowerCamelCase						(Generic[T, U]					):







  def __init__(		self		)		->						None:






        """simple docstring"""





        _snake_case		:	DoubleLinkedListNode[T, U]					     =     DoubleLinkedListNode(lowercase__     ,     lowercase__		)
        _snake_case		:	DoubleLinkedListNode[T, U]					     =     DoubleLinkedListNode(lowercase__     ,     lowercase__		)
        _snake_case     ,							_snake_case		:	Union[str, Any]					     =     self.rear, self.head







  def __repr__(		self		)		->						str:






        """simple docstring"""





        _snake_case		:	List[Any]					     =     ['''DoubleLinkedList''']
        _snake_case		:	str					     =     self.head
        while node.next is not None:
              rep.append(str(lowercase__		)		)
              _snake_case		:	List[str]					     =     node.next
        rep.append(str(self.rear		)		)
        return ",\n    ".join(lowercase__		)







  def 				UpperCAmelCase_				(		self     ,     lowercase__		)		->						None:






        """simple docstring"""





        _snake_case		:	Tuple					     =     self.rear.prev

        # All nodes other than self.head are guaranteed to have non-None previous
        assert previous is not None

        _snake_case		:	Union[str, Any]					     =     node
        _snake_case		:	Optional[Any]					     =     previous
        _snake_case		:	int					     =     node
        _snake_case		:	Union[str, Any]					     =     self.rear







  def 				UpperCAmelCase_				(		self     ,     lowercase__		)		->						DoubleLinkedListNode[T, U] | None:






        """simple docstring"""





        if node.prev is None or node.next is None:
              return None

        _snake_case		:	Optional[int]					     =     node.next
        _snake_case		:	Any					     =     node.prev
        _snake_case		:	List[str]					     =     None
        _snake_case		:	Optional[int]					     =     None
        return node





class lowerCamelCase						(Generic[T, U]					):
  _lowercase  :	dict[Callable[[T], U], LRUCache[T, U]]       					=				{}







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






        """simple docstring"""





        _snake_case		:	DoubleLinkedList[T, U]					     =     DoubleLinkedList()
        _snake_case		:	Union[str, Any]					     =     capacity
        _snake_case		:	int					     =     0
        _snake_case		:	Dict					     =     0
        _snake_case		:	Union[str, Any]					     =     0
        _snake_case		:	dict[T, DoubleLinkedListNode[T, U]]					     =     {}







  def __repr__(		self		)		->						str:






        """simple docstring"""





        return (
            F'''CacheInfo(hits={self.hits}, misses={self.miss}, '''
            F'''capacity={self.capacity}, current size={self.num_keys})'''
        )







  def __contains__(		self     ,     lowercase__		)		->						bool:






        """simple docstring"""





        return key in self.cache







  def 				UpperCAmelCase_				(		self     ,     lowercase__		)		->						U | None:






        """simple docstring"""





        if key in self.cache:
              self.hits += 1
              _snake_case		:	DoubleLinkedListNode[T, U]					     =     self.cache[key]
              _snake_case		:	Tuple					     =     self.list.remove(self.cache[key]		)
              assert node == value_node

              # node is guaranteed not None because it is in self.cache
              assert node is not None
              self.list.add(lowercase__		)
              return node.val
        self.miss += 1
        return None







  def 				UpperCAmelCase_				(		self     ,     lowercase__     ,     lowercase__		)		->						None:






        """simple docstring"""





        if key not in self.cache:
              if self.num_keys >= self.capacity:
                    # delete first node (oldest) when over capacity
                    _snake_case		:	Dict					     =     self.list.head.next

                    # guaranteed to have a non-None first node when num_keys > 0
                    # explain to type checker via assertions
                    assert first_node is not None
                    assert first_node.key is not None
                    assert (
                        self.list.remove(lowercase__		) is not None
                    )  # node guaranteed to be in list assert node.key is not None

                    del self.cache[first_node.key]
                    self.num_keys -= 1
              _snake_case		:	Optional[int]					     =     DoubleLinkedListNode(lowercase__     ,     lowercase__		)
              self.list.add(self.cache[key]		)
              self.num_keys += 1

        else:
              # bump node to the end of the list, update value
              _snake_case		:	Optional[Any]					     =     self.list.remove(self.cache[key]		)
              assert node is not None  # node guaranteed to be in list
              _snake_case		:	Optional[Any]					     =     value
              self.list.add(lowercase__		)







  @classmethod
  def 				UpperCAmelCase_				(		cls     ,     lowercase__ = 128		)		->						Callable[[Callable[[T], U]], Callable[..., U]]:






        """simple docstring"""





        def cache_decorator_inner(lowercase__		) -> Callable[..., U]:
              def cache_decorator_wrapper(*lowercase__		) -> U:
                    if func not in cls.decorator_function_to_instance_map:
                          _snake_case		:	Optional[Any]					     =     LRUCache(lowercase__		)

                    _snake_case		:	Union[str, Any]					     =     cls.decorator_function_to_instance_map[func].get(args[0]		)
                    if result is None:
                          _snake_case		:	Tuple					     =     func(*lowercase__		)
                          cls.decorator_function_to_instance_map[func].put(args[0]     ,     lowercase__		)
                    return result

              def cache_info() -> LRUCache[T, U]:
                    return cls.decorator_function_to_instance_map[func]

              setattr(lowercase__     ,     '''cache_info'''     ,     lowercase__		)  # noqa: B010

              return cache_decorator_wrapper

        return cache_decorator_inner


if __name__ == "__main__":
   import doctest

   doctest.testmod()


