


"""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    lowerCamelCase__						(		_a			,   unittest.TestCase    ):
      a :     Any											=		BertJapaneseTokenizer
      a :     List[Any]											=		False
      a :     List[Any]											=		True
      def SCREAMING_SNAKE_CASE_	(		self	:	Tuple							):






       '''simple docstring'''


       super().setUp()

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

       __lowercase									=	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 SCREAMING_SNAKE_CASE_	(		self	:	int      ,       A_	:	Optional[int]							):






       '''simple docstring'''


       __lowercase									=	"""こんにちは、世界。 \nこんばんは、世界。"""
       __lowercase									=	"""こんにちは 、 世界 。 こんばんは 、 世界 。"""
       return input_text, output_text
      def SCREAMING_SNAKE_CASE_	(		self	:	List[str]      ,       A_	:	Tuple							):






       '''simple docstring'''


       __lowercase							,		__lowercase									=	self.get_input_output_texts(A_							)
       __lowercase									=	tokenizer.encode(A_      ,       add_special_tokens=A_							)
       __lowercase									=	tokenizer.decode(A_      ,       clean_up_tokenization_spaces=A_							)
       return text, ids
      def SCREAMING_SNAKE_CASE_	(		self	:	List[Any]							):






       '''simple docstring'''


       pass  # TODO add if relevant
      def SCREAMING_SNAKE_CASE_	(		self	:	Dict							):






       '''simple docstring'''


       pass  # TODO add if relevant
      def SCREAMING_SNAKE_CASE_	(		self	:	Dict							):






       '''simple docstring'''


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






       '''simple docstring'''


       __lowercase									=	self.tokenizer_class(self.vocab_file							)

       __lowercase									=	tokenizer.tokenize("""こんにちは、世界。\nこんばんは、世界。"""							)
       self.assertListEqual(A_      ,       ["""こんにちは""", """、""", """世界""", """。""", """こん""", """##ばんは""", """、""", """世界""", """。"""]							)
       self.assertListEqual(tokenizer.convert_tokens_to_ids(A_							)      ,       [3, 1_2, 1_0, 1_4, 4, 9, 1_2, 1_0, 1_4]							)
      def SCREAMING_SNAKE_CASE_	(		self	:	Optional[int]							):






       '''simple docstring'''


       __lowercase									=	self.tokenizer_class(self.vocab_file      ,       word_tokenizer_type="""mecab"""							)
       self.assertIsNotNone(A_							)

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

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

       with open(A_      ,       """rb"""							) as handle:
        __lowercase									=	pickle.load(A_							)

       __lowercase									=	tokenizer_new.tokenize(A_							)

       self.assertListEqual(A_      ,       A_							)
      def SCREAMING_SNAKE_CASE_	(		self	:	List[Any]							):






       '''simple docstring'''


       __lowercase									=	MecabTokenizer(mecab_dic="""ipadic"""							)

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






       '''simple docstring'''


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

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






       '''simple docstring'''


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

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






       '''simple docstring'''


       __lowercase									=	MecabTokenizer(do_lower_case=A_      ,       mecab_dic="""ipadic"""							)

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






       '''simple docstring'''


       try:
        __lowercase									=	MecabTokenizer(
            do_lower_case=A_      ,       normalize_text=A_      ,       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 SCREAMING_SNAKE_CASE_	(		self	:	Any							):






       '''simple docstring'''


       __lowercase									=	MecabTokenizer(normalize_text=A_      ,       mecab_dic="""ipadic"""							)

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






       '''simple docstring'''


       __lowercase									=	self.tokenizer_class(self.vocab_file      ,       word_tokenizer_type="""sudachi"""							)
       self.assertIsNotNone(A_							)

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

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

       with open(A_      ,       """rb"""							) as handle:
        __lowercase									=	pickle.load(A_							)

       __lowercase									=	tokenizer_new.tokenize(A_							)

       self.assertListEqual(A_      ,       A_							)
      @require_sudachi
      def SCREAMING_SNAKE_CASE_	(		self	:	int							):






       '''simple docstring'''


       __lowercase									=	SudachiTokenizer(sudachi_dict_type="""core"""							)

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






       '''simple docstring'''


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

       self.assertListEqual(tokenizer.tokenize("""外国人参政権"""							)      ,       ["""外国""", """人""", """参政""", """権"""]							)
      @require_sudachi
      def SCREAMING_SNAKE_CASE_	(		self	:	List[Any]							):






       '''simple docstring'''


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

       self.assertListEqual(tokenizer.tokenize("""外国人参政権"""							)      ,       ["""外国人""", """参政権"""]							)
      @require_sudachi
      def SCREAMING_SNAKE_CASE_	(		self	:	Optional[int]							):






       '''simple docstring'''


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

       self.assertListEqual(tokenizer.tokenize("""外国人参政権"""							)      ,       ["""外国人参政権"""]							)
      @require_sudachi
      def SCREAMING_SNAKE_CASE_	(		self	:	Optional[Any]							):






       '''simple docstring'''


       __lowercase									=	SudachiTokenizer(do_lower_case=A_      ,       sudachi_dict_type="""core"""							)

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






       '''simple docstring'''


       __lowercase									=	SudachiTokenizer(normalize_text=A_      ,       sudachi_dict_type="""core"""							)

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






       '''simple docstring'''


       __lowercase									=	SudachiTokenizer(trim_whitespace=A_      ,       sudachi_dict_type="""core"""							)

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






       '''simple docstring'''


       __lowercase									=	self.tokenizer_class(self.vocab_file      ,       word_tokenizer_type="""jumanpp"""							)
       self.assertIsNotNone(A_							)

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

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

       with open(A_      ,       """rb"""							) as handle:
        __lowercase									=	pickle.load(A_							)

       __lowercase									=	tokenizer_new.tokenize(A_							)

       self.assertListEqual(A_      ,       A_							)
      @require_jumanpp
      def SCREAMING_SNAKE_CASE_	(		self	:	Union[str, Any]							):






       '''simple docstring'''


       __lowercase									=	JumanppTokenizer()

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






       '''simple docstring'''


       __lowercase									=	JumanppTokenizer(do_lower_case=A_							)

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






       '''simple docstring'''


       __lowercase									=	JumanppTokenizer(normalize_text=A_							)

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






       '''simple docstring'''


       __lowercase									=	JumanppTokenizer(trim_whitespace=A_							)

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






       '''simple docstring'''


       __lowercase									=	JumanppTokenizer()

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






       '''simple docstring'''


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

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

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

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

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

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






       '''simple docstring'''


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

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

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






      def SCREAMING_SNAKE_CASE_	(		self	:	str							):






       '''simple docstring'''


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

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

       __lowercase									=	tokenizer.build_inputs_with_special_tokens(A_							)
       __lowercase									=	tokenizer.build_inputs_with_special_tokens(A_      ,       A_							)

       # 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    lowerCamelCase__						(		_a			,   unittest.TestCase    ):
      a :     Optional[int]											=		BertJapaneseTokenizer
      a :     List[str]											=		False
      def SCREAMING_SNAKE_CASE_	(		self	:	Dict							):






       '''simple docstring'''


       super().setUp()

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

       __lowercase									=	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 SCREAMING_SNAKE_CASE_	(		self	:	List[Any]      ,       **A_	:	List[str]							):






       '''simple docstring'''


       return BertJapaneseTokenizer.from_pretrained(self.tmpdirname      ,       subword_tokenizer_type="""character"""      ,       **A_							)
      def SCREAMING_SNAKE_CASE_	(		self	:	Dict      ,       A_	:	Dict							):






       '''simple docstring'''


       __lowercase									=	"""こんにちは、世界。 \nこんばんは、世界。"""
       __lowercase									=	"""こ ん に ち は 、 世 界 。 こ ん ば ん は 、 世 界 。"""
       return input_text, output_text
      def SCREAMING_SNAKE_CASE_	(		self	:	Any							):






       '''simple docstring'''


       pass  # TODO add if relevant
      def SCREAMING_SNAKE_CASE_	(		self	:	str							):






       '''simple docstring'''


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






       '''simple docstring'''


       pass  # TODO add if relevant
      def SCREAMING_SNAKE_CASE_	(		self	:	str							):






       '''simple docstring'''


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

       __lowercase									=	tokenizer.tokenize("""こんにちは、世界。 \nこんばんは、世界。"""							)
       self.assertListEqual(
           A_      ,       ["""こ""", """ん""", """に""", """ち""", """は""", """、""", """世""", """界""", """。""", """こ""", """ん""", """ば""", """ん""", """は""", """、""", """世""", """界""", """。"""]							)
       self.assertListEqual(
           tokenizer.convert_tokens_to_ids(A_							)      ,       [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 SCREAMING_SNAKE_CASE_	(		self	:	int							):






       '''simple docstring'''


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

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

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

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

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






      def SCREAMING_SNAKE_CASE_	(		self	:	Optional[int]							):






       '''simple docstring'''


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

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

       __lowercase									=	tokenizer.build_inputs_with_special_tokens(A_							)
       __lowercase									=	tokenizer.build_inputs_with_special_tokens(A_      ,       A_							)

       # 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    lowerCamelCase__						(		unittest.TestCase    ):
      def SCREAMING_SNAKE_CASE_	(		self	:	Optional[int]							):






       '''simple docstring'''


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






class    lowerCamelCase__						(		unittest.TestCase    ):
      def SCREAMING_SNAKE_CASE_	(		self	:	int							):






       '''simple docstring'''


       __lowercase									=	"""cl-tohoku/bert-base-japanese"""
       with self.assertLogs("""transformers"""      ,       level="""WARNING"""							) as cm:
        BertTokenizer.from_pretrained(A_							)
        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."""							)							)
       __lowercase									=	"""bert-base-cased"""
       with self.assertLogs("""transformers"""      ,       level="""WARNING"""							) as cm:
        BertJapaneseTokenizer.from_pretrained(A_							)
        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 lowerCAmelCase_      (				UpperCamelCase__	: int				,   UpperCamelCase__	: list ):






 """simple docstring"""







 _enforce_args(UpperCamelCase__				,   UpperCamelCase__ )
 if n == 0:
  return 0
 __lowercase									=	float("""-inf""" )
 for i in range(1				,   n + 1 ):
  __lowercase									=	max(
      UpperCamelCase__				,   prices[i - 1] + naive_cut_rod_recursive(n - i				,   UpperCamelCase__ ) )

 return max_revue


def lowerCAmelCase_      (				UpperCamelCase__	: int				,   UpperCamelCase__	: list ):






 """simple docstring"""







 _enforce_args(UpperCamelCase__				,   UpperCamelCase__ )
 __lowercase									=	[float("""-inf""" ) for _ in range(n + 1 )]
 return _top_down_cut_rod_recursive(UpperCamelCase__				,   UpperCamelCase__				,   UpperCamelCase__ )


def lowerCAmelCase_      (				UpperCamelCase__	: int				,   UpperCamelCase__	: list				,   UpperCamelCase__	: list ):






 """simple docstring"""







 if max_rev[n] >= 0:
  return max_rev[n]
 elif n == 0:
  return 0
 else:
  __lowercase									=	float("""-inf""" )
  for i in range(1				,   n + 1 ):
   __lowercase									=	max(
       UpperCamelCase__				,   prices[i - 1] + _top_down_cut_rod_recursive(n - i				,   UpperCamelCase__				,   UpperCamelCase__ )				,   )

  __lowercase									=	max_revenue

 return max_rev[n]


def lowerCAmelCase_      (				UpperCamelCase__	: int				,   UpperCamelCase__	: list ):






 """simple docstring"""







 _enforce_args(UpperCamelCase__				,   UpperCamelCase__ )

 # length(max_rev) = n + 1, to accommodate for the revenue obtainable from a rod of
 # length 0.
 __lowercase									=	[float("""-inf""" ) for _ in range(n + 1 )]
 __lowercase									=	0

 for i in range(1				,   n + 1 ):
  __lowercase									=	max_rev[i]
  for j in range(1				,   i + 1 ):
   __lowercase									=	max(UpperCamelCase__				,   prices[j - 1] + max_rev[i - j] )

  __lowercase									=	max_revenue_i

 return max_rev[n]


def lowerCAmelCase_      (				UpperCamelCase__	: int				,   UpperCamelCase__	: list ):






 """simple docstring"""







 if n < 0:
  __lowercase									=	f'''n must be greater than or equal to 0. Got n = {n}'''
  raise ValueError(UpperCamelCase__ )

 if n > len(UpperCamelCase__ ):
  __lowercase									=	(
      """Each integral piece of rod must have a corresponding price. """
      f'''Got n = {n} but length of prices = {len(UpperCamelCase__ )}'''
  )
  raise ValueError(UpperCamelCase__ )


def lowerCAmelCase_      (				):






 """simple docstring"""







 __lowercase									=	[6, 10, 12, 15, 20, 23]
 __lowercase									=	len(UpperCamelCase__ )

 # the best revenue comes from cutting the rod into 6 pieces, each
 # of length 1 resulting in a revenue of 6 * 6 = 36.
 __lowercase									=	36

 __lowercase									=	top_down_cut_rod(UpperCamelCase__				,   UpperCamelCase__ )
 __lowercase									=	bottom_up_cut_rod(UpperCamelCase__				,   UpperCamelCase__ )
 __lowercase									=	naive_cut_rod_recursive(UpperCamelCase__				,   UpperCamelCase__ )

 assert expected_max_revenue == max_rev_top_down
 assert max_rev_top_down == max_rev_bottom_up
 assert max_rev_bottom_up == max_rev_naive


if __name__ == "__main__":
       main()
