






"""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 					snake_case		(							_lowerCAmelCase   ,	unittest.TestCase						):


   '''simple docstring'''

   A_						:	Union[str, Any]						 = BertJapaneseTokenizer
   A_						:	Union[str, Any]						 = False
   A_						:	Optional[int]						 = True


   def 				_SCREAMING_SNAKE_CASE				(	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 				_SCREAMING_SNAKE_CASE				(	self :     Tuple,       _lowerCamelCase :     Dict  ):

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


   def 				_SCREAMING_SNAKE_CASE				(	self :     Dict,       _lowerCamelCase :     Any  ):

     '''simple docstring'''
     __A			,    __A									= self.get_input_output_texts(_lowerCamelCase  )
     __A									= tokenizer.encode(_lowerCamelCase,       add_special_tokens=_lowerCamelCase  )
     __A									= tokenizer.decode(_lowerCamelCase,       clean_up_tokenization_spaces=_lowerCamelCase  )
     return text, ids


   def 				_SCREAMING_SNAKE_CASE				(	self :     Union[str, Any]  ):

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


   def 				_SCREAMING_SNAKE_CASE				(	self :     Tuple  ):

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


   def 				_SCREAMING_SNAKE_CASE				(	self :     int  ):

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


   def 				_SCREAMING_SNAKE_CASE				(	self :     Tuple  ):

     '''simple docstring'''
     __A									= self.tokenizer_class(self.vocab_file  )

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


   def 				_SCREAMING_SNAKE_CASE				(	self :     List[Any]  ):

     '''simple docstring'''
     __A									= self.tokenizer_class(self.vocab_file,       word_tokenizer_type='''mecab'''  )
     self.assertIsNotNone(_lowerCamelCase  )

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

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

     with open(_lowerCamelCase,       '''rb'''  ) as handle:
       __A									= pickle.load(_lowerCamelCase  )

     __A									= tokenizer_new.tokenize(_lowerCamelCase  )

     self.assertListEqual(_lowerCamelCase,       _lowerCamelCase  )


   def 				_SCREAMING_SNAKE_CASE				(	self :     List[str]  ):

     '''simple docstring'''
     __A									= MecabTokenizer(mecab_dic='''ipadic'''  )

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


   def 				_SCREAMING_SNAKE_CASE				(	self :     str  ):

     '''simple docstring'''
     try:
       __A									= MecabTokenizer(mecab_dic='''unidic_lite'''  )
     except ModuleNotFoundError:
       return

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


   def 				_SCREAMING_SNAKE_CASE				(	self :     Optional[Any]  ):

     '''simple docstring'''
     try:
       __A									= MecabTokenizer(mecab_dic='''unidic'''  )
     except ModuleNotFoundError:
       return

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


   def 				_SCREAMING_SNAKE_CASE				(	self :     int  ):

     '''simple docstring'''
     __A									= MecabTokenizer(do_lower_case=_lowerCamelCase,       mecab_dic='''ipadic'''  )

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


   def 				_SCREAMING_SNAKE_CASE				(	self :     List[Any]  ):

     '''simple docstring'''
     try:
       __A									= MecabTokenizer(
           do_lower_case=_lowerCamelCase,       normalize_text=_lowerCamelCase,       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 				_SCREAMING_SNAKE_CASE				(	self :     Optional[int]  ):

     '''simple docstring'''
     __A									= MecabTokenizer(normalize_text=_lowerCamelCase,       mecab_dic='''ipadic'''  )

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


   @require_sudachi
   def 				_SCREAMING_SNAKE_CASE				(	self :     Dict  ):

     '''simple docstring'''
     __A									= self.tokenizer_class(self.vocab_file,       word_tokenizer_type='''sudachi'''  )
     self.assertIsNotNone(_lowerCamelCase  )

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

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

     with open(_lowerCamelCase,       '''rb'''  ) as handle:
       __A									= pickle.load(_lowerCamelCase  )

     __A									= tokenizer_new.tokenize(_lowerCamelCase  )

     self.assertListEqual(_lowerCamelCase,       _lowerCamelCase  )


   @require_sudachi
   def 				_SCREAMING_SNAKE_CASE				(	self :     List[Any]  ):

     '''simple docstring'''
     __A									= SudachiTokenizer(sudachi_dict_type='''core'''  )

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


   @require_sudachi
   def 				_SCREAMING_SNAKE_CASE				(	self :     List[str]  ):

     '''simple docstring'''
     __A									= SudachiTokenizer(sudachi_dict_type='''core''',       sudachi_split_mode='''A'''  )

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


   @require_sudachi
   def 				_SCREAMING_SNAKE_CASE				(	self :     Tuple  ):

     '''simple docstring'''
     __A									= SudachiTokenizer(sudachi_dict_type='''core''',       sudachi_split_mode='''B'''  )

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


   @require_sudachi
   def 				_SCREAMING_SNAKE_CASE				(	self :     Optional[int]  ):

     '''simple docstring'''
     __A									= SudachiTokenizer(sudachi_dict_type='''core''',       sudachi_split_mode='''C'''  )

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


   @require_sudachi
   def 				_SCREAMING_SNAKE_CASE				(	self :     List[str]  ):

     '''simple docstring'''
     __A									= SudachiTokenizer(do_lower_case=_lowerCamelCase,       sudachi_dict_type='''core'''  )

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


   @require_sudachi
   def 				_SCREAMING_SNAKE_CASE				(	self :     Dict  ):

     '''simple docstring'''
     __A									= SudachiTokenizer(normalize_text=_lowerCamelCase,       sudachi_dict_type='''core'''  )

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


   @require_sudachi
   def 				_SCREAMING_SNAKE_CASE				(	self :     str  ):

     '''simple docstring'''
     __A									= SudachiTokenizer(trim_whitespace=_lowerCamelCase,       sudachi_dict_type='''core'''  )

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


   @require_jumanpp
   def 				_SCREAMING_SNAKE_CASE				(	self :     List[str]  ):

     '''simple docstring'''
     __A									= self.tokenizer_class(self.vocab_file,       word_tokenizer_type='''jumanpp'''  )
     self.assertIsNotNone(_lowerCamelCase  )

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

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

     with open(_lowerCamelCase,       '''rb'''  ) as handle:
       __A									= pickle.load(_lowerCamelCase  )

     __A									= tokenizer_new.tokenize(_lowerCamelCase  )

     self.assertListEqual(_lowerCamelCase,       _lowerCamelCase  )


   @require_jumanpp
   def 				_SCREAMING_SNAKE_CASE				(	self :     Optional[Any]  ):

     '''simple docstring'''
     __A									= JumanppTokenizer()

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


   @require_jumanpp
   def 				_SCREAMING_SNAKE_CASE				(	self :     Any  ):

     '''simple docstring'''
     __A									= JumanppTokenizer(do_lower_case=_lowerCamelCase  )

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


   @require_jumanpp
   def 				_SCREAMING_SNAKE_CASE				(	self :     Optional[int]  ):

     '''simple docstring'''
     __A									= JumanppTokenizer(normalize_text=_lowerCamelCase  )

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


   @require_jumanpp
   def 				_SCREAMING_SNAKE_CASE				(	self :     Optional[Any]  ):

     '''simple docstring'''
     __A									= JumanppTokenizer(trim_whitespace=_lowerCamelCase  )

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


   @require_jumanpp
   def 				_SCREAMING_SNAKE_CASE				(	self :     str  ):

     '''simple docstring'''
     __A									= JumanppTokenizer()

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


   def 				_SCREAMING_SNAKE_CASE				(	self :     List[Any]  ):

     '''simple docstring'''
     __A									= ['''[UNK]''', '''[CLS]''', '''[SEP]''', '''こんにちは''', '''こん''', '''にちは''', '''ばんは''', '''##こん''', '''##にちは''', '''##ばんは''']

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

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

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

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

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


   def 				_SCREAMING_SNAKE_CASE				(	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(_lowerCamelCase,       ['''▁国境''', '''▁の''', '''▁長い''', '''▁トンネル''', '''▁を''', '''▁抜ける''', '''▁と''', '''▁雪''', '''国''', '''▁であった''', '''▁。''']  )

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






   def 				_SCREAMING_SNAKE_CASE				(	self :     Union[str, Any]  ):

     '''simple docstring'''
     __A									= self.tokenizer_class.from_pretrained('''cl-tohoku/bert-base-japanese'''  )

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

     __A									= tokenizer.build_inputs_with_special_tokens(_lowerCamelCase  )
     __A									= tokenizer.build_inputs_with_special_tokens(_lowerCamelCase,       _lowerCamelCase  )

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


   '''simple docstring'''

   A_						:	int						 = BertJapaneseTokenizer
   A_						:	Optional[Any]						 = False


   def 				_SCREAMING_SNAKE_CASE				(	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 				_SCREAMING_SNAKE_CASE				(	self :     Dict,       **_lowerCamelCase :     Any  ):

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


   def 				_SCREAMING_SNAKE_CASE				(	self :     Any,       _lowerCamelCase :     Dict  ):

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


   def 				_SCREAMING_SNAKE_CASE				(	self :     Union[str, Any]  ):

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


   def 				_SCREAMING_SNAKE_CASE				(	self :     int  ):

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


   def 				_SCREAMING_SNAKE_CASE				(	self :     Tuple  ):

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


   def 				_SCREAMING_SNAKE_CASE				(	self :     Union[str, Any]  ):

     '''simple docstring'''
     __A									= self.tokenizer_class(self.vocab_file,       subword_tokenizer_type='''character'''  )

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


   def 				_SCREAMING_SNAKE_CASE				(	self :     Union[str, Any]  ):

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

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

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

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

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






   def 				_SCREAMING_SNAKE_CASE				(	self :     str  ):

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

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

     __A									= tokenizer.build_inputs_with_special_tokens(_lowerCamelCase  )
     __A									= tokenizer.build_inputs_with_special_tokens(_lowerCamelCase,       _lowerCamelCase  )

     # 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 					snake_case		(							unittest.TestCase						):


   '''simple docstring'''

   def 				_SCREAMING_SNAKE_CASE				(	self :     Optional[int]  ):

     '''simple docstring'''
     __A									= '''cl-tohoku/bert-base-japanese'''
     __A									= AutoTokenizer.from_pretrained(_lowerCamelCase  )
     self.assertIsInstance(_lowerCamelCase,       _lowerCamelCase  )





class 					snake_case		(							unittest.TestCase						):


   '''simple docstring'''

   def 				_SCREAMING_SNAKE_CASE				(	self :     int  ):

     '''simple docstring'''
     __A									= '''cl-tohoku/bert-base-japanese'''
     with self.assertLogs('''transformers''',       level='''WARNING'''  ) as cm:
       BertTokenizer.from_pretrained(_lowerCamelCase  )
       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(_lowerCamelCase  )
       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"""


