




"""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_				      =       BertJapaneseTokenizer
   A_				      =       False
   A_				      =       True







   def   UpperCAmelCase__			(		self)				->   Optional[Any]:
       super().setUp()

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

       UpperCamelCase              =	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       ,					lowerCamelCase_)				->   List[Any]:
       UpperCamelCase              =	'''こんにちは、世界。 \nこんばんは、世界。'''
       UpperCamelCase              =	'''こんにちは 、 世界 。 こんばんは 、 世界 。'''
       return input_text, output_text







   def   UpperCAmelCase__			(		self       ,					lowerCamelCase_)				->   Tuple:
       UpperCamelCase       ,	UpperCamelCase              =	self.get_input_output_texts(lowerCamelCase_)
       UpperCamelCase              =	tokenizer.encode(lowerCamelCase_       ,					add_special_tokens=lowerCamelCase_)
       UpperCamelCase              =	tokenizer.decode(lowerCamelCase_       ,					clean_up_tokenization_spaces=lowerCamelCase_)
       return text, ids







   def   UpperCAmelCase__			(		self)				->   str:
       pass  # TODO add if relevant







   def   UpperCAmelCase__			(		self)				->   List[str]:
       pass  # TODO add if relevant







   def   UpperCAmelCase__			(		self)				->   Optional[int]:
       pass  # TODO add if relevant







   def   UpperCAmelCase__			(		self)				->   str:
       UpperCamelCase              =	self.tokenizer_class(self.vocab_file)

       UpperCamelCase              =	tokenizer.tokenize('''こんにちは、世界。\nこんばんは、世界。''')
       self.assertListEqual(lowerCamelCase_       ,					['''こんにちは''', '''、''', '''世界''', '''。''', '''こん''', '''##ばんは''', '''、''', '''世界''', '''。'''])
       self.assertListEqual(tokenizer.convert_tokens_to_ids(lowerCamelCase_)       ,					[3, 1_2, 1_0, 1_4, 4, 9, 1_2, 1_0, 1_4])







   def   UpperCAmelCase__			(		self)				->   Optional[int]:
       UpperCamelCase              =	self.tokenizer_class(self.vocab_file       ,					word_tokenizer_type='''mecab''')
       self.assertIsNotNone(lowerCamelCase_)

       UpperCamelCase              =	'''こんにちは、世界。\nこんばんは、世界。'''
       UpperCamelCase              =	tokenizer.tokenize(lowerCamelCase_)
       self.assertListEqual(lowerCamelCase_       ,					['''こんにちは''', '''、''', '''世界''', '''。''', '''こん''', '''##ばんは''', '''、''', '''世界''', '''。'''])
       self.assertListEqual(tokenizer.convert_tokens_to_ids(lowerCamelCase_)       ,					[3, 1_2, 1_0, 1_4, 4, 9, 1_2, 1_0, 1_4])

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

       with open(lowerCamelCase_       ,					'''rb''') as handle:
           UpperCamelCase              =	pickle.load(lowerCamelCase_)

       UpperCamelCase              =	tokenizer_new.tokenize(lowerCamelCase_)

       self.assertListEqual(lowerCamelCase_       ,					lowerCamelCase_)







   def   UpperCAmelCase__			(		self)				->   Tuple:
       UpperCamelCase              =	MecabTokenizer(mecab_dic='''ipadic''')

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







   def   UpperCAmelCase__			(		self)				->   int:
       try:
           UpperCamelCase              =	MecabTokenizer(mecab_dic='''unidic_lite''')
       except ModuleNotFoundError:
           return

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







   def   UpperCAmelCase__			(		self)				->   Optional[Any]:
       try:
           UpperCamelCase              =	MecabTokenizer(mecab_dic='''unidic''')
       except ModuleNotFoundError:
           return

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







   def   UpperCAmelCase__			(		self)				->   Dict:
       UpperCamelCase              =	MecabTokenizer(do_lower_case=lowerCamelCase_       ,					mecab_dic='''ipadic''')

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







   def   UpperCAmelCase__			(		self)				->   int:
       try:
           UpperCamelCase              =	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   UpperCAmelCase__			(		self)				->   Optional[int]:
       UpperCamelCase              =	MecabTokenizer(normalize_text=lowerCamelCase_       ,					mecab_dic='''ipadic''')

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







   @require_sudachi
   def   UpperCAmelCase__			(		self)				->   Tuple:
       UpperCamelCase              =	self.tokenizer_class(self.vocab_file       ,					word_tokenizer_type='''sudachi''')
       self.assertIsNotNone(lowerCamelCase_)

       UpperCamelCase              =	'''こんにちは、世界。\nこんばんは、世界。'''
       UpperCamelCase              =	tokenizer.tokenize(lowerCamelCase_)
       self.assertListEqual(lowerCamelCase_       ,					['''こんにちは''', '''、''', '''世界''', '''。''', '''こん''', '''##ばんは''', '''、''', '''世界''', '''。'''])
       self.assertListEqual(tokenizer.convert_tokens_to_ids(lowerCamelCase_)       ,					[3, 1_2, 1_0, 1_4, 4, 9, 1_2, 1_0, 1_4])

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

       with open(lowerCamelCase_       ,					'''rb''') as handle:
           UpperCamelCase              =	pickle.load(lowerCamelCase_)

       UpperCamelCase              =	tokenizer_new.tokenize(lowerCamelCase_)

       self.assertListEqual(lowerCamelCase_       ,					lowerCamelCase_)







   @require_sudachi
   def   UpperCAmelCase__			(		self)				->   Any:
       UpperCamelCase              =	SudachiTokenizer(sudachi_dict_type='''core''')

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







   @require_sudachi
   def   UpperCAmelCase__			(		self)				->   int:
       UpperCamelCase              =	SudachiTokenizer(sudachi_dict_type='''core'''       ,					sudachi_split_mode='''A''')

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







   @require_sudachi
   def   UpperCAmelCase__			(		self)				->   Any:
       UpperCamelCase              =	SudachiTokenizer(sudachi_dict_type='''core'''       ,					sudachi_split_mode='''B''')

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







   @require_sudachi
   def   UpperCAmelCase__			(		self)				->   Optional[Any]:
       UpperCamelCase              =	SudachiTokenizer(sudachi_dict_type='''core'''       ,					sudachi_split_mode='''C''')

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







   @require_sudachi
   def   UpperCAmelCase__			(		self)				->   Any:
       UpperCamelCase              =	SudachiTokenizer(do_lower_case=lowerCamelCase_       ,					sudachi_dict_type='''core''')

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







   @require_sudachi
   def   UpperCAmelCase__			(		self)				->   Optional[int]:
       UpperCamelCase              =	SudachiTokenizer(normalize_text=lowerCamelCase_       ,					sudachi_dict_type='''core''')

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







   @require_sudachi
   def   UpperCAmelCase__			(		self)				->   str:
       UpperCamelCase              =	SudachiTokenizer(trim_whitespace=lowerCamelCase_       ,					sudachi_dict_type='''core''')

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







   @require_jumanpp
   def   UpperCAmelCase__			(		self)				->   str:
       UpperCamelCase              =	self.tokenizer_class(self.vocab_file       ,					word_tokenizer_type='''jumanpp''')
       self.assertIsNotNone(lowerCamelCase_)

       UpperCamelCase              =	'''こんにちは、世界。\nこんばんは、世界。'''
       UpperCamelCase              =	tokenizer.tokenize(lowerCamelCase_)
       self.assertListEqual(lowerCamelCase_       ,					['''こんにちは''', '''、''', '''世界''', '''。''', '''こん''', '''##ばんは''', '''、''', '''世界''', '''。'''])
       self.assertListEqual(tokenizer.convert_tokens_to_ids(lowerCamelCase_)       ,					[3, 1_2, 1_0, 1_4, 4, 9, 1_2, 1_0, 1_4])

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

       with open(lowerCamelCase_       ,					'''rb''') as handle:
           UpperCamelCase              =	pickle.load(lowerCamelCase_)

       UpperCamelCase              =	tokenizer_new.tokenize(lowerCamelCase_)

       self.assertListEqual(lowerCamelCase_       ,					lowerCamelCase_)







   @require_jumanpp
   def   UpperCAmelCase__			(		self)				->   str:
       UpperCamelCase              =	JumanppTokenizer()

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







   @require_jumanpp
   def   UpperCAmelCase__			(		self)				->   Optional[int]:
       UpperCamelCase              =	JumanppTokenizer(do_lower_case=lowerCamelCase_)

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







   @require_jumanpp
   def   UpperCAmelCase__			(		self)				->   int:
       UpperCamelCase              =	JumanppTokenizer(normalize_text=lowerCamelCase_)

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







   @require_jumanpp
   def   UpperCAmelCase__			(		self)				->   Optional[Any]:
       UpperCamelCase              =	JumanppTokenizer(trim_whitespace=lowerCamelCase_)

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







   @require_jumanpp
   def   UpperCAmelCase__			(		self)				->   List[Any]:
       UpperCamelCase              =	JumanppTokenizer()

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







   def   UpperCAmelCase__			(		self)				->   List[Any]:
       UpperCamelCase              =	['''[UNK]''', '''[CLS]''', '''[SEP]''', '''こんにちは''', '''こん''', '''にちは''', '''ばんは''', '''##こん''', '''##にちは''', '''##ばんは''']

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

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

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

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

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







   def   UpperCAmelCase__			(		self)				->   str:
       UpperCamelCase              =	BertJapaneseTokenizer.from_pretrained('''nlp-waseda/roberta-base-japanese-with-auto-jumanpp''')
       UpperCamelCase              =	tokenizer.subword_tokenizer

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

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







   def   UpperCAmelCase__			(		self)				->   List[Any]:
       UpperCamelCase              =	self.tokenizer_class.from_pretrained('''cl-tohoku/bert-base-japanese''')

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

       UpperCamelCase              =	tokenizer.build_inputs_with_special_tokens(lowerCamelCase_)
       UpperCamelCase              =	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_				      =       BertJapaneseTokenizer
   A_				      =       False







   def   UpperCAmelCase__			(		self)				->   str:
       super().setUp()

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

       UpperCamelCase              =	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       ,					**lowerCamelCase_)				->   str:
       return BertJapaneseTokenizer.from_pretrained(self.tmpdirname       ,					subword_tokenizer_type='''character'''       ,					**lowerCamelCase_)







   def   UpperCAmelCase__			(		self       ,					lowerCamelCase_)				->   Optional[Any]:
       UpperCamelCase              =	'''こんにちは、世界。 \nこんばんは、世界。'''
       UpperCamelCase              =	'''こ ん に ち は 、 世 界 。 こ ん ば ん は 、 世 界 。'''
       return input_text, output_text







   def   UpperCAmelCase__			(		self)				->   Tuple:
       pass  # TODO add if relevant







   def   UpperCAmelCase__			(		self)				->   Optional[Any]:
       pass  # TODO add if relevant







   def   UpperCAmelCase__			(		self)				->   str:
       pass  # TODO add if relevant







   def   UpperCAmelCase__			(		self)				->   Optional[Any]:
       UpperCamelCase              =	self.tokenizer_class(self.vocab_file       ,					subword_tokenizer_type='''character''')

       UpperCamelCase              =	tokenizer.tokenize('''こんにちは、世界。 \nこんばんは、世界。''')
       self.assertListEqual(
           lowerCamelCase_       ,					['''こ''', '''ん''', '''に''', '''ち''', '''は''', '''、''', '''世''', '''界''', '''。''', '''こ''', '''ん''', '''ば''', '''ん''', '''は''', '''、''', '''世''', '''界''', '''。'''])
       self.assertListEqual(
           tokenizer.convert_tokens_to_ids(lowerCamelCase_)       ,					[3, 4, 5, 6, 7, 1_1, 9, 1_0, 1_2, 3, 4, 8, 4, 7, 1_1, 9, 1_0, 1_2])







   def   UpperCAmelCase__			(		self)				->   Optional[int]:
       UpperCamelCase              =	['''[UNK]''', '''[CLS]''', '''[SEP]''', '''こ''', '''ん''', '''に''', '''ち''', '''は''', '''ば''', '''世''', '''界''', '''、''', '''。''']

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

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

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

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







   def   UpperCAmelCase__			(		self)				->   Union[str, Any]:
       UpperCamelCase              =	self.tokenizer_class.from_pretrained('''cl-tohoku/bert-base-japanese-char''')

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

       UpperCamelCase              =	tokenizer.build_inputs_with_special_tokens(lowerCamelCase_)
       UpperCamelCase              =	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   UpperCAmelCase__			(		self)				->   Union[str, Any]:
       UpperCamelCase              =	'''cl-tohoku/bert-base-japanese'''
       UpperCamelCase              =	AutoTokenizer.from_pretrained(lowerCamelCase_)
       self.assertIsInstance(lowerCamelCase_       ,					lowerCamelCase_)

class 				snake_case_			(					unittest.TestCase			):







   """simple docstring"""




   def   UpperCAmelCase__			(		self)				->   Optional[int]:
       UpperCamelCase              =	'''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.'''))
       UpperCamelCase              =	'''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 warnings

from ...configuration_utils import PretrainedConfig
from ...utils import logging


__snake_case				:  Tuple =       logging.get_logger(__name__)

__snake_case				:  Tuple =       {
    'xlnet-base-cased': 'https://huggingface.co/xlnet-base-cased/resolve/main/config.json',
    'xlnet-large-cased': 'https://huggingface.co/xlnet-large-cased/resolve/main/config.json',
}



class      A__  (    __SCREAMING_SNAKE_CASE				):




	'''simple docstring'''





	SCREAMING_SNAKE_CASE        =      'xlnet'
	SCREAMING_SNAKE_CASE        =      ['mems']
	SCREAMING_SNAKE_CASE        =      {
	    'n_token': 'vocab_size',  # Backward compatibility
	    'hidden_size': 'd_model',
	    'num_attention_heads': 'n_head',
	    'num_hidden_layers': 'n_layer',
	}

	def __init__(	self:						Tuple			,     _SCREAMING_SNAKE_CASE:						List[str]=3_2000			,     _SCREAMING_SNAKE_CASE:						Union[str, Any]=1024			,     _SCREAMING_SNAKE_CASE:						Dict=24			,     _SCREAMING_SNAKE_CASE:						Optional[int]=16			,     _SCREAMING_SNAKE_CASE:						List[str]=4096			,     _SCREAMING_SNAKE_CASE:						Tuple="gelu"			,     _SCREAMING_SNAKE_CASE:						int=True			,     _SCREAMING_SNAKE_CASE:						List[Any]="bi"			,     _SCREAMING_SNAKE_CASE:						Any=0.02			,     _SCREAMING_SNAKE_CASE:						List[str]=1e-12			,     _SCREAMING_SNAKE_CASE:						Any=0.1			,     _SCREAMING_SNAKE_CASE:						Any=512			,     _SCREAMING_SNAKE_CASE:						Union[str, Any]=None			,     _SCREAMING_SNAKE_CASE:						Any=True			,     _SCREAMING_SNAKE_CASE:						Any=False			,     _SCREAMING_SNAKE_CASE:						Tuple=False			,     _SCREAMING_SNAKE_CASE:						List[Any]=-1			,     _SCREAMING_SNAKE_CASE:						Union[str, Any]=False			,     _SCREAMING_SNAKE_CASE:						Optional[int]="last"			,     _SCREAMING_SNAKE_CASE:						Tuple=True			,     _SCREAMING_SNAKE_CASE:						Dict="tanh"			,     _SCREAMING_SNAKE_CASE:						int=0.1			,     _SCREAMING_SNAKE_CASE:						Tuple=5			,     _SCREAMING_SNAKE_CASE:						List[str]=5			,     _SCREAMING_SNAKE_CASE:						Optional[Any]=5			,     _SCREAMING_SNAKE_CASE:						Optional[int]=1			,     _SCREAMING_SNAKE_CASE:						Tuple=2			,     **_SCREAMING_SNAKE_CASE:						str			,     )							->			Optional[Any]:

				"""simple docstring"""

				__lowerCAmelCase :    Dict				=			vocab_size
				__lowerCAmelCase :    Optional[int]				=			d_model
				__lowerCAmelCase :    Union[str, Any]				=			n_layer
				__lowerCAmelCase :    List[Any]				=			n_head
				if d_model % n_head != 0:
							raise ValueError(F"""'d_model % n_head' ({d_model % n_head}) should be equal to 0""")
				if "d_head" in kwargs:
							if kwargs["d_head"] != d_model // n_head:
										raise ValueError(
										    F"""`d_head` ({kwargs['d_head']}) should be equal to `d_model // n_head` ({d_model // n_head})""")
				__lowerCAmelCase :    Optional[Any]				=			d_model // n_head
				__lowerCAmelCase :    Tuple				=			ff_activation
				__lowerCAmelCase :    Union[str, Any]				=			d_inner
				__lowerCAmelCase :    Any				=			untie_r
				__lowerCAmelCase :    int				=			attn_type

				__lowerCAmelCase :    Any				=			initializer_range
				__lowerCAmelCase :    List[Any]				=			layer_norm_eps

				__lowerCAmelCase :    int				=			dropout
				__lowerCAmelCase :    List[Any]				=			mem_len
				__lowerCAmelCase :    str				=			reuse_len
				__lowerCAmelCase :    Any				=			bi_data
				__lowerCAmelCase :    Optional[int]				=			clamp_len
				__lowerCAmelCase :    Union[str, Any]				=			same_length

				__lowerCAmelCase :    List[str]				=			summary_type
				__lowerCAmelCase :    Optional[int]				=			summary_use_proj
				__lowerCAmelCase :    Tuple				=			summary_activation
				__lowerCAmelCase :    Dict				=			summary_last_dropout
				__lowerCAmelCase :    str				=			start_n_top
				__lowerCAmelCase :    List[str]				=			end_n_top

				__lowerCAmelCase :    str				=			bos_token_id
				__lowerCAmelCase :    Optional[Any]				=			pad_token_id
				__lowerCAmelCase :    Optional[Any]				=			eos_token_id

				if "use_cache" in kwargs:
							warnings.warn(
							    "The `use_cache` argument is deprecated and will be removed in a future version, use `use_mems_eval`"
							    " instead."			,     _SCREAMING_SNAKE_CASE			,     )
							__lowerCAmelCase :    Optional[int]				=			kwargs["use_cache"]

				__lowerCAmelCase :    Optional[int]				=			use_mems_eval
				__lowerCAmelCase :    Any				=			use_mems_train
				super().__init__(pad_token_id=_SCREAMING_SNAKE_CASE			,     bos_token_id=_SCREAMING_SNAKE_CASE			,     eos_token_id=_SCREAMING_SNAKE_CASE			,     **_SCREAMING_SNAKE_CASE)

	@property
	def 				_SCREAMING_SNAKE_CASE  (	self:						Any)							->			int:

				"""simple docstring"""

				logger.info(F"""The model {self.model_type} is one of the few models that has no sequence length limit.""")
				return -1







	@max_position_embeddings.setter
	def 				_SCREAMING_SNAKE_CASE  (	self:						List[str]			,     _SCREAMING_SNAKE_CASE:						Optional[int])							->			Optional[int]:

				"""simple docstring"""

				raise NotImplementedError(
				    F"""The model {self.model_type} is one of the few models that has no sequence length limit.""")