






"""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      _lowercase (     __SCREAMING_SNAKE_CASE		,  unittest.TestCase						):
      _a   :     List[Any]								=   BertJapaneseTokenizer
      _a   :     Tuple								=   False
      _a   :     Optional[Any]								=   True


      def _UpperCamelCase						(    self				:	Any						):





            """simple docstring"""







            super().setUp()

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

            __snake_case      :    Union[str, Any]  			=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				:	Dict							,   a				:	Union[str, Any]						):





            """simple docstring"""







            __snake_case      :    List[Any]  			='''こんにちは、世界。 \nこんばんは、世界。'''
            __snake_case      :    Any  			='''こんにちは 、 世界 。 こんばんは 、 世界 。'''
            return input_text, output_text


      def _UpperCamelCase						(    self				:	Optional[int]							,   a				:	int						):





            """simple docstring"""







            __snake_case			,				__snake_case      :    Tuple  			=self.get_input_output_texts(_a						)
            __snake_case      :    Optional[Any]  			=tokenizer.encode(_a							,   add_special_tokens=_a						)
            __snake_case      :    Optional[int]  			=tokenizer.decode(_a							,   clean_up_tokenization_spaces=_a						)
            return text, ids


      def _UpperCamelCase						(    self				:	int						):





            """simple docstring"""







            pass  # TODO add if relevant


      def _UpperCamelCase						(    self				:	str						):





            """simple docstring"""







            pass  # TODO add if relevant


      def _UpperCamelCase						(    self				:	Optional[Any]						):





            """simple docstring"""







            pass  # TODO add if relevant


      def _UpperCamelCase						(    self				:	Optional[int]						):





            """simple docstring"""







            __snake_case      :    Any  			=self.tokenizer_class(self.vocab_file						)

            __snake_case      :    Optional[Any]  			=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 _UpperCamelCase						(    self				:	Tuple						):





            """simple docstring"""







            __snake_case      :    Optional[Any]  			=self.tokenizer_class(self.vocab_file							,   word_tokenizer_type='''mecab'''						)
            self.assertIsNotNone(_a						)

            __snake_case      :    Dict  			='''こんにちは、世界。\nこんばんは、世界。'''
            __snake_case      :    List[str]  			=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]						)

            __snake_case      :    str  			=os.path.join(self.tmpdirname							,   '''tokenizer.bin'''						)
            with open(_a							,   '''wb'''						) as handle:
                  pickle.dump(_a							,   _a						)

            with open(_a							,   '''rb'''						) as handle:
                  __snake_case      :    Optional[int]  			=pickle.load(_a						)

            __snake_case      :    Optional[int]  			=tokenizer_new.tokenize(_a						)

            self.assertListEqual(_a							,   _a						)


      def _UpperCamelCase						(    self				:	str						):





            """simple docstring"""







            __snake_case      :    Optional[int]  			=MecabTokenizer(mecab_dic='''ipadic'''						)

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


      def _UpperCamelCase						(    self				:	Any						):





            """simple docstring"""







            try:
                  __snake_case      :    Optional[int]  			=MecabTokenizer(mecab_dic='''unidic_lite'''						)
            except ModuleNotFoundError:
                  return

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


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





            """simple docstring"""







            try:
                  __snake_case      :    Union[str, Any]  			=MecabTokenizer(mecab_dic='''unidic'''						)
            except ModuleNotFoundError:
                  return

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


      def _UpperCamelCase						(    self				:	Optional[Any]						):





            """simple docstring"""







            __snake_case      :    Any  			=MecabTokenizer(do_lower_case=_a							,   mecab_dic='''ipadic'''						)

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


      def _UpperCamelCase						(    self				:	Any						):





            """simple docstring"""







            try:
                  __snake_case      :    Union[str, Any]  			=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 _UpperCamelCase						(    self				:	Dict						):





            """simple docstring"""







            __snake_case      :    List[Any]  			=MecabTokenizer(normalize_text=_a							,   mecab_dic='''ipadic'''						)

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


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





            """simple docstring"""







            __snake_case      :    Tuple  			=self.tokenizer_class(self.vocab_file							,   word_tokenizer_type='''sudachi'''						)
            self.assertIsNotNone(_a						)

            __snake_case      :    Optional[int]  			='''こんにちは、世界。\nこんばんは、世界。'''
            __snake_case      :    Optional[Any]  			=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]						)

            __snake_case      :    str  			=os.path.join(self.tmpdirname							,   '''tokenizer.bin'''						)
            with open(_a							,   '''wb'''						) as handle:
                  pickle.dump(_a							,   _a						)

            with open(_a							,   '''rb'''						) as handle:
                  __snake_case      :    List[Any]  			=pickle.load(_a						)

            __snake_case      :    Union[str, Any]  			=tokenizer_new.tokenize(_a						)

            self.assertListEqual(_a							,   _a						)


      @require_sudachi
      def _UpperCamelCase						(    self				:	Any						):





            """simple docstring"""







            __snake_case      :    str  			=SudachiTokenizer(sudachi_dict_type='''core'''						)

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


      @require_sudachi
      def _UpperCamelCase						(    self				:	Dict						):





            """simple docstring"""







            __snake_case      :    Union[str, Any]  			=SudachiTokenizer(sudachi_dict_type='''core'''							,   sudachi_split_mode='''A'''						)

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


      @require_sudachi
      def _UpperCamelCase						(    self				:	Dict						):





            """simple docstring"""







            __snake_case      :    Any  			=SudachiTokenizer(sudachi_dict_type='''core'''							,   sudachi_split_mode='''B'''						)

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


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





            """simple docstring"""







            __snake_case      :    List[str]  			=SudachiTokenizer(sudachi_dict_type='''core'''							,   sudachi_split_mode='''C'''						)

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


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





            """simple docstring"""







            __snake_case      :    str  			=SudachiTokenizer(do_lower_case=_a							,   sudachi_dict_type='''core'''						)

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


      @require_sudachi
      def _UpperCamelCase						(    self				:	int						):





            """simple docstring"""







            __snake_case      :    str  			=SudachiTokenizer(normalize_text=_a							,   sudachi_dict_type='''core'''						)

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


      @require_sudachi
      def _UpperCamelCase						(    self				:	int						):





            """simple docstring"""







            __snake_case      :    Dict  			=SudachiTokenizer(trim_whitespace=_a							,   sudachi_dict_type='''core'''						)

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


      @require_jumanpp
      def _UpperCamelCase						(    self				:	Dict						):





            """simple docstring"""







            __snake_case      :    List[str]  			=self.tokenizer_class(self.vocab_file							,   word_tokenizer_type='''jumanpp'''						)
            self.assertIsNotNone(_a						)

            __snake_case      :    Optional[Any]  			='''こんにちは、世界。\nこんばんは、世界。'''
            __snake_case      :    Optional[int]  			=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]						)

            __snake_case      :    str  			=os.path.join(self.tmpdirname							,   '''tokenizer.bin'''						)
            with open(_a							,   '''wb'''						) as handle:
                  pickle.dump(_a							,   _a						)

            with open(_a							,   '''rb'''						) as handle:
                  __snake_case      :    Dict  			=pickle.load(_a						)

            __snake_case      :    str  			=tokenizer_new.tokenize(_a						)

            self.assertListEqual(_a							,   _a						)


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





            """simple docstring"""







            __snake_case      :    Dict  			=JumanppTokenizer()

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


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





            """simple docstring"""







            __snake_case      :    Any  			=JumanppTokenizer(do_lower_case=_a						)

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


      @require_jumanpp
      def _UpperCamelCase						(    self				:	Any						):





            """simple docstring"""







            __snake_case      :    int  			=JumanppTokenizer(normalize_text=_a						)

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


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





            """simple docstring"""







            __snake_case      :    Any  			=JumanppTokenizer(trim_whitespace=_a						)

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


      @require_jumanpp
      def _UpperCamelCase						(    self				:	Tuple						):





            """simple docstring"""







            __snake_case      :    str  			=JumanppTokenizer()

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


      def _UpperCamelCase						(    self				:	Dict						):





            """simple docstring"""







            __snake_case      :    Optional[Any]  			=['''[UNK]''', '''[CLS]''', '''[SEP]''', '''こんにちは''', '''こん''', '''にちは''', '''ばんは''', '''##こん''', '''##にちは''', '''##ばんは''']

            __snake_case      :    str  			={}
            for i, token in enumerate(_a						):
                  __snake_case      :    str  			=i
            __snake_case      :    List[Any]  			=WordpieceTokenizer(vocab=_a							,   unk_token='''[UNK]'''						)

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

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

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

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


      def _UpperCamelCase						(    self				:	List[Any]						):





            """simple docstring"""







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

            __snake_case      :    Optional[int]  			=subword_tokenizer.tokenize('''国境 の 長い トンネル を 抜ける と 雪国 であった 。'''						)
            self.assertListEqual(_a							,   ['''▁国境''', '''▁の''', '''▁長い''', '''▁トンネル''', '''▁を''', '''▁抜ける''', '''▁と''', '''▁雪''', '''国''', '''▁であった''', '''▁。''']						)

            __snake_case      :    Union[str, Any]  			=subword_tokenizer.tokenize('''こんばんは こんばん にち は こんにちは'''						)
            self.assertListEqual(_a							,   ['''▁こん''', '''ばん''', '''は''', '''▁こん''', '''ばん''', '''▁に''', '''ち''', '''▁は''', '''▁こんにちは''']						)







      def _UpperCamelCase						(    self				:	Optional[Any]						):





            """simple docstring"""







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

            __snake_case      :    Optional[int]  			=tokenizer.encode('''ありがとう。'''							,   add_special_tokens=_a						)
            __snake_case      :    int  			=tokenizer.encode('''どういたしまして。'''							,   add_special_tokens=_a						)

            __snake_case      :    Any  			=tokenizer.build_inputs_with_special_tokens(_a						)
            __snake_case      :    int  			=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      _lowercase (     __SCREAMING_SNAKE_CASE		,  unittest.TestCase						):
      _a   :     Tuple								=   BertJapaneseTokenizer
      _a   :     List[str]								=   False


      def _UpperCamelCase						(    self				:	Optional[int]						):





            """simple docstring"""







            super().setUp()

            __snake_case      :    int  			=['''[UNK]''', '''[CLS]''', '''[SEP]''', '''こ''', '''ん''', '''に''', '''ち''', '''は''', '''ば''', '''世''', '''界''', '''、''', '''。''']

            __snake_case      :    Optional[int]  			=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				:	Tuple							,   **a				:	Union[str, Any]						):





            """simple docstring"""







            return BertJapaneseTokenizer.from_pretrained(self.tmpdirname							,   subword_tokenizer_type='''character'''							,   **_a						)


      def _UpperCamelCase						(    self				:	Tuple							,   a				:	str						):





            """simple docstring"""







            __snake_case      :    List[Any]  			='''こんにちは、世界。 \nこんばんは、世界。'''
            __snake_case      :    str  			='''こ ん に ち は 、 世 界 。 こ ん ば ん は 、 世 界 。'''
            return input_text, output_text


      def _UpperCamelCase						(    self				:	List[Any]						):





            """simple docstring"""







            pass  # TODO add if relevant


      def _UpperCamelCase						(    self				:	int						):





            """simple docstring"""







            pass  # TODO add if relevant


      def _UpperCamelCase						(    self				:	Tuple						):





            """simple docstring"""







            pass  # TODO add if relevant


      def _UpperCamelCase						(    self				:	List[str]						):





            """simple docstring"""







            __snake_case      :    str  			=self.tokenizer_class(self.vocab_file							,   subword_tokenizer_type='''character'''						)

            __snake_case      :    int  			=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 _UpperCamelCase						(    self				:	int						):





            """simple docstring"""







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

            __snake_case      :    int  			={}
            for i, token in enumerate(_a						):
                  __snake_case      :    Optional[Any]  			=i
            __snake_case      :    List[Any]  			=CharacterTokenizer(vocab=_a							,   unk_token='''[UNK]'''						)

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

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

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







      def _UpperCamelCase						(    self				:	Optional[int]						):





            """simple docstring"""







            __snake_case      :    Union[str, Any]  			=self.tokenizer_class.from_pretrained('''cl-tohoku/bert-base-japanese-char'''						)

            __snake_case      :    Tuple  			=tokenizer.encode('''ありがとう。'''							,   add_special_tokens=_a						)
            __snake_case      :    List[str]  			=tokenizer.encode('''どういたしまして。'''							,   add_special_tokens=_a						)

            __snake_case      :    Optional[int]  			=tokenizer.build_inputs_with_special_tokens(_a						)
            __snake_case      :    Optional[int]  			=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      _lowercase (     unittest.TestCase						):


      def _UpperCamelCase						(    self				:	str						):





            """simple docstring"""







            __snake_case      :    Tuple  			='''cl-tohoku/bert-base-japanese'''
            __snake_case      :    List[str]  			=AutoTokenizer.from_pretrained(_a						)
            self.assertIsInstance(_a							,   _a						)



class      _lowercase (     unittest.TestCase						):


      def _UpperCamelCase						(    self				:	Optional[int]						):





            """simple docstring"""







            __snake_case      :    List[Any]  			='''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.'''						)						)
            __snake_case      :    Tuple  			='''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"""