import os
import sys
from contextlib import contextmanager


# Windows only
if os.name == "nt":
       import ctypes
       import msvcrt  # noqa


       class 					snake_case		(							ctypes.Structure						):


          '''simple docstring'''

          A_						:	List[str]						 = [("size", ctypes.c_int), ("visible", ctypes.c_byte)]



def 					lowerCAmelCase				(    ):




  """simple docstring"""







  if os.name == "nt":
    __A									= CursorInfo()
    __A									= ctypes.windll.kernelaa.GetStdHandle(-1_1 )
    ctypes.windll.kernelaa.GetConsoleCursorInfo(__UpperCamelCase		,       ctypes.byref(__UpperCamelCase ) )
    __A									= False
    ctypes.windll.kernelaa.SetConsoleCursorInfo(__UpperCamelCase		,       ctypes.byref(__UpperCamelCase ) )
  elif os.name == "posix":
    sys.stdout.write('''\033[?25l''' )
    sys.stdout.flush()



def 					lowerCAmelCase				(    ):




  """simple docstring"""







  if os.name == "nt":
    __A									= CursorInfo()
    __A									= ctypes.windll.kernelaa.GetStdHandle(-1_1 )
    ctypes.windll.kernelaa.GetConsoleCursorInfo(__UpperCamelCase		,       ctypes.byref(__UpperCamelCase ) )
    __A									= True
    ctypes.windll.kernelaa.SetConsoleCursorInfo(__UpperCamelCase		,       ctypes.byref(__UpperCamelCase ) )
  elif os.name == "posix":
    sys.stdout.write('''\033[?25h''' )
    sys.stdout.flush()





@contextmanager
def 					lowerCAmelCase				(    ):




  """simple docstring"""







  try:
    hide_cursor()
    yield
  finally:
    show_cursor()




