


lowerCAmelCase       		=    """
# Transformers installation
! pip install transformers datasets
# To install from source instead of the last release, comment the command above and uncomment the following one.
# ! pip install git+https://github.com/huggingface/transformers.git
"""

lowerCAmelCase       		=    [{"""type""": """code""", """content""": INSTALL_CONTENT}]
lowerCAmelCase       		=    {
    """{processor_class}""": """FakeProcessorClass""",
    """{model_class}""": """FakeModelClass""",
    """{object_class}""": """FakeObjectClass""",
}









import json
import os
import shutil
import tempfile
import unittest

import numpy as np
import pytest

from transformers import CLIPTokenizer, CLIPTokenizerFast
from transformers.models.clip.tokenization_clip import VOCAB_FILES_NAMES
from transformers.testing_utils import require_vision
from transformers.utils import IMAGE_PROCESSOR_NAME, is_vision_available


if is_vision_available():
			from PIL import Image

			from transformers import OwlViTImageProcessor, OwlViTProcessor




@require_vision
class 							snake_case_       (    unittest.TestCase      ):

						"""simple docstring"""



						def        UpperCAmelCase__					(self:					int   )    ->     str:




											'''simple docstring'''



											__a					:						Union[str, Any]      =					tempfile.mkdtemp()

											# fmt: off
											__a					:						Dict      =					["", "l", "o", "w", "e", "r", "s", "t", "i", "d", "n", "lo", "l</w>", "w</w>", "r</w>", "t</w>", "low</w>", "er</w>", "lowest</w>", "newer</w>", "wider", "<unk>", "<|startoftext|>", "<|endoftext|>"]
											# fmt: on
											__a					:						str      =					dict(zip(__UpperCAmelCase ,					range(len(__UpperCAmelCase   )   )   )   )
											__a					:						Union[str, Any]      =					["#version: 0.2", "l o", "lo w</w>", "e r</w>", ""]
											__a					:						Union[str, Any]      =					{"unk_token": "<unk>"}

											__a					:						Dict      =					os.path.join(self.tmpdirname ,					VOCAB_FILES_NAMES["vocab_file"]   )
											__a					:						int      =					os.path.join(self.tmpdirname ,					VOCAB_FILES_NAMES["merges_file"]   )
											with open(self.vocab_file ,					"w" ,					encoding="utf-8"   ) as fp:
																fp.write(json.dumps(__UpperCAmelCase   ) + "\n"   )
											with open(self.merges_file ,					"w" ,					encoding="utf-8"   ) as fp:
																fp.write("\n".join(__UpperCAmelCase   )   )

											__a					:						str      =					{
											    "do_resize": True,
											    "size": 20,
											    "do_center_crop": True,
											    "crop_size": 18,
											    "do_normalize": True,
											    "image_mean": [0.48_14_54_66, 0.4_57_82_75, 0.40_82_10_73],
											    "image_std": [0.26_86_29_54, 0.26_13_02_58, 0.27_57_77_11],
											}
											__a					:						Any      =					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:					Tuple ,					**__UpperCAmelCase:					Dict   )    ->     List[str]:




											'''simple docstring'''



											return CLIPTokenizer.from_pretrained(self.tmpdirname ,					pad_token="!" ,					**__UpperCAmelCase   )



						def        UpperCAmelCase__					(self:					Optional[Any] ,					**__UpperCAmelCase:					int   )    ->     Any:




											'''simple docstring'''



											return CLIPTokenizerFast.from_pretrained(self.tmpdirname ,					pad_token="!" ,					**__UpperCAmelCase   )



						def        UpperCAmelCase__					(self:					List[Any] ,					**__UpperCAmelCase:					Dict   )    ->     Optional[int]:




											'''simple docstring'''



											return OwlViTImageProcessor.from_pretrained(self.tmpdirname ,					**__UpperCAmelCase   )



						def        UpperCAmelCase__					(self:					str   )    ->     int:




											'''simple docstring'''



											shutil.rmtree(self.tmpdirname   )



						def        UpperCAmelCase__					(self:					Dict   )    ->     Union[str, Any]:




											'''simple docstring'''



											__a					:						Dict      =					[np.random.randint(255 ,					size=(3, 30, 400) ,					dtype=np.uinta   )]

											__a					:						Any      =					[Image.fromarray(np.moveaxis(__UpperCAmelCase ,					0 ,					-1   )   ) for x in image_inputs]

											return image_inputs



						def        UpperCAmelCase__					(self:					Tuple   )    ->     Optional[Any]:




											'''simple docstring'''



											__a					:						Dict      =					self.get_tokenizer()
											__a					:						Dict      =					self.get_rust_tokenizer()
											__a					:						List[str]      =					self.get_image_processor()

											__a					:						Any      =					OwlViTProcessor(tokenizer=__UpperCAmelCase ,					image_processor=__UpperCAmelCase   )
											processor_slow.save_pretrained(self.tmpdirname   )
											__a					:						str      =					OwlViTProcessor.from_pretrained(self.tmpdirname ,					use_fast=__UpperCAmelCase   )

											__a					:						Union[str, Any]      =					OwlViTProcessor(tokenizer=__UpperCAmelCase ,					image_processor=__UpperCAmelCase   )
											processor_fast.save_pretrained(self.tmpdirname   )
											__a					:						List[Any]      =					OwlViTProcessor.from_pretrained(self.tmpdirname   )

											self.assertEqual(processor_slow.tokenizer.get_vocab() ,					tokenizer_slow.get_vocab()   )
											self.assertEqual(processor_fast.tokenizer.get_vocab() ,					tokenizer_fast.get_vocab()   )
											self.assertEqual(tokenizer_slow.get_vocab() ,					tokenizer_fast.get_vocab()   )
											self.assertIsInstance(processor_slow.tokenizer ,					__UpperCAmelCase   )
											self.assertIsInstance(processor_fast.tokenizer ,					__UpperCAmelCase   )

											self.assertEqual(processor_slow.image_processor.to_json_string() ,					image_processor.to_json_string()   )
											self.assertEqual(processor_fast.image_processor.to_json_string() ,					image_processor.to_json_string()   )
											self.assertIsInstance(processor_slow.image_processor ,					__UpperCAmelCase   )
											self.assertIsInstance(processor_fast.image_processor ,					__UpperCAmelCase   )



						def        UpperCAmelCase__					(self:					str   )    ->     Dict:




											'''simple docstring'''



											__a					:						Tuple      =					OwlViTProcessor(tokenizer=self.get_tokenizer() ,					image_processor=self.get_image_processor()   )
											processor.save_pretrained(self.tmpdirname   )

											__a					:						Optional[Any]      =					self.get_tokenizer(bos_token="(BOS)" ,					eos_token="(EOS)"   )
											__a					:						str      =					self.get_image_processor(do_normalize=__UpperCAmelCase   )

											__a					:						str      =					OwlViTProcessor.from_pretrained(
											    self.tmpdirname ,					bos_token="(BOS)" ,					eos_token="(EOS)" ,					do_normalize=__UpperCAmelCase   )

											self.assertEqual(processor.tokenizer.get_vocab() ,					tokenizer_add_kwargs.get_vocab()   )
											self.assertIsInstance(processor.tokenizer ,					__UpperCAmelCase   )

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



						def        UpperCAmelCase__					(self:					Optional[int]   )    ->     Dict:




											'''simple docstring'''



											__a					:						Optional[Any]      =					self.get_image_processor()
											__a					:						str      =					self.get_tokenizer()

											__a					:						List[str]      =					OwlViTProcessor(tokenizer=__UpperCAmelCase ,					image_processor=__UpperCAmelCase   )

											__a					:						List[str]      =					self.prepare_image_inputs()

											__a					:						Optional[Any]      =					image_processor(__UpperCAmelCase ,					return_tensors="np"   )
											__a					:						int      =					processor(images=__UpperCAmelCase ,					return_tensors="np"   )

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



						def        UpperCAmelCase__					(self:					Dict   )    ->     Optional[int]:




											'''simple docstring'''



											__a					:						int      =					self.get_image_processor()
											__a					:						Tuple      =					self.get_tokenizer()

											__a					:						Optional[int]      =					OwlViTProcessor(tokenizer=__UpperCAmelCase ,					image_processor=__UpperCAmelCase   )

											__a					:						Dict      =					"lower newer"

											__a					:						Any      =					processor(text=__UpperCAmelCase ,					return_tensors="np"   )

											__a					:						List[str]      =					tokenizer(__UpperCAmelCase ,					return_tensors="np"   )

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



						def        UpperCAmelCase__					(self:					List[Any]   )    ->     Dict:




											'''simple docstring'''



											__a					:						Dict      =					self.get_image_processor()
											__a					:						List[str]      =					self.get_tokenizer()

											__a					:						Optional[Any]      =					OwlViTProcessor(tokenizer=__UpperCAmelCase ,					image_processor=__UpperCAmelCase   )

											__a					:						Optional[int]      =					"lower newer"
											__a					:						int      =					self.prepare_image_inputs()

											__a					:						Optional[int]      =					processor(text=__UpperCAmelCase ,					images=__UpperCAmelCase   )

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

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



						def        UpperCAmelCase__					(self:					int   )    ->     Union[str, Any]:




											'''simple docstring'''



											__a					:						Dict      =					"google/owlvit-base-patch32"
											__a					:						Dict      =					OwlViTProcessor.from_pretrained(__UpperCAmelCase   )

											__a					:						List[str]      =					["cat", "nasa badge"]
											__a					:						List[Any]      =					processor(text=__UpperCAmelCase   )

											__a					:						Any      =					16
											self.assertListEqual(list(inputs.keys()   ) ,					["input_ids", "attention_mask"]   )
											self.assertEqual(inputs["input_ids"].shape ,					(2, seq_length)   )

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



						def        UpperCAmelCase__					(self:					Any   )    ->     Optional[int]:




											'''simple docstring'''



											__a					:						Optional[int]      =					"google/owlvit-base-patch32"
											__a					:						Optional[int]      =					OwlViTProcessor.from_pretrained(__UpperCAmelCase   )

											__a					:						Tuple      =					[["cat", "nasa badge"], ["person"]]
											__a					:						List[Any]      =					processor(text=__UpperCAmelCase   )

											__a					:						Tuple      =					16
											__a					:						Optional[Any]      =					len(__UpperCAmelCase   )
											__a					:						Optional[Any]      =					max([len(__UpperCAmelCase   ) for texts in input_texts]   )

											self.assertListEqual(list(inputs.keys()   ) ,					["input_ids", "attention_mask"]   )
											self.assertEqual(inputs["input_ids"].shape ,					(batch_size * num_max_text_queries, seq_length)   )

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



						def        UpperCAmelCase__					(self:					Tuple   )    ->     Dict:




											'''simple docstring'''



											__a					:						int      =					"google/owlvit-base-patch32"
											__a					:						Dict      =					OwlViTProcessor.from_pretrained(__UpperCAmelCase   )

											__a					:						List[str]      =					["cat", "nasa badge"]
											__a					:						List[Any]      =					processor(text=__UpperCAmelCase   )

											__a					:						int      =					16
											__a					:						Union[str, Any]      =					inputs["input_ids"]
											__a					:						Optional[int]      =					[
											    [49406, 2368, 49407, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
											    [49406, 6841, 11301, 49407, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
											]

											self.assertListEqual(list(inputs.keys()   ) ,					["input_ids", "attention_mask"]   )
											self.assertEqual(inputs["input_ids"].shape ,					(2, seq_length)   )
											self.assertListEqual(list(input_ids[0]   ) ,					predicted_ids[0]   )
											self.assertListEqual(list(input_ids[1]   ) ,					predicted_ids[1]   )



						def        UpperCAmelCase__					(self:					Optional[int]   )    ->     List[Any]:




											'''simple docstring'''



											__a					:						Union[str, Any]      =					self.get_image_processor()
											__a					:						List[str]      =					self.get_tokenizer()

											__a					:						Tuple      =					OwlViTProcessor(tokenizer=__UpperCAmelCase ,					image_processor=__UpperCAmelCase   )

											__a					:						str      =					self.prepare_image_inputs()
											__a					:						Any      =					self.prepare_image_inputs()

											__a					:						str      =					processor(images=__UpperCAmelCase ,					query_images=__UpperCAmelCase   )

											self.assertListEqual(list(inputs.keys()   ) ,					["query_pixel_values", "pixel_values"]   )

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



						def        UpperCAmelCase__					(self:					Any   )    ->     Tuple:




											'''simple docstring'''



											__a					:						int      =					self.get_image_processor()
											__a					:						Tuple      =					self.get_tokenizer()

											__a					:						Optional[int]      =					OwlViTProcessor(tokenizer=__UpperCAmelCase ,					image_processor=__UpperCAmelCase   )

											__a					:						List[str]      =					[[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

											__a					:						Tuple      =					processor.batch_decode(__UpperCAmelCase   )
											__a					:						str      =					tokenizer.batch_decode(__UpperCAmelCase   )

											self.assertListEqual(__UpperCAmelCase ,					__UpperCAmelCase   )





