

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




      """simple docstring"""

      def 		__A	(   self							:				List[Any]	):
            A_						  =				tempfile.mkdtemp()

            # fmt: off
            A_						  =				["", "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_						  =				dict(zip(UpperCAmelCase						,			range(len(UpperCAmelCase	)	)	)	)
            A_						  =				["#version: 0.2", "l o", "lo w</w>", "e r</w>", ""]
            A_						  =				{"unk_token": "<unk>"}

            A_						  =				os.path.join(self.tmpdirname						,			VOCAB_FILES_NAMES["vocab_file"]	)
            A_						  =				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_						  =				{
                "do_resize": True,
                "size": 20,
                "do_center_crop": True,
                "crop_size": 18,
                "do_normalize": True,
                "image_mean": [0.48_145_466, 0.4_578_275, 0.40_821_073],
                "image_std": [0.26_862_954, 0.26_130_258, 0.27_577_711],
            }
            A_						  =				os.path.join(self.tmpdirname						,			UpperCAmelCase	)
            with open(self.image_processor_file						,			"w"						,			encoding="utf-8"	) as fp:
                  json.dump(UpperCAmelCase						,			UpperCAmelCase	)





      def 		__A	(   self							:				Any						,			**UpperCAmelCase							:				str	):
            return CLIPTokenizer.from_pretrained(self.tmpdirname						,			pad_token="!"						,			**UpperCAmelCase	)





      def 		__A	(   self							:				Dict						,			**UpperCAmelCase							:				Optional[Any]	):
            return CLIPTokenizerFast.from_pretrained(self.tmpdirname						,			pad_token="!"						,			**UpperCAmelCase	)





      def 		__A	(   self							:				List[Any]						,			**UpperCAmelCase							:				str	):
            return OwlViTImageProcessor.from_pretrained(self.tmpdirname						,			**UpperCAmelCase	)





      def 		__A	(   self							:				List[Any]	):
            shutil.rmtree(self.tmpdirname	)





      def 		__A	(   self							:				Tuple	):
            A_						  =				[np.random.randint(255						,			size=(3, 30, 400)						,			dtype=np.uinta	)]

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

            return image_inputs





      def 		__A	(   self							:				Any	):
            A_						  =				self.get_tokenizer()
            A_						  =				self.get_rust_tokenizer()
            A_						  =				self.get_image_processor()

            A_						  =				OwlViTProcessor(tokenizer=UpperCAmelCase						,			image_processor=UpperCAmelCase	)
            processor_slow.save_pretrained(self.tmpdirname	)
            A_						  =				OwlViTProcessor.from_pretrained(self.tmpdirname						,			use_fast=UpperCAmelCase	)

            A_						  =				OwlViTProcessor(tokenizer=UpperCAmelCase						,			image_processor=UpperCAmelCase	)
            processor_fast.save_pretrained(self.tmpdirname	)
            A_						  =				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 		__A	(   self							:				Any	):
            A_						  =				OwlViTProcessor(tokenizer=self.get_tokenizer()						,			image_processor=self.get_image_processor()	)
            processor.save_pretrained(self.tmpdirname	)

            A_						  =				self.get_tokenizer(bos_token="(BOS)"						,			eos_token="(EOS)"	)
            A_						  =				self.get_image_processor(do_normalize=UpperCAmelCase	)

            A_						  =				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 		__A	(   self							:				Any	):
            A_						  =				self.get_image_processor()
            A_						  =				self.get_tokenizer()

            A_						  =				OwlViTProcessor(tokenizer=UpperCAmelCase						,			image_processor=UpperCAmelCase	)

            A_						  =				self.prepare_image_inputs()

            A_						  =				image_processor(UpperCAmelCase						,			return_tensors="np"	)
            A_						  =				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 		__A	(   self							:				Optional[int]	):
            A_						  =				self.get_image_processor()
            A_						  =				self.get_tokenizer()

            A_						  =				OwlViTProcessor(tokenizer=UpperCAmelCase						,			image_processor=UpperCAmelCase	)

            A_						  =				"lower newer"

            A_						  =				processor(text=UpperCAmelCase						,			return_tensors="np"	)

            A_						  =				tokenizer(UpperCAmelCase						,			return_tensors="np"	)

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





      def 		__A	(   self							:				int	):
            A_						  =				self.get_image_processor()
            A_						  =				self.get_tokenizer()

            A_						  =				OwlViTProcessor(tokenizer=UpperCAmelCase						,			image_processor=UpperCAmelCase	)

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

            A_						  =				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 		__A	(   self							:				int	):
            A_						  =				"google/owlvit-base-patch32"
            A_						  =				OwlViTProcessor.from_pretrained(UpperCAmelCase	)

            A_						  =				["cat", "nasa badge"]
            A_						  =				processor(text=UpperCAmelCase	)

            A_						  =				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 		__A	(   self							:				Optional[int]	):
            A_						  =				"google/owlvit-base-patch32"
            A_						  =				OwlViTProcessor.from_pretrained(UpperCAmelCase	)

            A_						  =				[["cat", "nasa badge"], ["person"]]
            A_						  =				processor(text=UpperCAmelCase	)

            A_						  =				16
            A_						  =				len(UpperCAmelCase	)
            A_						  =				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 		__A	(   self							:				Optional[Any]	):
            A_						  =				"google/owlvit-base-patch32"
            A_						  =				OwlViTProcessor.from_pretrained(UpperCAmelCase	)

            A_						  =				["cat", "nasa badge"]
            A_						  =				processor(text=UpperCAmelCase	)

            A_						  =				16
            A_						  =				inputs["input_ids"]
            A_						  =				[
                [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 		__A	(   self							:				Tuple	):
            A_						  =				self.get_image_processor()
            A_						  =				self.get_tokenizer()

            A_						  =				OwlViTProcessor(tokenizer=UpperCAmelCase						,			image_processor=UpperCAmelCase	)

            A_						  =				self.prepare_image_inputs()
            A_						  =				self.prepare_image_inputs()

            A_						  =				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 		__A	(   self							:				List[str]	):
            A_						  =				self.get_image_processor()
            A_						  =				self.get_tokenizer()

            A_						  =				OwlViTProcessor(tokenizer=UpperCAmelCase						,			image_processor=UpperCAmelCase	)

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

            A_						  =				processor.batch_decode(UpperCAmelCase	)
            A_						  =				tokenizer.batch_decode(UpperCAmelCase	)

            self.assertListEqual(UpperCAmelCase						,			UpperCAmelCase	)





def 				A__ (snake_case   :		int				)     ->						bool:
					if number < 0:
										raise ValueError("""number must not be negative"""				)
					return number & (number - 1) == 0


if __name__ == "__main__":
	import doctest

	doctest.testmod()






