




"""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 enum
import os
from hashlib import shaaaa
from typing import Optional

from .. import config
from .logging import get_logger


_lowercase							=				get_logger(__name__)

class 					__a     ( enum.Enum       ):



							'''simple docstring'''







							_lowerCamelCase					:			Tuple          =   """all_checks"""
							_lowerCamelCase					:			Optional[int]          =   """basic_checks"""
							_lowerCamelCase					:			str          =   """no_checks"""





class 					__a     ( __a       ):



							'''simple docstring'''












class 					__a     ( __a       ):



							'''simple docstring'''












class 					__a     ( __a       ):



							'''simple docstring'''












class 					__a     ( __a       ):



							'''simple docstring'''












def      lowerCAmelCase__			(		__magic_name__			,   __magic_name__			,   __magic_name__=None      )						->Union[str, Any]:
			if expected_checksums is None:
						logger.info("Unable to verify checksums."      )
						return
			if len(set(__magic_name__      ) - set(__magic_name__      )      ) > 0:
						raise ExpectedMoreDownloadedFiles(str(set(__magic_name__      ) - set(__magic_name__      )      )      )
			if len(set(__magic_name__      ) - set(__magic_name__      )      ) > 0:
						raise UnexpectedDownloadedFile(str(set(__magic_name__      ) - set(__magic_name__      )      )      )
			__lowercase       =       [url for url in expected_checksums if expected_checksums[url] != recorded_checksums[url]]
			__lowercase       =       " for " + verification_name if verification_name is not None else ""
			if len(__magic_name__      ) > 0:
						raise NonMatchingChecksumError(
						    F'''Checksums didn\'t match{for_verification_name}:\n'''
						    F'''{bad_urls}\n'''
						    "Set `verification_mode='no_checks'` to skip checksums verification and ignore this error"      )
			logger.info("All the checksums matched successfully" + for_verification_name      )

class 					__a     ( __a       ):



							'''simple docstring'''












class 					__a     ( __a       ):



							'''simple docstring'''












class 					__a     ( __a       ):



							'''simple docstring'''












class 					__a     ( __a       ):



							'''simple docstring'''












def      lowerCAmelCase__			(		__magic_name__			,   __magic_name__      )						->Any:
			if expected_splits is None:
						logger.info("Unable to verify splits sizes."      )
						return
			if len(set(__magic_name__      ) - set(__magic_name__      )      ) > 0:
						raise ExpectedMoreSplits(str(set(__magic_name__      ) - set(__magic_name__      )      )      )
			if len(set(__magic_name__      ) - set(__magic_name__      )      ) > 0:
						raise UnexpectedSplits(str(set(__magic_name__      ) - set(__magic_name__      )      )      )
			__lowercase       =       [
			    {"expected": expected_splits[name], "recorded": recorded_splits[name]}
			    for name in expected_splits
			    if expected_splits[name].num_examples != recorded_splits[name].num_examples
			]
			if len(__magic_name__      ) > 0:
						raise NonMatchingSplitsSizesError(str(__magic_name__      )      )
			logger.info("All the splits matched successfully."      )



def      lowerCAmelCase__			(		__magic_name__			,   __magic_name__ = True      )						->dict:
			if record_checksum:
						__lowercase       =       shaaaa()
						with open(__magic_name__			,   "rb"      ) as f:
									for chunk in iter(lambda: f.read(1 << 2_0      )			,   b""      ):
												m.update(__magic_name__      )
									__lowercase       =       m.hexdigest()
			else:
						__lowercase       =       None
			return {"num_bytes": os.path.getsize(__magic_name__      ), "checksum": checksum}







def      lowerCAmelCase__			(		__magic_name__      )						->List[str]:
			if dataset_size and config.IN_MEMORY_MAX_SIZE:
						return dataset_size < config.IN_MEMORY_MAX_SIZE
			else:
						return False





