






import collections
import json
import os
import re
from typing import TYPE_CHECKING, List, Optional, Tuple

import numpy as np

from ...tokenization_utils_fast import PreTrainedTokenizer
from ...utils import logging


if TYPE_CHECKING:
 from transformers.pipelines.conversational import Conversation


lowerCamelCase			:					Optional[int]         =	logging.get_logger(__name__)

lowerCamelCase			:					Union[str, Any]         =	{'''vocab_file''': '''vocab.txt''', '''emoji_file''': '''emoji.json'''}

lowerCamelCase			:					Optional[int]         =	{
    '''vocab_file''': {
        '''abeja/gpt-neox-japanese-2.7b''': '''https://huggingface.co/abeja/gpt-neox-japanese-2.7b/resolve/main/vocab.txt''',
    },
    '''emoji_file''': {
        '''abeja/gpt-neox-japanese-2.7b''': '''https://huggingface.co/abeja/gpt-neox-japanese-2.7b/resolve/main/emoji.json''',
    },
}

lowerCamelCase			:					Union[str, Any]         =	{
    '''abeja/gpt-neox-japanese-2.7b''': 2048,
}





def       __lowerCAmelCase							(						__snake_case					, __snake_case       ):





     with open(SCREAMING_SNAKE_CASE__					, "r"					, encoding="utf-8"       ) as f:
          __lowerCAmelCase								=					json.loads(f.read()       )

     __lowerCAmelCase								=					collections.OrderedDict()
     __lowerCAmelCase								=					collections.OrderedDict()
     __lowerCAmelCase								=					collections.OrderedDict()
     with open(SCREAMING_SNAKE_CASE__					, "r"					, encoding="utf-8"       ) as f:
          __lowerCAmelCase								=					f.readlines()
     __lowerCAmelCase								=					[[t.rstrip("\n"       )] if (t == """,""" or """,""" not in t) else t.rstrip("\n"       ).split(","       ) for t in token]
     for idx, b in enumerate(SCREAMING_SNAKE_CASE__       ):
          __lowerCAmelCase								=					b
          __lowerCAmelCase								=					idx
          for wd in b:
               __lowerCAmelCase								=					idx

     return vocab, raw_vocab, ids_to_tokens, emoji



