






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       __lowercase      (	lowercase_			,      unittest.TestCase  ):







     '''simple docstring'''
     SCREAMING_SNAKE_CASE   						=				BertJapaneseTokenizer
     SCREAMING_SNAKE_CASE   						=				False
     SCREAMING_SNAKE_CASE   						=				True




     def 		lowerCAmelCase_     (				self       :			Optional[Any]				):


         """simple docstring"""



         super().setUp()

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

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




     def 		lowerCAmelCase_     (				self       :			List[str] ,	UpperCamelCase_       :			Optional[Any]				):


         """simple docstring"""



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




     def 		lowerCAmelCase_     (				self       :			Optional[int] ,	UpperCamelCase_       :			Optional[int]				):


         """simple docstring"""



         __A    ,	__A         =	self.get_input_output_texts(UpperCamelCase_				)
         __A         =	tokenizer.encode(UpperCamelCase_ ,	add_special_tokens=UpperCamelCase_				)
         __A         =	tokenizer.decode(UpperCamelCase_ ,	clean_up_tokenization_spaces=UpperCamelCase_				)
         return text, ids




     def 		lowerCAmelCase_     (				self       :			str				):


         """simple docstring"""



         pass  # TODO add if relevant




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


         """simple docstring"""



         pass  # TODO add if relevant




     def 		lowerCAmelCase_     (				self       :			Tuple				):


         """simple docstring"""



         pass  # TODO add if relevant




     def 		lowerCAmelCase_     (				self       :			List[Any]				):


         """simple docstring"""



         __A         =	self.tokenizer_class(self.vocab_file				)

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




     def 		lowerCAmelCase_     (				self       :			List[Any]				):


         """simple docstring"""



         __A         =	self.tokenizer_class(self.vocab_file ,	word_tokenizer_type="""mecab"""				)
         self.assertIsNotNone(UpperCamelCase_				)

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

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

         with open(UpperCamelCase_ ,	"""rb"""				) as handle:
             __A         =	pickle.load(UpperCamelCase_				)

         __A         =	tokenizer_new.tokenize(UpperCamelCase_				)

         self.assertListEqual(UpperCamelCase_ ,	UpperCamelCase_				)




     def 		lowerCAmelCase_     (				self       :			Optional[Any]				):


         """simple docstring"""



         __A         =	MecabTokenizer(mecab_dic="""ipadic"""				)

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




     def 		lowerCAmelCase_     (				self       :			List[Any]				):


         """simple docstring"""



         try:
             __A         =	MecabTokenizer(mecab_dic="""unidic_lite"""				)
         except ModuleNotFoundError:
             return

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




     def 		lowerCAmelCase_     (				self       :			int				):


         """simple docstring"""



         try:
             __A         =	MecabTokenizer(mecab_dic="""unidic"""				)
         except ModuleNotFoundError:
             return

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




     def 		lowerCAmelCase_     (				self       :			List[str]				):


         """simple docstring"""



         __A         =	MecabTokenizer(do_lower_case=UpperCamelCase_ ,	mecab_dic="""ipadic"""				)

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




     def 		lowerCAmelCase_     (				self       :			Optional[int]				):


         """simple docstring"""



         try:
             __A         =	MecabTokenizer(
                 do_lower_case=UpperCamelCase_ ,	normalize_text=UpperCamelCase_ ,	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       :			List[Any]				):


         """simple docstring"""



         __A         =	MecabTokenizer(normalize_text=UpperCamelCase_ ,	mecab_dic="""ipadic"""				)

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




     @require_sudachi
     def 		lowerCAmelCase_     (				self       :			int				):


         """simple docstring"""



         __A         =	self.tokenizer_class(self.vocab_file ,	word_tokenizer_type="""sudachi"""				)
         self.assertIsNotNone(UpperCamelCase_				)

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

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

         with open(UpperCamelCase_ ,	"""rb"""				) as handle:
             __A         =	pickle.load(UpperCamelCase_				)

         __A         =	tokenizer_new.tokenize(UpperCamelCase_				)

         self.assertListEqual(UpperCamelCase_ ,	UpperCamelCase_				)




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


         """simple docstring"""



         __A         =	SudachiTokenizer(sudachi_dict_type="""core"""				)

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




     @require_sudachi
     def 		lowerCAmelCase_     (				self       :			Union[str, Any]				):


         """simple docstring"""



         __A         =	SudachiTokenizer(sudachi_dict_type="""core""" ,	sudachi_split_mode="""A"""				)

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




     @require_sudachi
     def 		lowerCAmelCase_     (				self       :			Tuple				):


         """simple docstring"""



         __A         =	SudachiTokenizer(sudachi_dict_type="""core""" ,	sudachi_split_mode="""B"""				)

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




     @require_sudachi
     def 		lowerCAmelCase_     (				self       :			Tuple				):


         """simple docstring"""



         __A         =	SudachiTokenizer(sudachi_dict_type="""core""" ,	sudachi_split_mode="""C"""				)

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




     @require_sudachi
     def 		lowerCAmelCase_     (				self       :			Union[str, Any]				):


         """simple docstring"""



         __A         =	SudachiTokenizer(do_lower_case=UpperCamelCase_ ,	sudachi_dict_type="""core"""				)

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




     @require_sudachi
     def 		lowerCAmelCase_     (				self       :			Any				):


         """simple docstring"""



         __A         =	SudachiTokenizer(normalize_text=UpperCamelCase_ ,	sudachi_dict_type="""core"""				)

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




     @require_sudachi
     def 		lowerCAmelCase_     (				self       :			Any				):


         """simple docstring"""



         __A         =	SudachiTokenizer(trim_whitespace=UpperCamelCase_ ,	sudachi_dict_type="""core"""				)

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




     @require_jumanpp
     def 		lowerCAmelCase_     (				self       :			List[Any]				):


         """simple docstring"""



         __A         =	self.tokenizer_class(self.vocab_file ,	word_tokenizer_type="""jumanpp"""				)
         self.assertIsNotNone(UpperCamelCase_				)

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

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

         with open(UpperCamelCase_ ,	"""rb"""				) as handle:
             __A         =	pickle.load(UpperCamelCase_				)

         __A         =	tokenizer_new.tokenize(UpperCamelCase_				)

         self.assertListEqual(UpperCamelCase_ ,	UpperCamelCase_				)




     @require_jumanpp
     def 		lowerCAmelCase_     (				self       :			Union[str, Any]				):


         """simple docstring"""



         __A         =	JumanppTokenizer()

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




     @require_jumanpp
     def 		lowerCAmelCase_     (				self       :			Dict				):


         """simple docstring"""



         __A         =	JumanppTokenizer(do_lower_case=UpperCamelCase_				)

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




     @require_jumanpp
     def 		lowerCAmelCase_     (				self       :			str				):


         """simple docstring"""



         __A         =	JumanppTokenizer(normalize_text=UpperCamelCase_				)

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




     @require_jumanpp
     def 		lowerCAmelCase_     (				self       :			str				):


         """simple docstring"""



         __A         =	JumanppTokenizer(trim_whitespace=UpperCamelCase_				)

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




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


         """simple docstring"""



         __A         =	JumanppTokenizer()

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




     def 		lowerCAmelCase_     (				self       :			List[str]				):


         """simple docstring"""



         __A         =	["""[UNK]""", """[CLS]""", """[SEP]""", """こんにちは""", """こん""", """にちは""", """ばんは""", """##こん""", """##にちは""", """##ばんは"""]

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

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

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

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

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




     def 		lowerCAmelCase_     (				self       :			Dict				):


         """simple docstring"""



         __A         =	BertJapaneseTokenizer.from_pretrained("""nlp-waseda/roberta-base-japanese-with-auto-jumanpp"""				)
         __A         =	tokenizer.subword_tokenizer

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

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





     def 		lowerCAmelCase_     (				self       :			Optional[int]				):


         """simple docstring"""



         __A         =	self.tokenizer_class.from_pretrained("""cl-tohoku/bert-base-japanese"""				)

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

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

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







     '''simple docstring'''
     SCREAMING_SNAKE_CASE   						=				BertJapaneseTokenizer
     SCREAMING_SNAKE_CASE   						=				False




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


         """simple docstring"""



         super().setUp()

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

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




     def 		lowerCAmelCase_     (				self       :			Dict ,	**UpperCamelCase_       :			Dict				):


         """simple docstring"""



         return BertJapaneseTokenizer.from_pretrained(self.tmpdirname ,	subword_tokenizer_type="""character""" ,	**UpperCamelCase_				)




     def 		lowerCAmelCase_     (				self       :			Union[str, Any] ,	UpperCamelCase_       :			Union[str, Any]				):


         """simple docstring"""



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




     def 		lowerCAmelCase_     (				self       :			Any				):


         """simple docstring"""



         pass  # TODO add if relevant




     def 		lowerCAmelCase_     (				self       :			List[str]				):


         """simple docstring"""



         pass  # TODO add if relevant




     def 		lowerCAmelCase_     (				self       :			Optional[int]				):


         """simple docstring"""



         pass  # TODO add if relevant




     def 		lowerCAmelCase_     (				self       :			List[Any]				):


         """simple docstring"""



         __A         =	self.tokenizer_class(self.vocab_file ,	subword_tokenizer_type="""character"""				)

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




     def 		lowerCAmelCase_     (				self       :			Optional[Any]				):


         """simple docstring"""



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

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

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

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

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





     def 		lowerCAmelCase_     (				self       :			Any				):


         """simple docstring"""



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

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

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

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







     '''simple docstring'''




     def 		lowerCAmelCase_     (				self       :			str				):


         """simple docstring"""



         __A         =	"""cl-tohoku/bert-base-japanese"""
         __A         =	AutoTokenizer.from_pretrained(UpperCamelCase_				)
         self.assertIsInstance(UpperCamelCase_ ,	UpperCamelCase_				)


class       __lowercase      (	unittest.TestCase  ):







     '''simple docstring'''




     def 		lowerCAmelCase_     (				self       :			List[Any]				):


         """simple docstring"""



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












def 			_SCREAMING_SNAKE_CASE						( __lowercase   :			List[Any]			,				__lowercase   :			Dict			,				__lowercase   :			str    )						->      Dict:





    """simple docstring"""

    if n == 0:
        return 1

    elif n % 2 == 1:
        return (binary_exponentiation(__lowercase			,				n - 1			,				__lowercase    ) * a) % mod

    else:
        __A         =	binary_exponentiation(__lowercase			,				n / 2			,				__lowercase    )
        return (b * b) % mod


# a prime number
__a      :       Union[str, Any]				  =   701

__a      :       Dict				  =   1000000000
__a      :       Union[str, Any]				  =   10

# using binary exponentiation function, O(log(p)):
print((a / b) % p == (a * binary_exponentiation(b, p - 2, p)) % p)






print((a / b) % p == (a * b ** (p - 2)) % p)




