




'''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   ):
							lowercase_          =    BertJapaneseTokenizer
							lowercase_          =    False
							lowercase_          =    True







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


														"""simple docstring"""


														super().setUp()

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

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







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


														"""simple docstring"""


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







							def        __lowerCAmelCase      (  self	:  Optional[Any]							,      lowerCAmelCase_	:  List[str] )      ->							Tuple:


														"""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        __lowerCAmelCase      (  self	:  Tuple )      ->							Tuple:


														"""simple docstring"""


														pass  # TODO add if relevant







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


														"""simple docstring"""


														pass  # TODO add if relevant







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


														"""simple docstring"""


														pass  # TODO add if relevant







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


														"""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        __lowerCAmelCase      (  self	:  List[Any] )      ->							Union[str, 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        __lowerCAmelCase      (  self	:  str )      ->							int:


														"""simple docstring"""


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

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







							def        __lowerCAmelCase      (  self	:  Dict )      ->							Dict:


														"""simple docstring"""


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

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







							def        __lowerCAmelCase      (  self	:  str )      ->							Tuple:


														"""simple docstring"""


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

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







							def        __lowerCAmelCase      (  self	:  Tuple )      ->							str:


														"""simple docstring"""


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

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







							def        __lowerCAmelCase      (  self	:  Dict )      ->							int:


														"""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        __lowerCAmelCase      (  self	:  Optional[Any] )      ->							str:


														"""simple docstring"""


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

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







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


														"""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        __lowerCAmelCase      (  self	:  List[str] )      ->							Union[str, Any]:


														"""simple docstring"""


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

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







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


														"""simple docstring"""


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

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







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


														"""simple docstring"""


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

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







							@require_sudachi
							def        __lowerCAmelCase      (  self	:  Any )      ->							int:


														"""simple docstring"""


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

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







							@require_sudachi
							def        __lowerCAmelCase      (  self	:  Dict )      ->							Dict:


														"""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        __lowerCAmelCase      (  self	:  str )      ->							List[str]:


														"""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        __lowerCAmelCase      (  self	:  List[str] )      ->							Optional[int]:


														"""simple docstring"""


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

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







							@require_jumanpp
							def        __lowerCAmelCase      (  self	:  Dict )      ->							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        __lowerCAmelCase      (  self	:  Optional[int] )      ->							int:


														"""simple docstring"""


														_a     					=    JumanppTokenizer()

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







							@require_jumanpp
							def        __lowerCAmelCase      (  self	:  str )      ->							Union[str, 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        __lowerCAmelCase      (  self	:  Tuple )      ->							int:


														"""simple docstring"""


														_a     					=    JumanppTokenizer(normalize_text=lowerCAmelCase_ )

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







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


														"""simple docstring"""


														_a     					=    JumanppTokenizer(trim_whitespace=lowerCAmelCase_ )

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







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


														"""simple docstring"""


														_a     					=    JumanppTokenizer()

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







							def        __lowerCAmelCase      (  self	:  int )      ->							Tuple:


														"""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        __lowerCAmelCase      (  self	:  Optional[int] )      ->							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        __lowerCAmelCase      (  self	:  Optional[Any] )      ->							Optional[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       A   (		_a					,unittest.TestCase   ):
							lowercase_          =    BertJapaneseTokenizer
							lowercase_          =    False







							def        __lowerCAmelCase      (  self	:  int )      ->							str:


														"""simple docstring"""


														super().setUp()

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

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







							def        __lowerCAmelCase      (  self	:  str							,      **lowerCAmelCase_	:  Optional[Any] )      ->							Dict:


														"""simple docstring"""


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







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


														"""simple docstring"""


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







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


														"""simple docstring"""


														pass  # TODO add if relevant







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


														"""simple docstring"""


														pass  # TODO add if relevant







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


														"""simple docstring"""


														pass  # TODO add if relevant







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


														"""simple docstring"""


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

														_a     					=    tokenizer.tokenize('''こんにちは、世界。 \nこんばんは、世界。''' )
														self.assertListEqual(
														    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        __lowerCAmelCase      (  self	:  List[Any] )      ->							Tuple:


														"""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        __lowerCAmelCase      (  self	:  Tuple )      ->							Union[str, Any]:


														"""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       A   (		unittest.TestCase   ):







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


														"""simple docstring"""


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



class       A   (		unittest.TestCase   ):







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


														"""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'''