class 							_UpperCamelCase			(_UpperCAmelCase			):
      snake_case_  =							VOCAB_FILES_NAMES
      snake_case_  =							PRETRAINED_VOCAB_FILES_MAP
      snake_case_  =							PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
      snake_case_  =							["""input_ids""", """attention_mask"""]


      def __init__(	self					,						__UpperCamelCase					,						__UpperCamelCase					,						__UpperCamelCase="<|endoftext|>"					,						__UpperCamelCase="<|endoftext|>"					,						__UpperCamelCase="<|startoftext|>"					,						__UpperCamelCase="<|endoftext|>"					,						__UpperCamelCase=False					,						**__UpperCamelCase					,						)->	Tuple:
           super().__init__(
               unk_token=lowercase__					,						pad_token=lowercase__					,						bos_token=lowercase__					,						eos_token=lowercase__					,						do_clean_text=lowercase__					,						**lowercase__					,						)
           if not os.path.isfile(lowercase__	):
                raise ValueError(
                    F"""Can\'t find a vocabulary file at path \'{vocab_file}\'. To load the vocabulary from a Google pretrained"""
                    " model use `tokenizer = GPTNeoXJapaneseokenizer.from_pretrained(PRETRAINED_MODEL_NAME)`"	)
           if not os.path.isfile(lowercase__	):
                raise ValueError(
                    F"""Can\'t find a emoji file at path \'{emoji_file}\'. To load the emoji information from a Google"""
                    " pretrained model use `tokenizer = GPTNeoXJapaneseokenizer.from_pretrained(PRETRAINED_MODEL_NAME)`"	)
           __lowerCAmelCase								=					do_clean_text
           __lowerCAmelCase								=					load_vocab_and_emoji(lowercase__					,						lowercase__	)
           __lowerCAmelCase								=					SubWordJapaneseTokenizer(
               vocab=self.vocab					,						ids_to_tokens=self.ids_to_tokens					,						emoji=self.emoji	)


      @property
      def  __UpperCAmelCase		(	self	)->	List[Any]:
           # self.vocab contains support for character fluctuation unique to Japanese, and has a large number of vocab
           return len(self.raw_vocab	)


      def  __UpperCAmelCase		(	self	)->	Union[str, Any]:
           return dict(self.raw_vocab					,						**self.added_tokens_encoder	)


      def  __UpperCAmelCase		(	self					,						__UpperCamelCase	)->	Any:
           return self.subword_tokenizer.tokenize(lowercase__					,						clean=self.do_clean_text	)


      def  __UpperCAmelCase		(	self					,						__UpperCamelCase	)->	Any:
           return self.vocab.get(lowercase__					,						self.vocab.get(self.unk_token	)	)


      def  __UpperCAmelCase		(	self					,						__UpperCamelCase	)->	Any:
           return self.subword_tokenizer.convert_id_to_token(lowercase__	)


      def  __UpperCAmelCase		(	self					,						__UpperCamelCase	)->	int:
           __lowerCAmelCase								=					"""""".join(lowercase__	).strip()
           return out_string


      def  __UpperCAmelCase		(	self					,						__UpperCamelCase	)->	Any:
           __lowerCAmelCase								=					[]
           for is_user, text in conversation.iter_texts():
                input_ids.extend(self.encode(lowercase__					,						add_special_tokens=lowercase__	) + [self.eos_token_id]	)

           if len(lowercase__	) > self.model_max_length:
                __lowerCAmelCase								=					input_ids[-self.model_max_length :]
           return input_ids


      def  __UpperCAmelCase		(	self					,						__UpperCamelCase					,						__UpperCamelCase = None	)->	List[str]:
           __lowerCAmelCase								=					0
           if os.path.isdir(lowercase__	):
                __lowerCAmelCase								=					os.path.join(
                    lowercase__					,						(filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"]	)
                __lowerCAmelCase								=					os.path.join(
                    lowercase__					,						(filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["emoji_file"]	)
           else:
                __lowerCAmelCase								=					(
                    (filename_prefix + """-""" if filename_prefix else """""") + save_directory + VOCAB_FILES_NAMES["""vocab_file"""]
                )
                __lowerCAmelCase								=					(
                    (filename_prefix + """-""" if filename_prefix else """""") + save_directory + VOCAB_FILES_NAMES["""emoji_file"""]
                )
           with open(lowercase__					,						"w"					,						encoding="utf-8"	) as writer:
                for token_index, token in self.ids_to_tokens.items():
                     if index != token_index:
                          logger.warning(
                              F"""Saving vocabulary to {vocab_file}: vocabulary indices are not consecutive."""
                              " Please check that the vocabulary is not corrupted!"	)
                          __lowerCAmelCase								=					token_index
                     writer.write(",".join(lowercase__	) + "\n"	)
                     index += 1
           with open(lowercase__					,						"w"					,						encoding="utf-8"	) as writer:
                json.dump(self.emoji					,						lowercase__	)
           return vocab_file, emoji_file



class 							_UpperCamelCase			(_UpperCAmelCase			):


      def __init__(	self					,						__UpperCamelCase					,						__UpperCamelCase					,						__UpperCamelCase	)->	Optional[int]:
           __lowerCAmelCase								=					vocab  # same as swe
           __lowerCAmelCase								=					ids_to_tokens  # same as bpe
           __lowerCAmelCase								=					emoji
           __lowerCAmelCase								=					np.max([len(lowercase__	) for w in self.vocab.keys()]	)
           __lowerCAmelCase								=					re.compile(R"(https?|ftp)(:\/\/[-_\.!~*\'()a-zA-Z0-9;\/?:\@&=\+$,%#]+)"	)
           __lowerCAmelCase								=					re.compile(R"[A-Za-z0-9\._+]*@[\-_0-9A-Za-z]+(\.[A-Za-z]+)*"	)
           __lowerCAmelCase								=					re.compile(R"[\(]{0,1}[0-9]{2,4}[\)\-\(]{0,1}[0-9]{2,4}[\)\-]{0,1}[0-9]{3,4}"	)
           __lowerCAmelCase								=					re.compile(
               R"([12]\d{3}[/\-年])*(0?[1-9]|1[0-2])[/\-月]((0?[1-9]|[12][0-9]|3[01])日?)*(\d{1,2}|:|\d{1,2}時|\d{1,2}分|\(日\)|\(月\)|\(火\)|\(水\)|\(木\)|\(金\)|\(土\)|㈰|㈪|㈫|㈬|㈭|㈮|㈯)*"	)
           __lowerCAmelCase								=					re.compile(
               R"(明治|大正|昭和|平成|令和|㍾|㍽|㍼|㍻|\u32ff)\d{1,2}年(0?[1-9]|1[0-2])月(0?[1-9]|[12][0-9]|3[01])日(\d{1,2}|:|\d{1,2}時|\d{1,2}分|\(日\)|\(月\)|\(火\)|\(水\)|\(木\)|\(金\)|\(土\)|㈰|㈪|㈫|㈬|㈭|㈮|㈯)*"	)
           __lowerCAmelCase								=					re.compile(
               R"((0|[1-9]\d*|[1-9]\d{0,2}(,\d{3})+)*億)*((0|[1-9]\d*|[1-9]\d{0,2}(,\d{3})+)*万)*((0|[1-9]\d*|[1-9]\d{0,2}(,\d{3})+)*千)*(0|[1-9]\d*|[1-9]\d{0,2}(,\d{3})+)*(千円|万円|千万円|円|千ドル|万ドル|千万ドル|ドル|千ユーロ|万ユーロ|千万ユーロ|ユーロ)+(\(税込\)|\(税抜\)|\+tax)*"	)
           __lowerCAmelCase								=					"""─━│┃┄┅┆┇┈┉┊┋┌┍┎┏┐┑┒┓└┕┖┗┘┙┚┛├┝┞┟┠┡┢┣┤┥┦┧┨┩┪┫┬┭┮┯┰┱┲┳┴┵┶┷┸┹┺┻┼┽┾┿╀╁╂╃╄╅╆╇╈╉╊╋╌╍╎╏═║╒╓╔╕╖╗╘╙╚╛╜╝╞╟╠╡╢╣╤╥╦╧╨╩╪╫╬╭╮╯╰╱╲╳╴╵╶╷╸╹╺╻╼╽╾╿"""
           __lowerCAmelCase								=					"""▀▁▂▃▄▅▆▇█▉▊▋▌▍▎▏▐░▒▓▔▕▖▗▘▙▚▛▜▝▞▟"""
           __lowerCAmelCase								=					str.maketrans({k: "<BLOCK>" for k in keisen + blocks}	)


      def __len__(	self	)->	List[str]:
           return len(self.ids_to_tokens	)


      def  __UpperCAmelCase		(	self					,						__UpperCamelCase	)->	Union[str, Any]:
           __lowerCAmelCase								=					self.content_repattera.sub("<URL>"					,						lowercase__	)
           __lowerCAmelCase								=					self.content_repattera.sub("<EMAIL>"					,						lowercase__	)
           __lowerCAmelCase								=					self.content_repattera.sub("<TEL>"					,						lowercase__	)
           __lowerCAmelCase								=					self.content_repattera.sub("<DATE>"					,						lowercase__	)
           __lowerCAmelCase								=					self.content_repattera.sub("<DATE>"					,						lowercase__	)
           __lowerCAmelCase								=					self.content_repattera.sub("<PRICE>"					,						lowercase__	)
           __lowerCAmelCase								=					content.translate(self.content_transa	)
           while "<BLOCK><BLOCK>" in content:
                __lowerCAmelCase								=					content.replace("<BLOCK><BLOCK>"					,						"<BLOCK>"	)
           return content


      def  __UpperCAmelCase		(	self					,						__UpperCamelCase					,						__UpperCamelCase=False	)->	Any:
           __lowerCAmelCase								=					text.replace(" "					,						"<SP>"	)
           __lowerCAmelCase								=					text.replace("　"					,						"<SP>"	)
           __lowerCAmelCase								=					text.replace("\r\n"					,						"<BR>"	)
           __lowerCAmelCase								=					text.replace("\n"					,						"<BR>"	)
           __lowerCAmelCase								=					text.replace("\r"					,						"<BR>"	)
           __lowerCAmelCase								=					text.replace("\t"					,						"<TAB>"	)
           __lowerCAmelCase								=					text.replace("—"					,						"ー"	)
           __lowerCAmelCase								=					text.replace("−"					,						"ー"	)
           for k, v in self.emoji["emoji"].items():
                if k in text:
                     __lowerCAmelCase								=					text.replace(lowercase__					,						lowercase__	)
           if clean:
                __lowerCAmelCase								=					self.clean_text(lowercase__	)

           def check_simbol(__UpperCamelCase	):
                __lowerCAmelCase								=					x.encode()
                if len(lowercase__	) == 1 and len(lowercase__	) == 2:
                     __lowerCAmelCase								=					(int(e[0]	) << 8) + int(e[1]	)
                     if (
                         (c >= 0xC_2A1 and c <= 0xC_2BF)
                         or (c >= 0xC_780 and c <= 0xC_783)
                         or (c >= 0xC_AB9 and c <= 0xC_BBF)
                         or (c >= 0xC_C80 and c <= 0xC_DA2)
                     ):
                          return True
                return False

           def checkuae(__UpperCamelCase	):
                __lowerCAmelCase								=					x.encode()
                if len(lowercase__	) == 1 and len(lowercase__	) == 3:
                     __lowerCAmelCase								=					(int(e[0]	) << 1_6) + (int(e[1]	) << 8) + int(e[2]	)
                     if c >= 0xE28_080 and c <= 0xE2B_07F:
                          return True
                return False

           __lowerCAmelCase								=					0
           __lowerCAmelCase								=					[]
           while pos < len(lowercase__	):
                __lowerCAmelCase								=					min(len(lowercase__	)					,						pos + self.maxlen + 1	) if text[pos] == """<""" else pos + 3
                __lowerCAmelCase								=					[]  # (token_id, token, pos)
                for e in range(lowercase__					,						lowercase__					,						-1	):
                     __lowerCAmelCase								=					text[pos:e]
                     if wd in self.vocab:
                          if wd[0] == "<" and len(lowercase__	) > 2:
                               __lowerCAmelCase								=					[(self.vocab[wd], wd, e)]
                               break
                          else:
                               candidates.append((self.vocab[wd], wd, e)	)
                if len(lowercase__	) > 0:
                     # the smallest token_id is adopted
                     __lowerCAmelCase								=					sorted(lowercase__					,						key=lambda __UpperCamelCase	: x[0]	)[0]
                     result.append(lowercase__	)
                     __lowerCAmelCase								=					e
                else:
                     __lowerCAmelCase								=					pos + 1
                     __lowerCAmelCase								=					text[pos:end]
                     if check_simbol(lowercase__	):
                          result.append("<KIGOU>"	)
                     elif checkuae(lowercase__	):
                          result.append("<U2000U2BFF>"	)
                     else:
                          for i in wd.encode("utf-8"	):
                               result.append("<|byte%d|>" % i	)
                     __lowerCAmelCase								=					end
           return result


      def  __UpperCAmelCase		(	self					,						__UpperCamelCase					,						__UpperCamelCase="\n"	)->	List[Any]:
           __lowerCAmelCase								=					[]
           __lowerCAmelCase								=					[]
           __lowerCAmelCase								=					self.ids_to_tokens[index][0]
           if word[:6] == "<|byte" and word[-2:] == "|>":
                byte_tokens.append(int(word[6:-2]	)	)
           else:
                if len(lowercase__	) > 0:
                     words.append(bytearray(lowercase__	).decode("utf-8"					,						errors="replace"	)	)
                     __lowerCAmelCase								=					[]
                if word[:7] == "<|emoji" and word[-2:] == "|>":
                     words.append(self.emoji["emoji_inv"][word]	)
                elif word == "<SP>":
                     words.append(" "	)
                elif word == "<BR>":
                     words.append(lowercase__	)
                elif word == "<TAB>":
                     words.append("\t"	)
                elif word == "<BLOCK>":
                     words.append("▀"	)
                elif word == "<KIGOU>":
                     words.append("ǀ"	)
                elif word == "<U2000U2BFF>":
                     words.append("‖"	)
                else:
                     words.append(lowercase__	)
           if len(lowercase__	) > 0:
                words.append(bytearray(lowercase__	).decode("utf-8"					,						errors="replace"	)	)
           __lowerCAmelCase								=					"""""".join(lowercase__	)
           return text














import json
import os
import shutil
import tempfile
import unittest

import numpy as np

from transformers import BertTokenizerFast
from transformers.models.bert.tokenization_bert import VOCAB_FILES_NAMES, BertTokenizer
from transformers.testing_utils import require_tokenizers, require_vision
from transformers.utils import IMAGE_PROCESSOR_NAME, is_vision_available


if is_vision_available():
 from PIL import Image

 from transformers import VisionTextDualEncoderProcessor, ViTImageProcessor



@require_tokenizers
@require_vision
class 							_UpperCamelCase			(unittest.TestCase			):


      def  __UpperCAmelCase		(	self	)->	Optional[Any]:
           __lowerCAmelCase								=					tempfile.mkdtemp()

           # fmt: off
           __lowerCAmelCase								=					["[UNK]", "[CLS]", "[SEP]", "[PAD]", "[MASK]", "want", "##want", "##ed", "wa", "un", "runn", "##ing", ",", "low", "lowest"]
           # fmt: on
           __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]	)	)

           __lowerCAmelCase								=					{
               "do_resize": True,
               "size": {"height": 1_8, "width": 1_8},
               "do_normalize": True,
               "image_mean": [0.5, 0.5, 0.5],
               "image_std": [0.5, 0.5, 0.5],
           }
           __lowerCAmelCase								=					os.path.join(self.tmpdirname					,						__UpperCamelCase	)
           with open(self.image_processor_file					,						"w"					,						encoding="utf-8"	) as fp:
                json.dump(__UpperCamelCase					,						__UpperCamelCase	)


      def  __UpperCAmelCase		(	self					,						**__UpperCamelCase	)->	Optional[Any]:
           return BertTokenizer.from_pretrained(self.tmpdirname					,						**__UpperCamelCase	)


      def  __UpperCAmelCase		(	self					,						**__UpperCamelCase	)->	Any:
           return ViTImageProcessor.from_pretrained(self.tmpdirname					,						**__UpperCamelCase	)


      def  __UpperCAmelCase		(	self	)->	Any:
           shutil.rmtree(self.tmpdirname	)


      def  __UpperCAmelCase		(	self	)->	int:
           __lowerCAmelCase								=					[np.random.randint(2_5_5					,						size=(3, 3_0, 4_0_0)					,						dtype=np.uinta	)]

           __lowerCAmelCase								=					[Image.fromarray(np.moveaxis(__UpperCamelCase					,						0					,						-1	)	) for x in image_inputs]

           return image_inputs


      def  __UpperCAmelCase		(	self	)->	Optional[Any]:
           __lowerCAmelCase								=					self.get_tokenizer()
           __lowerCAmelCase								=					self.get_image_processor()

           __lowerCAmelCase								=					VisionTextDualEncoderProcessor(tokenizer=__UpperCamelCase					,						image_processor=__UpperCamelCase	)

           processor.save_pretrained(self.tmpdirname	)
           __lowerCAmelCase								=					VisionTextDualEncoderProcessor.from_pretrained(self.tmpdirname	)

           self.assertEqual(processor.tokenizer.get_vocab()					,						tokenizer.get_vocab()	)
           self.assertIsInstance(processor.tokenizer					,						(BertTokenizer, BertTokenizerFast)	)

           self.assertEqual(processor.image_processor.to_json_string()					,						image_processor.to_json_string()	)
           self.assertIsInstance(processor.image_processor					,						__UpperCamelCase	)


      def  __UpperCAmelCase		(	self	)->	str:
           __lowerCAmelCase								=					VisionTextDualEncoderProcessor(
               tokenizer=self.get_tokenizer()					,						image_processor=self.get_image_processor()	)
           processor.save_pretrained(self.tmpdirname	)

           __lowerCAmelCase								=					self.get_tokenizer(bos_token="(BOS)"					,						eos_token="(EOS)"	)
           __lowerCAmelCase								=					self.get_image_processor(do_normalize=__UpperCamelCase					,						padding_value=1.0	)

           __lowerCAmelCase								=					VisionTextDualEncoderProcessor.from_pretrained(
               self.tmpdirname					,						bos_token="(BOS)"					,						eos_token="(EOS)"					,						do_normalize=__UpperCamelCase					,						padding_value=1.0	)

           self.assertEqual(processor.tokenizer.get_vocab()					,						tokenizer_add_kwargs.get_vocab()	)
           self.assertIsInstance(processor.tokenizer					,						(BertTokenizer, BertTokenizerFast)	)

           self.assertEqual(processor.image_processor.to_json_string()					,						image_processor_add_kwargs.to_json_string()	)
           self.assertIsInstance(processor.image_processor					,						__UpperCamelCase	)


      def  __UpperCAmelCase		(	self	)->	Union[str, Any]:
           __lowerCAmelCase								=					self.get_image_processor()
           __lowerCAmelCase								=					self.get_tokenizer()

           __lowerCAmelCase								=					VisionTextDualEncoderProcessor(tokenizer=__UpperCamelCase					,						image_processor=__UpperCamelCase	)

           __lowerCAmelCase								=					self.prepare_image_inputs()

           __lowerCAmelCase								=					image_processor(__UpperCamelCase					,						return_tensors="np"	)
           __lowerCAmelCase								=					processor(images=__UpperCamelCase					,						return_tensors="np"	)

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


      def  __UpperCAmelCase		(	self	)->	Dict:
           __lowerCAmelCase								=					self.get_image_processor()
           __lowerCAmelCase								=					self.get_tokenizer()

           __lowerCAmelCase								=					VisionTextDualEncoderProcessor(tokenizer=__UpperCamelCase					,						image_processor=__UpperCamelCase	)

           __lowerCAmelCase								=					"lower newer"

           __lowerCAmelCase								=					processor(text=__UpperCamelCase	)

           __lowerCAmelCase								=					tokenizer(__UpperCamelCase	)

           for key in encoded_tok.keys():
                self.assertListEqual(encoded_tok[key]					,						encoded_processor[key]	)


      def  __UpperCAmelCase		(	self	)->	List[str]:
           __lowerCAmelCase								=					self.get_image_processor()
           __lowerCAmelCase								=					self.get_tokenizer()

           __lowerCAmelCase								=					VisionTextDualEncoderProcessor(tokenizer=__UpperCamelCase					,						image_processor=__UpperCamelCase	)

           __lowerCAmelCase								=					"lower newer"
           __lowerCAmelCase								=					self.prepare_image_inputs()

           __lowerCAmelCase								=					processor(text=__UpperCamelCase					,						images=__UpperCamelCase	)

           self.assertListEqual(list(inputs.keys()	)					,						["input_ids", "token_type_ids", "attention_mask", "pixel_values"]	)

           # test if it raises when no input is passed
           with self.assertRaises(__UpperCamelCase	):
                processor()


      def  __UpperCAmelCase		(	self	)->	Optional[int]:
           __lowerCAmelCase								=					self.get_image_processor()
           __lowerCAmelCase								=					self.get_tokenizer()

           __lowerCAmelCase								=					VisionTextDualEncoderProcessor(tokenizer=__UpperCamelCase					,						image_processor=__UpperCamelCase	)

           __lowerCAmelCase								=					[[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

           __lowerCAmelCase								=					processor.batch_decode(__UpperCamelCase	)
           __lowerCAmelCase								=					tokenizer.batch_decode(__UpperCamelCase	)

           self.assertListEqual(__UpperCamelCase					,						__UpperCamelCase	)


      def  __UpperCAmelCase		(	self	)->	Any:
           __lowerCAmelCase								=					self.get_image_processor()
           __lowerCAmelCase								=					self.get_tokenizer()

           __lowerCAmelCase								=					VisionTextDualEncoderProcessor(tokenizer=__UpperCamelCase					,						image_processor=__UpperCamelCase	)

           __lowerCAmelCase								=					"lower newer"
           __lowerCAmelCase								=					self.prepare_image_inputs()

           __lowerCAmelCase								=					processor(text=__UpperCamelCase					,						images=__UpperCamelCase	)

           self.assertListEqual(list(inputs.keys()	)					,						processor.model_input_names	)