import unittest

import numpy as np

from transformers.testing_utils import is_flaky, require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
    import torch

if is_vision_available():
    from PIL import Image

    from transformers import DonutImageProcessor


class      _lowercase (     unittest.TestCase						):


      def __init__(    self				:	List[Any]							,   a				:	int							,   a				:	Dict=7							,   a				:	int=3							,   a				:	int=1_8							,   a				:	Dict=3_0							,   a				:	Dict=4_0_0							,   a				:	Optional[Any]=True							,   a				:	Dict=None							,   a				:	int=True							,   a				:	Dict=False							,   a				:	int=True							,   a				:	str=True							,   a				:	List[str]=[0.5, 0.5, 0.5]							,   a				:	Optional[Any]=[0.5, 0.5, 0.5]							,   ):





            """simple docstring"""







            __snake_case      :    List[Any]  			=parent
            __snake_case      :    List[Any]  			=batch_size
            __snake_case      :    str  			=num_channels
            __snake_case      :    Dict  			=image_size
            __snake_case      :    str  			=min_resolution
            __snake_case      :    Tuple  			=max_resolution
            __snake_case      :    str  			=do_resize
            __snake_case      :    Any  			=size if size is not None else {'''height''': 1_8, '''width''': 2_0}
            __snake_case      :    List[Any]  			=do_thumbnail
            __snake_case      :    Tuple  			=do_align_axis
            __snake_case      :    Any  			=do_pad
            __snake_case      :    Dict  			=do_normalize
            __snake_case      :    List[Any]  			=image_mean
            __snake_case      :    Any  			=image_std







      def _UpperCamelCase						(    self				:	str						):





            """simple docstring"""







            return {
                "do_resize": self.do_resize,
                "size": self.size,
                "do_thumbnail": self.do_thumbnail,
                "do_align_long_axis": self.do_align_axis,
                "do_pad": self.do_pad,
                "do_normalize": self.do_normalize,
                "image_mean": self.image_mean,
                "image_std": self.image_std,
            }