from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_sentencepiece_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


_snake_case				:				Dict       							=		{
    'configuration_albert': ['ALBERT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'AlbertConfig', 'AlbertOnnxConfig'],
}

try:
				if not is_sentencepiece_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				_snake_case				:				Optional[int]       							=		['AlbertTokenizer']

try:
				if not is_tokenizers_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				_snake_case				:				str       							=		['AlbertTokenizerFast']

try:
				if not is_torch_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				_snake_case				:				str       							=		[
				    'ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST',
				    'AlbertForMaskedLM',
				    'AlbertForMultipleChoice',
				    'AlbertForPreTraining',
				    'AlbertForQuestionAnswering',
				    'AlbertForSequenceClassification',
				    'AlbertForTokenClassification',
				    'AlbertModel',
				    'AlbertPreTrainedModel',
				    'load_tf_weights_in_albert',
				]

try:
				if not is_tf_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				_snake_case				:				Any       							=		[
				    'TF_ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST',
				    'TFAlbertForMaskedLM',
				    'TFAlbertForMultipleChoice',
				    'TFAlbertForPreTraining',
				    'TFAlbertForQuestionAnswering',
				    'TFAlbertForSequenceClassification',
				    'TFAlbertForTokenClassification',
				    'TFAlbertMainLayer',
				    'TFAlbertModel',
				    'TFAlbertPreTrainedModel',
				]

try:
				if not is_flax_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				_snake_case				:				Any       							=		[
				    'FlaxAlbertForMaskedLM',
				    'FlaxAlbertForMultipleChoice',
				    'FlaxAlbertForPreTraining',
				    'FlaxAlbertForQuestionAnswering',
				    'FlaxAlbertForSequenceClassification',
				    'FlaxAlbertForTokenClassification',
				    'FlaxAlbertModel',
				    'FlaxAlbertPreTrainedModel',
				]

if TYPE_CHECKING:
				from .configuration_albert import ALBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, AlbertConfig, AlbertOnnxConfig

				try:
								if not is_sentencepiece_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .tokenization_albert import AlbertTokenizer

				try:
								if not is_tokenizers_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .tokenization_albert_fast import AlbertTokenizerFast

				try:
								if not is_torch_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_albert import (
								    ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
								    AlbertForMaskedLM,
								    AlbertForMultipleChoice,
								    AlbertForPreTraining,
								    AlbertForQuestionAnswering,
								    AlbertForSequenceClassification,
								    AlbertForTokenClassification,
								    AlbertModel,
								    AlbertPreTrainedModel,
								    load_tf_weights_in_albert,
								)

				try:
								if not is_tf_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_tf_albert import (
								    TF_ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
								    TFAlbertForMaskedLM,
								    TFAlbertForMultipleChoice,
								    TFAlbertForPreTraining,
								    TFAlbertForQuestionAnswering,
								    TFAlbertForSequenceClassification,
								    TFAlbertForTokenClassification,
								    TFAlbertMainLayer,
								    TFAlbertModel,
								    TFAlbertPreTrainedModel,
								)

				try:
								if not is_flax_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_flax_albert import (
								    FlaxAlbertForMaskedLM,
								    FlaxAlbertForMultipleChoice,
								    FlaxAlbertForPreTraining,
								    FlaxAlbertForQuestionAnswering,
								    FlaxAlbertForSequenceClassification,
								    FlaxAlbertForTokenClassification,
								    FlaxAlbertModel,
								    FlaxAlbertPreTrainedModel,
								)
else:
				import sys

				_snake_case				:				Union[str, Any]       							=		_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)

