





'''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_		(		snake_case_						,unittest.TestCase		):
 __lowerCamelCase						:							List[Any]         =					BertJapaneseTokenizer
 __lowerCamelCase						:							Union[str, Any]         =					False
 __lowerCamelCase						:							str         =					True




 def 							_snake_case   (	self		)    ->							Any:
     super().setUp()

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

     _lowerCAmelCase				=      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 							_snake_case   (	self			,     _lowerCAmelCase		)    ->							str:
     _lowerCAmelCase				=      "こんにちは、世界。 \nこんばんは、世界。"
     _lowerCAmelCase				=      "こんにちは 、 世界 。 こんばんは 、 世界 。"
     return input_text, output_text




 def 							_snake_case   (	self			,     _lowerCAmelCase		)    ->							List[Any]:
     _lowerCAmelCase			,			_lowerCAmelCase				=      self.get_input_output_texts(_lowerCAmelCase		)
     _lowerCAmelCase				=      tokenizer.encode(_lowerCAmelCase			,     add_special_tokens=_lowerCAmelCase		)
     _lowerCAmelCase				=      tokenizer.decode(_lowerCAmelCase			,     clean_up_tokenization_spaces=_lowerCAmelCase		)
     return text, ids




 def 							_snake_case   (	self		)    ->							Tuple:
     pass  # TODO add if relevant




 def 							_snake_case   (	self		)    ->							List[Any]:
     pass  # TODO add if relevant




 def 							_snake_case   (	self		)    ->							Union[str, Any]:
     pass  # TODO add if relevant




 def 							_snake_case   (	self		)    ->							Optional[Any]:
     _lowerCAmelCase				=      self.tokenizer_class(self.vocab_file		)

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




 def 							_snake_case   (	self		)    ->							Optional[Any]:
     _lowerCAmelCase				=      self.tokenizer_class(self.vocab_file			,     word_tokenizer_type="mecab"		)
     self.assertIsNotNone(_lowerCAmelCase		)

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

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

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

     _lowerCAmelCase				=      tokenizer_new.tokenize(_lowerCAmelCase		)

     self.assertListEqual(_lowerCAmelCase			,     _lowerCAmelCase		)




 def 							_snake_case   (	self		)    ->							Dict:
     _lowerCAmelCase				=      MecabTokenizer(mecab_dic="ipadic"		)

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




 def 							_snake_case   (	self		)    ->							List[str]:
     try:
         _lowerCAmelCase				=      MecabTokenizer(mecab_dic="unidic_lite"		)
     except ModuleNotFoundError:
         return

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




 def 							_snake_case   (	self		)    ->							str:
     try:
         _lowerCAmelCase				=      MecabTokenizer(mecab_dic="unidic"		)
     except ModuleNotFoundError:
         return

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




 def 							_snake_case   (	self		)    ->							Optional[int]:
     _lowerCAmelCase				=      MecabTokenizer(do_lower_case=_lowerCAmelCase			,     mecab_dic="ipadic"		)

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




 def 							_snake_case   (	self		)    ->							List[Any]:
     try:
         _lowerCAmelCase				=      MecabTokenizer(
             do_lower_case=_lowerCAmelCase			,     normalize_text=_lowerCAmelCase			,     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 							_snake_case   (	self		)    ->							List[str]:
     _lowerCAmelCase				=      MecabTokenizer(normalize_text=_lowerCAmelCase			,     mecab_dic="ipadic"		)

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




 @require_sudachi
 def 							_snake_case   (	self		)    ->							Tuple:
     _lowerCAmelCase				=      self.tokenizer_class(self.vocab_file			,     word_tokenizer_type="sudachi"		)
     self.assertIsNotNone(_lowerCAmelCase		)

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

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

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

     _lowerCAmelCase				=      tokenizer_new.tokenize(_lowerCAmelCase		)

     self.assertListEqual(_lowerCAmelCase			,     _lowerCAmelCase		)




 @require_sudachi
 def 							_snake_case   (	self		)    ->							int:
     _lowerCAmelCase				=      SudachiTokenizer(sudachi_dict_type="core"		)

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




 @require_sudachi
 def 							_snake_case   (	self		)    ->							Tuple:
     _lowerCAmelCase				=      SudachiTokenizer(sudachi_dict_type="core"			,     sudachi_split_mode="A"		)

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




 @require_sudachi
 def 							_snake_case   (	self		)    ->							Any:
     _lowerCAmelCase				=      SudachiTokenizer(sudachi_dict_type="core"			,     sudachi_split_mode="B"		)

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




 @require_sudachi
 def 							_snake_case   (	self		)    ->							str:
     _lowerCAmelCase				=      SudachiTokenizer(sudachi_dict_type="core"			,     sudachi_split_mode="C"		)

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




 @require_sudachi
 def 							_snake_case   (	self		)    ->							List[str]:
     _lowerCAmelCase				=      SudachiTokenizer(do_lower_case=_lowerCAmelCase			,     sudachi_dict_type="core"		)

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




 @require_sudachi
 def 							_snake_case   (	self		)    ->							str:
     _lowerCAmelCase				=      SudachiTokenizer(normalize_text=_lowerCAmelCase			,     sudachi_dict_type="core"		)

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




 @require_sudachi
 def 							_snake_case   (	self		)    ->							List[str]:
     _lowerCAmelCase				=      SudachiTokenizer(trim_whitespace=_lowerCAmelCase			,     sudachi_dict_type="core"		)

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




 @require_jumanpp
 def 							_snake_case   (	self		)    ->							Any:
     _lowerCAmelCase				=      self.tokenizer_class(self.vocab_file			,     word_tokenizer_type="jumanpp"		)
     self.assertIsNotNone(_lowerCAmelCase		)

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

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

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

     _lowerCAmelCase				=      tokenizer_new.tokenize(_lowerCAmelCase		)

     self.assertListEqual(_lowerCAmelCase			,     _lowerCAmelCase		)




 @require_jumanpp
 def 							_snake_case   (	self		)    ->							Union[str, Any]:
     _lowerCAmelCase				=      JumanppTokenizer()

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




 @require_jumanpp
 def 							_snake_case   (	self		)    ->							int:
     _lowerCAmelCase				=      JumanppTokenizer(do_lower_case=_lowerCAmelCase		)

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




 @require_jumanpp
 def 							_snake_case   (	self		)    ->							str:
     _lowerCAmelCase				=      JumanppTokenizer(normalize_text=_lowerCAmelCase		)

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




 @require_jumanpp
 def 							_snake_case   (	self		)    ->							List[str]:
     _lowerCAmelCase				=      JumanppTokenizer(trim_whitespace=_lowerCAmelCase		)

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




 @require_jumanpp
 def 							_snake_case   (	self		)    ->							int:
     _lowerCAmelCase				=      JumanppTokenizer()

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




 def 							_snake_case   (	self		)    ->							List[str]:
     _lowerCAmelCase				=      ["[UNK]", "[CLS]", "[SEP]", "こんにちは", "こん", "にちは", "ばんは", "##こん", "##にちは", "##ばんは"]

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

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

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

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

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




 def 							_snake_case   (	self		)    ->							Any:
     _lowerCAmelCase				=      BertJapaneseTokenizer.from_pretrained("nlp-waseda/roberta-base-japanese-with-auto-jumanpp"		)
     _lowerCAmelCase				=      tokenizer.subword_tokenizer

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

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





 def 							_snake_case   (	self		)    ->							Dict:
     _lowerCAmelCase				=      self.tokenizer_class.from_pretrained("cl-tohoku/bert-base-japanese"		)

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

     _lowerCAmelCase				=      tokenizer.build_inputs_with_special_tokens(_lowerCAmelCase		)
     _lowerCAmelCase				=      tokenizer.build_inputs_with_special_tokens(_lowerCAmelCase			,     _lowerCAmelCase		)

     # 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_		(		snake_case_						,unittest.TestCase		):
 __lowerCamelCase						:							Dict         =					BertJapaneseTokenizer
 __lowerCamelCase						:							str         =					False




 def 							_snake_case   (	self		)    ->							Any:
     super().setUp()

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

     _lowerCAmelCase				=      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 							_snake_case   (	self			,     **_lowerCAmelCase		)    ->							Any:
     return BertJapaneseTokenizer.from_pretrained(self.tmpdirname			,     subword_tokenizer_type="character"			,     **_lowerCAmelCase		)




 def 							_snake_case   (	self			,     _lowerCAmelCase		)    ->							Tuple:
     _lowerCAmelCase				=      "こんにちは、世界。 \nこんばんは、世界。"
     _lowerCAmelCase				=      "こ ん に ち は 、 世 界 。 こ ん ば ん は 、 世 界 。"
     return input_text, output_text




 def 							_snake_case   (	self		)    ->							Dict:
     pass  # TODO add if relevant




 def 							_snake_case   (	self		)    ->							Tuple:
     pass  # TODO add if relevant




 def 							_snake_case   (	self		)    ->							Dict:
     pass  # TODO add if relevant




 def 							_snake_case   (	self		)    ->							Tuple:
     _lowerCAmelCase				=      self.tokenizer_class(self.vocab_file			,     subword_tokenizer_type="character"		)

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




 def 							_snake_case   (	self		)    ->							Optional[Any]:
     _lowerCAmelCase				=      ["[UNK]", "[CLS]", "[SEP]", "こ", "ん", "に", "ち", "は", "ば", "世", "界", "、", "。"]

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

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

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

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





 def 							_snake_case   (	self		)    ->							str:
     _lowerCAmelCase				=      self.tokenizer_class.from_pretrained("cl-tohoku/bert-base-japanese-char"		)

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

     _lowerCAmelCase				=      tokenizer.build_inputs_with_special_tokens(_lowerCAmelCase		)
     _lowerCAmelCase				=      tokenizer.build_inputs_with_special_tokens(_lowerCAmelCase			,     _lowerCAmelCase		)

     # 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 							_snake_case   (	self		)    ->							Union[str, Any]:
     _lowerCAmelCase				=      "cl-tohoku/bert-base-japanese"
     _lowerCAmelCase				=      AutoTokenizer.from_pretrained(_lowerCAmelCase		)
     self.assertIsInstance(_lowerCAmelCase			,     _lowerCAmelCase		)







class    lowerCAmelCase_		(		unittest.TestCase		):




 def 							_snake_case   (	self		)    ->							Optional[int]:
     _lowerCAmelCase				=      "cl-tohoku/bert-base-japanese"
     with self.assertLogs("transformers"			,     level="WARNING"		) as cm:
         BertTokenizer.from_pretrained(_lowerCAmelCase		)
         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."		)		)
     _lowerCAmelCase				=      "bert-base-cased"
     with self.assertLogs("transformers"			,     level="WARNING"		) as cm:
         BertJapaneseTokenizer.from_pretrained(_lowerCAmelCase		)
         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 shutil
import tempfile
import unittest

import numpy as np
import pytest

from transformers import is_speech_available, is_vision_available
from transformers.testing_utils import require_torch


if is_vision_available():
       from transformers import TvltImageProcessor

if is_speech_available():
       from transformers import TvltFeatureExtractor

from transformers import TvltProcessor

@require_torch
class    lowerCAmelCase_		(		unittest.TestCase		):




 def 							_snake_case   (	self		)    ->							Dict:
     _lowerCAmelCase				=      "ZinengTang/tvlt-base"
     _lowerCAmelCase				=      tempfile.mkdtemp()




 def 							_snake_case   (	self			,     **_lowerCAmelCase		)    ->							Any:
     return TvltImageProcessor.from_pretrained(self.checkpoint			,     **_lowerCAmelCase		)




 def 							_snake_case   (	self			,     **_lowerCAmelCase		)    ->							str:
     return TvltFeatureExtractor.from_pretrained(self.checkpoint			,     **_lowerCAmelCase		)




 def 							_snake_case   (	self		)    ->							Optional[Any]:
     shutil.rmtree(self.tmpdirname		)




 def 							_snake_case   (	self		)    ->							Union[str, Any]:
     _lowerCAmelCase				=      self.get_image_processor()
     _lowerCAmelCase				=      self.get_feature_extractor()

     _lowerCAmelCase				=      TvltProcessor(image_processor=_lowerCAmelCase			,     feature_extractor=_lowerCAmelCase		)
     processor.save_pretrained(self.tmpdirname		)
     _lowerCAmelCase				=      TvltProcessor.from_pretrained(self.tmpdirname		)

     self.assertIsInstance(processor.feature_extractor			,     _lowerCAmelCase		)
     self.assertIsInstance(processor.image_processor			,     _lowerCAmelCase		)




 def 							_snake_case   (	self		)    ->							Any:
     _lowerCAmelCase				=      self.get_image_processor()
     _lowerCAmelCase				=      self.get_feature_extractor()

     _lowerCAmelCase				=      TvltProcessor(image_processor=_lowerCAmelCase			,     feature_extractor=_lowerCAmelCase		)

     _lowerCAmelCase				=      np.ones([12000]		)

     _lowerCAmelCase				=      feature_extractor(_lowerCAmelCase			,     return_tensors="np"		)
     _lowerCAmelCase				=      processor(audio=_lowerCAmelCase			,     return_tensors="np"		)

     for key in audio_dict.keys():
         self.assertAlmostEqual(audio_dict[key].sum()			,     input_processor[key].sum()			,     delta=1E-2		)




 def 							_snake_case   (	self		)    ->							str:
     _lowerCAmelCase				=      self.get_image_processor()
     _lowerCAmelCase				=      self.get_feature_extractor()

     _lowerCAmelCase				=      TvltProcessor(image_processor=_lowerCAmelCase			,     feature_extractor=_lowerCAmelCase		)

     _lowerCAmelCase				=      np.ones([3, 224, 224]		)

     _lowerCAmelCase				=      image_processor(_lowerCAmelCase			,     return_tensors="np"		)
     _lowerCAmelCase				=      processor(images=_lowerCAmelCase			,     return_tensors="np"		)

     for key in image_dict.keys():
         self.assertAlmostEqual(image_dict[key].sum()			,     input_processor[key].sum()			,     delta=1E-2		)




 def 							_snake_case   (	self		)    ->							str:
     _lowerCAmelCase				=      self.get_image_processor()
     _lowerCAmelCase				=      self.get_feature_extractor()

     _lowerCAmelCase				=      TvltProcessor(image_processor=_lowerCAmelCase			,     feature_extractor=_lowerCAmelCase		)

     _lowerCAmelCase				=      np.ones([12000]		)
     _lowerCAmelCase				=      np.ones([3, 224, 224]		)

     _lowerCAmelCase				=      processor(audio=_lowerCAmelCase			,     images=_lowerCAmelCase		)

     self.assertListEqual(list(inputs.keys()		)			,     ["audio_values", "audio_mask", "pixel_values", "pixel_mask"]		)

     # test if it raises when no input is passed
     with pytest.raises(_lowerCAmelCase		):
         processor()





 def 							_snake_case   (	self		)    ->							str:
     _lowerCAmelCase				=      self.get_image_processor()
     _lowerCAmelCase				=      self.get_feature_extractor()

     _lowerCAmelCase				=      TvltProcessor(image_processor=_lowerCAmelCase			,     feature_extractor=_lowerCAmelCase		)

     self.assertListEqual(
         processor.model_input_names			,     image_processor.model_input_names + feature_extractor.model_input_names			,     msg="`processor` and `image_processor`+`feature_extractor` model input names do not match"			,     )


