
'''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_							(    A					,				unittest.TestCase				):

 '''simple docstring'''
 lowercase_					:    Union[str, Any]				=							BertJapaneseTokenizer
 lowercase_					:    Optional[int]				=							False
 lowercase_					:    Optional[int]				=							True







 def 							UpperCamelCase  (					self		:  List[Any] ):



   '''simple docstring'''




   super().setUp()

   UpperCAmelCase__      :					Union[str, Any]				       =							[
       "[UNK]",
       "[CLS]",
       "[SEP]",
       "こんにちは",
       "こん",
       "にちは",
       "ばんは",
       "##こん",
       "##にちは",
       "##ばんは",
       "世界",
       "##世界",
       "、",
       "##、",
       "。",
       "##。",
   ]

   UpperCAmelCase__      :					str				       =							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		:  Optional[Any]			,				snake_case__		:  int ):



   '''simple docstring'''




   UpperCAmelCase__      :					Union[str, Any]				       =							"こんにちは、世界。 \nこんばんは、世界。"
   UpperCAmelCase__      :					Union[str, Any]				       =							"こんにちは 、 世界 。 こんばんは 、 世界 。"
   return input_text, output_text







 def 							UpperCamelCase  (					self		:  Optional[Any]			,				snake_case__		:  int ):



   '''simple docstring'''




   UpperCAmelCase__       ,			UpperCAmelCase__      :					int				       =							self.get_input_output_texts(snake_case__ )
   UpperCAmelCase__      :					int				       =							tokenizer.encode(snake_case__			,				add_special_tokens=snake_case__ )
   UpperCAmelCase__      :					str				       =							tokenizer.decode(snake_case__			,				clean_up_tokenization_spaces=snake_case__ )
   return text, ids







 def 							UpperCamelCase  (					self		:  int ):



   '''simple docstring'''




   pass  # TODO add if relevant







 def 							UpperCamelCase  (					self		:  Dict ):



   '''simple docstring'''




   pass  # TODO add if relevant







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



   '''simple docstring'''




   pass  # TODO add if relevant







 def 							UpperCamelCase  (					self		:  Optional[Any] ):



   '''simple docstring'''




   UpperCAmelCase__      :					Union[str, Any]				       =							self.tokenizer_class(self.vocab_file )

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







 def 							UpperCamelCase  (					self		:  int ):



   '''simple docstring'''




   UpperCAmelCase__      :					Any				       =							self.tokenizer_class(self.vocab_file			,				word_tokenizer_type="mecab" )
   self.assertIsNotNone(snake_case__ )

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

   UpperCAmelCase__      :					List[Any]				       =							os.path.join(self.tmpdirname			,				"tokenizer.bin" )
   with open(snake_case__			,				"wb" ) as handle:
     pickle.dump(snake_case__			,				snake_case__ )

   with open(snake_case__			,				"rb" ) as handle:
     UpperCAmelCase__      :					Tuple				       =							pickle.load(snake_case__ )

   UpperCAmelCase__      :					int				       =							tokenizer_new.tokenize(snake_case__ )

   self.assertListEqual(snake_case__			,				snake_case__ )







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



   '''simple docstring'''




   UpperCAmelCase__      :					Dict				       =							MecabTokenizer(mecab_dic="ipadic" )

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







 def 							UpperCamelCase  (					self		:  Any ):



   '''simple docstring'''




   try:
     UpperCAmelCase__      :					List[Any]				       =							MecabTokenizer(mecab_dic="unidic_lite" )
   except ModuleNotFoundError:
     return

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







 def 							UpperCamelCase  (					self		:  List[str] ):



   '''simple docstring'''




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

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







 def 							UpperCamelCase  (					self		:  int ):



   '''simple docstring'''




   UpperCAmelCase__      :					List[Any]				       =							MecabTokenizer(do_lower_case=snake_case__			,				mecab_dic="ipadic" )

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







 def 							UpperCamelCase  (					self		:  Any ):



   '''simple docstring'''




   try:
     UpperCAmelCase__      :					List[str]				       =							MecabTokenizer(
         do_lower_case=snake_case__			,				normalize_text=snake_case__			,				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		:  Union[str, Any] ):



   '''simple docstring'''




   UpperCAmelCase__      :					str				       =							MecabTokenizer(normalize_text=snake_case__			,				mecab_dic="ipadic" )

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







 @require_sudachi
 def 							UpperCamelCase  (					self		:  int ):



   '''simple docstring'''




   UpperCAmelCase__      :					int				       =							self.tokenizer_class(self.vocab_file			,				word_tokenizer_type="sudachi" )
   self.assertIsNotNone(snake_case__ )

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

   UpperCAmelCase__      :					List[Any]				       =							os.path.join(self.tmpdirname			,				"tokenizer.bin" )
   with open(snake_case__			,				"wb" ) as handle:
     pickle.dump(snake_case__			,				snake_case__ )

   with open(snake_case__			,				"rb" ) as handle:
     UpperCAmelCase__      :					Any				       =							pickle.load(snake_case__ )

   UpperCAmelCase__      :					Tuple				       =							tokenizer_new.tokenize(snake_case__ )

   self.assertListEqual(snake_case__			,				snake_case__ )







 @require_sudachi
 def 							UpperCamelCase  (					self		:  int ):



   '''simple docstring'''




   UpperCAmelCase__      :					Union[str, Any]				       =							SudachiTokenizer(sudachi_dict_type="core" )

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







 @require_sudachi
 def 							UpperCamelCase  (					self		:  Optional[int] ):



   '''simple docstring'''




   UpperCAmelCase__      :					int				       =							SudachiTokenizer(sudachi_dict_type="core"			,				sudachi_split_mode="A" )

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







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



   '''simple docstring'''




   UpperCAmelCase__      :					Optional[int]				       =							SudachiTokenizer(sudachi_dict_type="core"			,				sudachi_split_mode="B" )

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







 @require_sudachi
 def 							UpperCamelCase  (					self		:  Tuple ):



   '''simple docstring'''




   UpperCAmelCase__      :					Optional[int]				       =							SudachiTokenizer(sudachi_dict_type="core"			,				sudachi_split_mode="C" )

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







 @require_sudachi
 def 							UpperCamelCase  (					self		:  Optional[int] ):



   '''simple docstring'''




   UpperCAmelCase__      :					List[str]				       =							SudachiTokenizer(do_lower_case=snake_case__			,				sudachi_dict_type="core" )

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







 @require_sudachi
 def 							UpperCamelCase  (					self		:  int ):



   '''simple docstring'''




   UpperCAmelCase__      :					List[str]				       =							SudachiTokenizer(normalize_text=snake_case__			,				sudachi_dict_type="core" )

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







 @require_sudachi
 def 							UpperCamelCase  (					self		:  str ):



   '''simple docstring'''




   UpperCAmelCase__      :					Union[str, Any]				       =							SudachiTokenizer(trim_whitespace=snake_case__			,				sudachi_dict_type="core" )

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







 @require_jumanpp
 def 							UpperCamelCase  (					self		:  List[str] ):



   '''simple docstring'''




   UpperCAmelCase__      :					Optional[Any]				       =							self.tokenizer_class(self.vocab_file			,				word_tokenizer_type="jumanpp" )
   self.assertIsNotNone(snake_case__ )

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

   UpperCAmelCase__      :					List[str]				       =							os.path.join(self.tmpdirname			,				"tokenizer.bin" )
   with open(snake_case__			,				"wb" ) as handle:
     pickle.dump(snake_case__			,				snake_case__ )

   with open(snake_case__			,				"rb" ) as handle:
     UpperCAmelCase__      :					Optional[Any]				       =							pickle.load(snake_case__ )

   UpperCAmelCase__      :					List[str]				       =							tokenizer_new.tokenize(snake_case__ )

   self.assertListEqual(snake_case__			,				snake_case__ )







 @require_jumanpp
 def 							UpperCamelCase  (					self		:  str ):



   '''simple docstring'''




   UpperCAmelCase__      :					List[Any]				       =							JumanppTokenizer()

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







 @require_jumanpp
 def 							UpperCamelCase  (					self		:  Any ):



   '''simple docstring'''




   UpperCAmelCase__      :					List[str]				       =							JumanppTokenizer(do_lower_case=snake_case__ )

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







 @require_jumanpp
 def 							UpperCamelCase  (					self		:  Tuple ):



   '''simple docstring'''




   UpperCAmelCase__      :					Tuple				       =							JumanppTokenizer(normalize_text=snake_case__ )

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







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



   '''simple docstring'''




   UpperCAmelCase__      :					Union[str, Any]				       =							JumanppTokenizer(trim_whitespace=snake_case__ )

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







 @require_jumanpp
 def 							UpperCamelCase  (					self		:  Optional[int] ):



   '''simple docstring'''




   UpperCAmelCase__      :					Dict				       =							JumanppTokenizer()

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







 def 							UpperCamelCase  (					self		:  int ):



   '''simple docstring'''




   UpperCAmelCase__      :					Optional[int]				       =							["[UNK]", "[CLS]", "[SEP]", "こんにちは", "こん", "にちは", "ばんは", "##こん", "##にちは", "##ばんは"]

   UpperCAmelCase__      :					List[str]				       =							{}
   for i, token in enumerate(snake_case__ ):
     UpperCAmelCase__      :					Optional[int]				       =							i
   UpperCAmelCase__      :					int				       =							WordpieceTokenizer(vocab=snake_case__			,				unk_token="[UNK]" )

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

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

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

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







 def 							UpperCamelCase  (					self		:  List[str] ):



   '''simple docstring'''




   UpperCAmelCase__      :					str				       =							BertJapaneseTokenizer.from_pretrained("nlp-waseda/roberta-base-japanese-with-auto-jumanpp" )
   UpperCAmelCase__      :					List[str]				       =							tokenizer.subword_tokenizer

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

   UpperCAmelCase__      :					Any				       =							subword_tokenizer.tokenize("こんばんは こんばん にち は こんにちは" )
   self.assertListEqual(snake_case__			,				["▁こん", "ばん", "は", "▁こん", "ばん", "▁に", "ち", "▁は", "▁こんにちは"] )







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



   '''simple docstring'''




   UpperCAmelCase__      :					Any				       =							self.tokenizer_class.from_pretrained("cl-tohoku/bert-base-japanese" )

   UpperCAmelCase__      :					Tuple				       =							tokenizer.encode("ありがとう。"			,				add_special_tokens=snake_case__ )
   UpperCAmelCase__      :					Dict				       =							tokenizer.encode("どういたしまして。"			,				add_special_tokens=snake_case__ )

   UpperCAmelCase__      :					Union[str, Any]				       =							tokenizer.build_inputs_with_special_tokens(snake_case__ )
   UpperCAmelCase__      :					List[str]				       =							tokenizer.build_inputs_with_special_tokens(snake_case__			,				snake_case__ )

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

 '''simple docstring'''
 lowercase_					:    Any				=							BertJapaneseTokenizer
 lowercase_					:    Optional[Any]				=							False







 def 							UpperCamelCase  (					self		:  Any ):



   '''simple docstring'''




   super().setUp()

   UpperCAmelCase__      :					Optional[int]				       =							["[UNK]", "[CLS]", "[SEP]", "こ", "ん", "に", "ち", "は", "ば", "世", "界", "、", "。"]

   UpperCAmelCase__      :					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 							UpperCamelCase  (					self		:  str			,				**snake_case__		:  Dict ):



   '''simple docstring'''




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







 def 							UpperCamelCase  (					self		:  Dict			,				snake_case__		:  Tuple ):



   '''simple docstring'''




   UpperCAmelCase__      :					Dict				       =							"こんにちは、世界。 \nこんばんは、世界。"
   UpperCAmelCase__      :					Tuple				       =							"こ ん に ち は 、 世 界 。 こ ん ば ん は 、 世 界 。"
   return input_text, output_text







 def 							UpperCamelCase  (					self		:  int ):



   '''simple docstring'''




   pass  # TODO add if relevant







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



   '''simple docstring'''




   pass  # TODO add if relevant







 def 							UpperCamelCase  (					self		:  Dict ):



   '''simple docstring'''




   pass  # TODO add if relevant







 def 							UpperCamelCase  (					self		:  List[str] ):



   '''simple docstring'''




   UpperCAmelCase__      :					str				       =							self.tokenizer_class(self.vocab_file			,				subword_tokenizer_type="character" )

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







 def 							UpperCamelCase  (					self		:  Tuple ):



   '''simple docstring'''




   UpperCAmelCase__      :					Optional[Any]				       =							["[UNK]", "[CLS]", "[SEP]", "こ", "ん", "に", "ち", "は", "ば", "世", "界", "、", "。"]

   UpperCAmelCase__      :					Any				       =							{}
   for i, token in enumerate(snake_case__ ):
     UpperCAmelCase__      :					Union[str, Any]				       =							i
   UpperCAmelCase__      :					Any				       =							CharacterTokenizer(vocab=snake_case__			,				unk_token="[UNK]" )

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

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

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







 def 							UpperCamelCase  (					self		:  Tuple ):



   '''simple docstring'''




   UpperCAmelCase__      :					List[str]				       =							self.tokenizer_class.from_pretrained("cl-tohoku/bert-base-japanese-char" )

   UpperCAmelCase__      :					Tuple				       =							tokenizer.encode("ありがとう。"			,				add_special_tokens=snake_case__ )
   UpperCAmelCase__      :					Union[str, Any]				       =							tokenizer.encode("どういたしまして。"			,				add_special_tokens=snake_case__ )

   UpperCAmelCase__      :					Any				       =							tokenizer.build_inputs_with_special_tokens(snake_case__ )
   UpperCAmelCase__      :					int				       =							tokenizer.build_inputs_with_special_tokens(snake_case__			,				snake_case__ )

   # 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				):

 '''simple docstring'''







 def 							UpperCamelCase  (					self		:  Optional[Any] ):



   '''simple docstring'''




   UpperCAmelCase__      :					Union[str, Any]				       =							"cl-tohoku/bert-base-japanese"
   UpperCAmelCase__      :					int				       =							AutoTokenizer.from_pretrained(snake_case__ )
   self.assertIsInstance(snake_case__			,				snake_case__ )






class 							UpperCAmelCase_							(    unittest.TestCase				):

 '''simple docstring'''







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



   '''simple docstring'''




   UpperCAmelCase__      :					Optional[int]				       =							"cl-tohoku/bert-base-japanese"
   with self.assertLogs("transformers"			,				level="WARNING" ) as cm:
     BertTokenizer.from_pretrained(snake_case__ )
     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__      :					int				       =							"bert-base-cased"
   with self.assertLogs("transformers"			,				level="WARNING" ) as cm:
     BertJapaneseTokenizer.from_pretrained(snake_case__ )
     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'''





def snake_case_     (					lowercase__		):
  return sum(i for i in range(1   ,       number // 2 + 1		) if number % i == 0		) == number


if __name__ == "__main__":
      print("""Program to check whether a number is a Perfect number or not...""")
      SCREAMING_SNAKE_CASE     =       int(input("""Enter number: """).strip())
      print(F'{number} is {"" if perfect(number) else "not "}a Perfect Number.')



