




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 			a__    (					unittest.TestCase      ):






						def 				__SCREAMING_SNAKE_CASE(   self			):




											"""simple docstring"""



											__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		,			_A			)
											with open(self.image_processor_file		,			"w"		,			encoding="utf-8"			) as fp:
																json.dump(_A		,			_A			)






						def 				__SCREAMING_SNAKE_CASE(   self		,			**_A			):




											"""simple docstring"""



											return BertTokenizer.from_pretrained(self.tmpdirname		,			**_A			)






						def 				__SCREAMING_SNAKE_CASE(   self		,			**_A			):




											"""simple docstring"""



											return ViTImageProcessor.from_pretrained(self.tmpdirname		,			**_A			)






						def 				__SCREAMING_SNAKE_CASE(   self			):




											"""simple docstring"""



											shutil.rmtree(self.tmpdirname			)






						def 				__SCREAMING_SNAKE_CASE(   self			):




											"""simple docstring"""



											__lowerCAmelCase				   =       [np.random.randint(2_5_5		,			size=(3, 3_0, 4_0_0)		,			dtype=np.uinta			)]

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

											return image_inputs






						def 				__SCREAMING_SNAKE_CASE(   self			):




											"""simple docstring"""



											__lowerCAmelCase				   =       self.get_tokenizer()
											__lowerCAmelCase				   =       self.get_image_processor()

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

											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		,			_A			)






						def 				__SCREAMING_SNAKE_CASE(   self			):




											"""simple docstring"""



											__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=_A		,			padding_value=1.0			)

											__lowerCAmelCase				   =       VisionTextDualEncoderProcessor.from_pretrained(
											    self.tmpdirname		,			bos_token="(BOS)"		,			eos_token="(EOS)"		,			do_normalize=_A		,			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		,			_A			)






						def 				__SCREAMING_SNAKE_CASE(   self			):




											"""simple docstring"""



											__lowerCAmelCase				   =       self.get_image_processor()
											__lowerCAmelCase				   =       self.get_tokenizer()

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

											__lowerCAmelCase				   =       self.prepare_image_inputs()

											__lowerCAmelCase				   =       image_processor(_A		,			return_tensors="np"			)
											__lowerCAmelCase				   =       processor(images=_A		,			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 				__SCREAMING_SNAKE_CASE(   self			):




											"""simple docstring"""



											__lowerCAmelCase				   =       self.get_image_processor()
											__lowerCAmelCase				   =       self.get_tokenizer()

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

											__lowerCAmelCase				   =       "lower newer"

											__lowerCAmelCase				   =       processor(text=_A			)

											__lowerCAmelCase				   =       tokenizer(_A			)

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






						def 				__SCREAMING_SNAKE_CASE(   self			):




											"""simple docstring"""



											__lowerCAmelCase				   =       self.get_image_processor()
											__lowerCAmelCase				   =       self.get_tokenizer()

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

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

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

											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(_A			):
																processor()






						def 				__SCREAMING_SNAKE_CASE(   self			):




											"""simple docstring"""



											__lowerCAmelCase				   =       self.get_image_processor()
											__lowerCAmelCase				   =       self.get_tokenizer()

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

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

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

											self.assertListEqual(_A		,			_A			)






						def 				__SCREAMING_SNAKE_CASE(   self			):




											"""simple docstring"""



											__lowerCAmelCase				   =       self.get_image_processor()
											__lowerCAmelCase				   =       self.get_tokenizer()

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

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

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

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










'''simple docstring'''







from ..utils import DummyObject, requires_backends


class 			_a  (	metaclass=__a ):
       __a				:     int   				=					["""flax""", """transformers"""]
       def __init__(	self						:	Optional[Any]   ,				*lowercase						:	str   ,				**lowercase						:	List[Any]				):



           '''simple docstring'''

           requires_backends(self   ,				['''flax''', '''transformers''']				)
       @classmethod
       def     A      (	cls						:	Union[str, Any]   ,				*lowercase						:	List[Any]   ,				**lowercase						:	List[str]				):



           '''simple docstring'''

           requires_backends(cls   ,				['''flax''', '''transformers''']				)







       @classmethod
       def     A      (	cls						:	Union[str, Any]   ,				*lowercase						:	Tuple   ,				**lowercase						:	int				):



           '''simple docstring'''

           requires_backends(cls   ,				['''flax''', '''transformers''']				)






class 			_a  (	metaclass=__a ):
       __a				:     int   				=					["""flax""", """transformers"""]
       def __init__(	self						:	int   ,				*lowercase						:	Tuple   ,				**lowercase						:	Dict				):



           '''simple docstring'''

           requires_backends(self   ,				['''flax''', '''transformers''']				)
       @classmethod
       def     A      (	cls						:	List[str]   ,				*lowercase						:	Optional[int]   ,				**lowercase						:	List[Any]				):



           '''simple docstring'''

           requires_backends(cls   ,				['''flax''', '''transformers''']				)







       @classmethod
       def     A      (	cls						:	Dict   ,				*lowercase						:	Union[str, Any]   ,				**lowercase						:	Union[str, Any]				):



           '''simple docstring'''

           requires_backends(cls   ,				['''flax''', '''transformers''']				)






class 			_a  (	metaclass=__a ):
       __a				:     int   				=					["""flax""", """transformers"""]
       def __init__(	self						:	Optional[int]   ,				*lowercase						:	Union[str, Any]   ,				**lowercase						:	Any				):



           '''simple docstring'''

           requires_backends(self   ,				['''flax''', '''transformers''']				)
       @classmethod
       def     A      (	cls						:	Union[str, Any]   ,				*lowercase						:	Tuple   ,				**lowercase						:	Any				):



           '''simple docstring'''

           requires_backends(cls   ,				['''flax''', '''transformers''']				)







       @classmethod
       def     A      (	cls						:	Any   ,				*lowercase						:	Dict   ,				**lowercase						:	Optional[Any]				):



           '''simple docstring'''

           requires_backends(cls   ,				['''flax''', '''transformers''']				)






class 			_a  (	metaclass=__a ):
       __a				:     Any   				=					["""flax""", """transformers"""]
       def __init__(	self						:	Any   ,				*lowercase						:	Optional[Any]   ,				**lowercase						:	Optional[int]				):



           '''simple docstring'''

           requires_backends(self   ,				['''flax''', '''transformers''']				)
       @classmethod
       def     A      (	cls						:	Dict   ,				*lowercase						:	Optional[Any]   ,				**lowercase						:	Optional[Any]				):



           '''simple docstring'''

           requires_backends(cls   ,				['''flax''', '''transformers''']				)







       @classmethod
       def     A      (	cls						:	Union[str, Any]   ,				*lowercase						:	str   ,				**lowercase						:	Any				):



           '''simple docstring'''

           requires_backends(cls   ,				['''flax''', '''transformers''']				)




