



"""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        _UpperCAmelCase       (			lowerCAmelCase__    ,     unittest.TestCase):
 _lowerCAmelCase   :			List[Any]							=		BertJapaneseTokenizer
 _lowerCAmelCase   :			Any							=		False
 _lowerCAmelCase   :			str							=		True

 def 						_snake_case					(     self		:       Union[str, Any]				):
     super().setUp()

     snake_case_ :     List[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 						_snake_case					(     self		:       Any  ,     lowercase_		:       Optional[int]				):
     snake_case_ :     Dict				=	'''こんにちは、世界。 \nこんばんは、世界。'''
     snake_case_ :     Optional[Any]				=	'''こんにちは 、 世界 。 こんばんは 、 世界 。'''
     return input_text, output_text

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

 def 						_snake_case					(     self		:       Optional[int]				):
     pass  # TODO add if relevant

 def 						_snake_case					(     self		:       Union[str, Any]				):
     pass  # TODO add if relevant

 def 						_snake_case					(     self		:       Optional[int]				):
     pass  # TODO add if relevant

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

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

 def 						_snake_case					(     self		:       Union[str, Any]				):
     snake_case_ :     Optional[Any]				=	self.tokenizer_class(self.vocab_file  ,     word_tokenizer_type='''mecab'''				)
     self.assertIsNotNone(lowercase_				)

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

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

     with open(lowercase_  ,     '''rb'''				) as handle:
         snake_case_ :     str				=	pickle.load(lowercase_				)

     snake_case_ :     Optional[int]				=	tokenizer_new.tokenize(lowercase_				)

     self.assertListEqual(lowercase_  ,     lowercase_				)

 def 						_snake_case					(     self		:       List[Any]				):
     snake_case_ :     str				=	MecabTokenizer(mecab_dic='''ipadic'''				)

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

 def 						_snake_case					(     self		:       Union[str, Any]				):
     try:
         snake_case_ :     Optional[Any]				=	MecabTokenizer(mecab_dic='''unidic_lite'''				)
     except ModuleNotFoundError:
         return

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

 def 						_snake_case					(     self		:       int				):
     try:
         snake_case_ :     int				=	MecabTokenizer(mecab_dic='''unidic'''				)
     except ModuleNotFoundError:
         return

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

 def 						_snake_case					(     self		:       Optional[Any]				):
     snake_case_ :     Any				=	MecabTokenizer(do_lower_case=lowercase_  ,     mecab_dic='''ipadic'''				)

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

 def 						_snake_case					(     self		:       List[str]				):
     try:
         snake_case_ :     List[Any]				=	MecabTokenizer(
             do_lower_case=lowercase_  ,     normalize_text=lowercase_  ,     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 						_snake_case					(     self		:       Union[str, Any]				):
     snake_case_ :     Tuple				=	MecabTokenizer(normalize_text=lowercase_  ,     mecab_dic='''ipadic'''				)

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

 @require_sudachi
 def 						_snake_case					(     self		:       List[Any]				):
     snake_case_ :     str				=	self.tokenizer_class(self.vocab_file  ,     word_tokenizer_type='''sudachi'''				)
     self.assertIsNotNone(lowercase_				)

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

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

     with open(lowercase_  ,     '''rb'''				) as handle:
         snake_case_ :     Any				=	pickle.load(lowercase_				)

     snake_case_ :     List[str]				=	tokenizer_new.tokenize(lowercase_				)

     self.assertListEqual(lowercase_  ,     lowercase_				)

 @require_sudachi
 def 						_snake_case					(     self		:       Dict				):
     snake_case_ :     int				=	SudachiTokenizer(sudachi_dict_type='''core'''				)

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

 @require_sudachi
 def 						_snake_case					(     self		:       int				):
     snake_case_ :     int				=	SudachiTokenizer(sudachi_dict_type='''core'''  ,     sudachi_split_mode='''A'''				)

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

 @require_sudachi
 def 						_snake_case					(     self		:       Union[str, Any]				):
     snake_case_ :     Optional[Any]				=	SudachiTokenizer(sudachi_dict_type='''core'''  ,     sudachi_split_mode='''B'''				)

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

 @require_sudachi
 def 						_snake_case					(     self		:       List[str]				):
     snake_case_ :     Optional[Any]				=	SudachiTokenizer(sudachi_dict_type='''core'''  ,     sudachi_split_mode='''C'''				)

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

 @require_sudachi
 def 						_snake_case					(     self		:       Any				):
     snake_case_ :     Union[str, Any]				=	SudachiTokenizer(do_lower_case=lowercase_  ,     sudachi_dict_type='''core'''				)

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

 @require_sudachi
 def 						_snake_case					(     self		:       Optional[int]				):
     snake_case_ :     str				=	SudachiTokenizer(normalize_text=lowercase_  ,     sudachi_dict_type='''core'''				)

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

 @require_sudachi
 def 						_snake_case					(     self		:       Tuple				):
     snake_case_ :     Union[str, Any]				=	SudachiTokenizer(trim_whitespace=lowercase_  ,     sudachi_dict_type='''core'''				)

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

 @require_jumanpp
 def 						_snake_case					(     self		:       Tuple				):
     snake_case_ :     Union[str, Any]				=	self.tokenizer_class(self.vocab_file  ,     word_tokenizer_type='''jumanpp'''				)
     self.assertIsNotNone(lowercase_				)

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

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

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

     snake_case_ :     str				=	tokenizer_new.tokenize(lowercase_				)

     self.assertListEqual(lowercase_  ,     lowercase_				)

 @require_jumanpp
 def 						_snake_case					(     self		:       str				):
     snake_case_ :     Union[str, Any]				=	JumanppTokenizer()

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

 @require_jumanpp
 def 						_snake_case					(     self		:       Optional[int]				):
     snake_case_ :     str				=	JumanppTokenizer(do_lower_case=lowercase_				)

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

 @require_jumanpp
 def 						_snake_case					(     self		:       Optional[Any]				):
     snake_case_ :     Tuple				=	JumanppTokenizer(normalize_text=lowercase_				)

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

 @require_jumanpp
 def 						_snake_case					(     self		:       Optional[int]				):
     snake_case_ :     Optional[Any]				=	JumanppTokenizer(trim_whitespace=lowercase_				)

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

 @require_jumanpp
 def 						_snake_case					(     self		:       Union[str, Any]				):
     snake_case_ :     int				=	JumanppTokenizer()

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

 def 						_snake_case					(     self		:       Tuple				):
     snake_case_ :     str				=	['''[UNK]''', '''[CLS]''', '''[SEP]''', '''こんにちは''', '''こん''', '''にちは''', '''ばんは''', '''##こん''', '''##にちは''', '''##ばんは''']

     snake_case_ :     str				=	{}
     for i, token in enumerate(lowercase_				):
         snake_case_ :     str				=	i
     snake_case_ :     int				=	WordpieceTokenizer(vocab=lowercase_  ,     unk_token='''[UNK]'''				)

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

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

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

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

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

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

     snake_case_ :     Union[str, Any]				=	subword_tokenizer.tokenize('''こんばんは こんばん にち は こんにちは'''				)
     self.assertListEqual(lowercase_  ,     ['''▁こん''', '''ばん''', '''は''', '''▁こん''', '''ばん''', '''▁に''', '''ち''', '''▁は''', '''▁こんにちは''']				)






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

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

     snake_case_ :     Union[str, Any]				=	tokenizer.build_inputs_with_special_tokens(lowercase_				)
     snake_case_ :     List[Any]				=	tokenizer.build_inputs_with_special_tokens(lowercase_  ,     lowercase_				)

     # 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        _UpperCAmelCase       (			lowerCAmelCase__    ,     unittest.TestCase):
 _lowerCAmelCase   :			Optional[Any]							=		BertJapaneseTokenizer
 _lowerCAmelCase   :			Optional[int]							=		False

 def 						_snake_case					(     self		:       Tuple				):
     super().setUp()

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

     snake_case_ :     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 						_snake_case					(     self		:       Optional[Any]  ,     **lowercase_		:       Any				):
     return BertJapaneseTokenizer.from_pretrained(self.tmpdirname  ,     subword_tokenizer_type='''character'''  ,     **lowercase_				)

 def 						_snake_case					(     self		:       str  ,     lowercase_		:       Optional[Any]				):
     snake_case_ :     str				=	'''こんにちは、世界。 \nこんばんは、世界。'''
     snake_case_ :     int				=	'''こ ん に ち は 、 世 界 。 こ ん ば ん は 、 世 界 。'''
     return input_text, output_text

 def 						_snake_case					(     self		:       Union[str, Any]				):
     pass  # TODO add if relevant

 def 						_snake_case					(     self		:       int				):
     pass  # TODO add if relevant

 def 						_snake_case					(     self		:       List[Any]				):
     pass  # TODO add if relevant

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

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

 def 						_snake_case					(     self		:       Dict				):
     snake_case_ :     str				=	['''[UNK]''', '''[CLS]''', '''[SEP]''', '''こ''', '''ん''', '''に''', '''ち''', '''は''', '''ば''', '''世''', '''界''', '''、''', '''。''']

     snake_case_ :     int				=	{}
     for i, token in enumerate(lowercase_				):
         snake_case_ :     int				=	i
     snake_case_ :     List[Any]				=	CharacterTokenizer(vocab=lowercase_  ,     unk_token='''[UNK]'''				)

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

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

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






 def 						_snake_case					(     self		:       Dict				):
     snake_case_ :     int				=	self.tokenizer_class.from_pretrained('''cl-tohoku/bert-base-japanese-char'''				)

     snake_case_ :     Any				=	tokenizer.encode('''ありがとう。'''  ,     add_special_tokens=lowercase_				)
     snake_case_ :     Dict				=	tokenizer.encode('''どういたしまして。'''  ,     add_special_tokens=lowercase_				)

     snake_case_ :     List[Any]				=	tokenizer.build_inputs_with_special_tokens(lowercase_				)
     snake_case_ :     Optional[Any]				=	tokenizer.build_inputs_with_special_tokens(lowercase_  ,     lowercase_				)

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

 def 						_snake_case					(     self		:       str				):
     snake_case_ :     Optional[int]				=	'''cl-tohoku/bert-base-japanese'''
     snake_case_ :     Any				=	AutoTokenizer.from_pretrained(lowercase_				)
     self.assertIsInstance(lowercase_  ,     lowercase_				)





class        _UpperCAmelCase       (			unittest.TestCase):

 def 						_snake_case					(     self		:       List[Any]				):
     snake_case_ :     Optional[Any]				=	'''cl-tohoku/bert-base-japanese'''
     with self.assertLogs('''transformers'''  ,     level='''WARNING'''				) as cm:
         BertTokenizer.from_pretrained(lowercase_				)
         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_ :     Any				=	'''bert-base-cased'''
     with self.assertLogs('''transformers'''  ,     level='''WARNING'''				) as cm:
         BertJapaneseTokenizer.from_pretrained(lowercase_				)
         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_torch_available


lowercase__    :  str							    =	{
    '''configuration_x_clip''': [
        '''XCLIP_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''XCLIPConfig''',
        '''XCLIPTextConfig''',
        '''XCLIPVisionConfig''',
    ],
    '''processing_x_clip''': ['''XCLIPProcessor'''],
}

try:
     if not is_torch_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     lowercase__    :  Tuple							    =	[
         '''XCLIP_PRETRAINED_MODEL_ARCHIVE_LIST''',
         '''XCLIPModel''',
         '''XCLIPPreTrainedModel''',
         '''XCLIPTextModel''',
         '''XCLIPVisionModel''',
     ]

if TYPE_CHECKING:
     from .configuration_x_clip import (
         XCLIP_PRETRAINED_CONFIG_ARCHIVE_MAP,
         XCLIPConfig,
         XCLIPTextConfig,
         XCLIPVisionConfig,
     )
     from .processing_x_clip import XCLIPProcessor

     try:
          if not is_torch_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_x_clip import (
              XCLIP_PRETRAINED_MODEL_ARCHIVE_LIST,
              XCLIPModel,
              XCLIPPreTrainedModel,
              XCLIPTextModel,
              XCLIPVisionModel,
          )

else:
     import sys

     lowercase__    :  Tuple							    =	_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)