@require_torch
@require_vision
class      _lowercase (     lowerCAmelCase		,  unittest.TestCase						):
      _a   :     str								=   DonutImageProcessor if is_vision_available() else None


      def _UpperCamelCase						(    self				:	Optional[int]						):





            """simple docstring"""







            __snake_case      :    Optional[Any]  			=DonutImageProcessingTester(self						)


      @property
      def _UpperCamelCase						(    self				:	Optional[int]						):





            """simple docstring"""







            return self.image_processor_tester.prepare_image_processor_dict()


      def _UpperCamelCase						(    self				:	List[str]						):





            """simple docstring"""







            __snake_case      :    Optional[Any]  			=self.image_processing_class(**self.image_processor_dict						)
            self.assertTrue(hasattr(a							,   '''do_resize'''						)						)
            self.assertTrue(hasattr(a							,   '''size'''						)						)
            self.assertTrue(hasattr(a							,   '''do_thumbnail'''						)						)
            self.assertTrue(hasattr(a							,   '''do_align_long_axis'''						)						)
            self.assertTrue(hasattr(a							,   '''do_pad'''						)						)
            self.assertTrue(hasattr(a							,   '''do_normalize'''						)						)
            self.assertTrue(hasattr(a							,   '''image_mean'''						)						)
            self.assertTrue(hasattr(a							,   '''image_std'''						)						)


      def _UpperCamelCase						(    self				:	Tuple						):





            """simple docstring"""







            __snake_case      :    Dict  			=self.image_processing_class.from_dict(self.image_processor_dict						)
            self.assertEqual(image_processor.size							,   {'''height''': 1_8, '''width''': 2_0}						)

            __snake_case      :    List[Any]  			=self.image_processing_class.from_dict(self.image_processor_dict							,   size=4_2						)
            self.assertEqual(image_processor.size							,   {'''height''': 4_2, '''width''': 4_2}						)

            # Previous config had dimensions in (width, height) order
            __snake_case      :    Tuple  			=self.image_processing_class.from_dict(self.image_processor_dict							,   size=(4_2, 8_4)						)
            self.assertEqual(image_processor.size							,   {'''height''': 8_4, '''width''': 4_2}						)


      def _UpperCamelCase						(    self				:	Any						):





            """simple docstring"""







            pass


      @is_flaky()
      def _UpperCamelCase						(    self				:	Union[str, Any]						):





            """simple docstring"""







            __snake_case      :    List[Any]  			=self.image_processing_class(**self.image_processor_dict						)
            # create random PIL images
            __snake_case      :    List[Any]  			=prepare_image_inputs(self.image_processor_tester							,   equal_resolution=a						)
            for image in image_inputs:
                  self.assertIsInstance(a							,   Image.Image						)

            # Test not batched input
            __snake_case      :    str  			=image_processing(image_inputs[0]							,   return_tensors='''pt'''						).pixel_values
            self.assertEqual(
                encoded_images.shape							,   (
                    1,
                    self.image_processor_tester.num_channels,
                    self.image_processor_tester.size['''height'''],
                    self.image_processor_tester.size['''width'''],
                )							,   )

            # Test batched
            __snake_case      :    Optional[int]  			=image_processing(a							,   return_tensors='''pt'''						).pixel_values
            self.assertEqual(
                encoded_images.shape							,   (
                    self.image_processor_tester.batch_size,
                    self.image_processor_tester.num_channels,
                    self.image_processor_tester.size['''height'''],
                    self.image_processor_tester.size['''width'''],
                )							,   )


      @is_flaky()
      def _UpperCamelCase						(    self				:	Tuple						):





            """simple docstring"""







            __snake_case      :    Tuple  			=self.image_processing_class(**self.image_processor_dict						)
            # create random numpy tensors
            __snake_case      :    Optional[int]  			=prepare_image_inputs(self.image_processor_tester							,   equal_resolution=a							,   numpify=a						)
            for image in image_inputs:
                  self.assertIsInstance(a							,   np.ndarray						)

            # Test not batched input
            __snake_case      :    List[Any]  			=image_processing(image_inputs[0]							,   return_tensors='''pt'''						).pixel_values
            self.assertEqual(
                encoded_images.shape							,   (
                    1,
                    self.image_processor_tester.num_channels,
                    self.image_processor_tester.size['''height'''],
                    self.image_processor_tester.size['''width'''],
                )							,   )

            # Test batched
            __snake_case      :    int  			=image_processing(a							,   return_tensors='''pt'''						).pixel_values
            self.assertEqual(
                encoded_images.shape							,   (
                    self.image_processor_tester.batch_size,
                    self.image_processor_tester.num_channels,
                    self.image_processor_tester.size['''height'''],
                    self.image_processor_tester.size['''width'''],
                )							,   )







      @is_flaky()
      def _UpperCamelCase						(    self				:	List[str]						):





            """simple docstring"""







            __snake_case      :    Dict  			=self.image_processing_class(**self.image_processor_dict						)
            # create random PyTorch tensors
            __snake_case      :    Dict  			=prepare_image_inputs(self.image_processor_tester							,   equal_resolution=a							,   torchify=a						)
            for image in image_inputs:
                  self.assertIsInstance(a							,   torch.Tensor						)

            # Test not batched input
            __snake_case      :    Dict  			=image_processing(image_inputs[0]							,   return_tensors='''pt'''						).pixel_values
            self.assertEqual(
                encoded_images.shape							,   (
                    1,
                    self.image_processor_tester.num_channels,
                    self.image_processor_tester.size['''height'''],
                    self.image_processor_tester.size['''width'''],
                )							,   )

            # Test batched
            __snake_case      :    Optional[int]  			=image_processing(a							,   return_tensors='''pt'''						).pixel_values
            self.assertEqual(
                encoded_images.shape							,   (
                    self.image_processor_tester.batch_size,
                    self.image_processor_tester.num_channels,
                    self.image_processor_tester.size['''height'''],
                    self.image_processor_tester.size['''width'''],
                )							,   )


