


"""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			:  List[str]           =		BertJapaneseTokenizer
      a			:  Optional[Any]           =		False
      a			:  Optional[int]           =		True
      def SCREAMING_SNAKE_CASE_						(		self						:						List[str]				):






       '''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						:						str   ,							A_						:						List[str]				):






       '''simple docstring'''


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






       '''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						:						Union[str, Any]				):






       '''simple docstring'''


       pass  # TODO add if relevant
      def SCREAMING_SNAKE_CASE_						(		self						:						List[Any]				):






       '''simple docstring'''


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






       '''simple docstring'''


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






       '''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						:						List[str]				):






       '''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						:						Optional[int]				):






       '''simple docstring'''


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

       self.assertListEqual(
           tokenizer.tokenize(""" \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  """				)   ,							["""アップルストア""", """で""", """iPhone""", """8""", """が""", """発売""", """さ""", """れ""", """た""", """。"""]   ,							)
      def SCREAMING_SNAKE_CASE_						(		self						:						List[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						:						str				):






       '''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						:						Dict				):






       '''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						:						List[str]				):






       '''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						:						str				):






       '''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						:						Tuple				):






       '''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						:						Optional[Any]				):






       '''simple docstring'''


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

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






       '''simple docstring'''


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

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






       '''simple docstring'''


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

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






       '''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						:						int				):






       '''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						:						List[Any]				):






       '''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						:						Any				):






       '''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						:						Tuple				):






       '''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						:						List[Any]				):






       '''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						:						Tuple				):






       '''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						:						str				):






       '''simple docstring'''


       __lowercase						=						JumanppTokenizer(trim_whitespace=A_				)

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






       '''simple docstring'''


       __lowercase						=						JumanppTokenizer()

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






       '''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						:						Any				):






       '''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						:						Optional[int]				):






       '''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			:  Union[str, Any]           =		BertJapaneseTokenizer
      a			:  Any           =		False
      def SCREAMING_SNAKE_CASE_						(		self						:						str				):






       '''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						:						Union[str, Any]   ,							**A_						:						Dict				):






       '''simple docstring'''


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






       '''simple docstring'''


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






       '''simple docstring'''


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






       '''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						:						Any				):






       '''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						:						str				):






       '''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"""

from pathlib import Path

import cva
import numpy as np
from matplotlib import pyplot as plt


def lowerCAmelCase_   (					UpperCamelCase__						:			np.ndarray					, UpperCamelCase__						:			np.ndarray					, UpperCamelCase__						:			np.ndarray					, UpperCamelCase__						:			int					, UpperCamelCase__						:			int			):






 """simple docstring"""







 __lowercase						=						cva.getAffineTransform(UpperCamelCase__					, UpperCamelCase__			)
 return cva.warpAffine(UpperCamelCase__					, UpperCamelCase__					, (rows, cols)			)


if __name__ == "__main__":
       # read original image
       UpperCAmelCase__					=cva.imread(
           str(Path(__file__).resolve().parent.parent / "image_data" / "lena.jpg")
       )
       # turn image in gray scale value
       UpperCAmelCase__					=cva.cvtColor(image, cva.COLOR_BGR2GRAY)
       # get image shape
       UpperCAmelCase__				,   UpperCAmelCase__					=gray_img.shape

       # set different points to rotate image
       UpperCAmelCase__					=np.array([[50, 50], [200, 50], [50, 200]], np.floataa)
       UpperCAmelCase__					=np.array([[10, 100], [200, 50], [100, 250]], np.floataa)
       UpperCAmelCase__					=np.array([[50, 50], [150, 50], [120, 200]], np.floataa)
       UpperCAmelCase__					=np.array([[10, 100], [80, 50], [180, 250]], np.floataa)

       # add all rotated images in a list
       UpperCAmelCase__					=[
           gray_img,
           get_rotation(gray_img, ptsa, ptsa, img_rows, img_cols),
           get_rotation(gray_img, ptsa, ptsa, img_rows, img_cols),
           get_rotation(gray_img, ptsa, ptsa, img_rows, img_cols),
       ]

       # plot different image rotations
       UpperCAmelCase__					=plt.figure(1)
       UpperCAmelCase__					=["Original", "Rotation 1", "Rotation 2", "Rotation 3"]
       for i, image in enumerate(images):
              plt.subplot(2, 2, i + 1), plt.imshow(image, "gray")
              plt.title(titles[i])
              plt.axis("off")
              plt.subplots_adjust(left=0.0, bottom=0.05, right=1.0, top=0.95)
       plt.show()
