

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   __lowercase      (unittest.TestCase ):
 def 	UpperCamelCase__  (							self					)					->str:



       '''simple docstring'''





       __lowerCAmelCase					:						str					=					tempfile.mkdtemp()

       # fmt: off
       __lowerCAmelCase					:						Any					=					['''''', '''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
       __lowerCAmelCase					:						List[str]					=					dict(zip(A_      ,							range(len(A_					)					)					)					)
       __lowerCAmelCase					:						Tuple					=					['''#version: 0.2''', '''l o''', '''lo w</w>''', '''e r</w>''', '''''']
       __lowerCAmelCase					:						Dict					=					{'''unk_token''': '''<unk>'''}

       __lowerCAmelCase					:						Any					=					os.path.join(self.tmpdirname      ,							VOCAB_FILES_NAMES['''vocab_file''']					)
       __lowerCAmelCase					:						Optional[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(A_					) + '''\n'''					)
       with open(self.merges_file      ,							'''w'''      ,							encoding='''utf-8'''					) as fp:
             fp.write('''\n'''.join(A_					)					)

       __lowerCAmelCase					:						str					=					{
           '''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],
       }
       __lowerCAmelCase					:						Optional[int]					=					os.path.join(self.tmpdirname      ,							A_					)
       with open(self.image_processor_file      ,							'''w'''      ,							encoding='''utf-8'''					) as fp:
             json.dump(A_      ,							A_					)
 def 	UpperCamelCase__  (							self      ,							**A_					)					->Union[str, Any]:



       '''simple docstring'''





       return CLIPTokenizer.from_pretrained(self.tmpdirname      ,							pad_token='''!'''      ,							**A_					)
 def 	UpperCamelCase__  (							self      ,							**A_					)					->Union[str, Any]:



       '''simple docstring'''





       return CLIPTokenizerFast.from_pretrained(self.tmpdirname      ,							pad_token='''!'''      ,							**A_					)
 def 	UpperCamelCase__  (							self      ,							**A_					)					->str:



       '''simple docstring'''





       return OwlViTImageProcessor.from_pretrained(self.tmpdirname      ,							**A_					)
 def 	UpperCamelCase__  (							self					)					->Any:



       '''simple docstring'''





       shutil.rmtree(self.tmpdirname					)
 def 	UpperCamelCase__  (							self					)					->str:



       '''simple docstring'''





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

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

       return image_inputs
 def 	UpperCamelCase__  (							self					)					->Dict:



       '''simple docstring'''





       __lowerCAmelCase					:						str					=					self.get_tokenizer()
       __lowerCAmelCase					:						List[Any]					=					self.get_rust_tokenizer()
       __lowerCAmelCase					:						str					=					self.get_image_processor()

       __lowerCAmelCase					:						Tuple					=					OwlViTProcessor(tokenizer=A_      ,							image_processor=A_					)
       processor_slow.save_pretrained(self.tmpdirname					)
       __lowerCAmelCase					:						Optional[int]					=					OwlViTProcessor.from_pretrained(self.tmpdirname      ,							use_fast=A_					)

       __lowerCAmelCase					:						Union[str, Any]					=					OwlViTProcessor(tokenizer=A_      ,							image_processor=A_					)
       processor_fast.save_pretrained(self.tmpdirname					)
       __lowerCAmelCase					:						Union[str, 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      ,							A_					)
       self.assertIsInstance(processor_fast.tokenizer      ,							A_					)

       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      ,							A_					)
       self.assertIsInstance(processor_fast.image_processor      ,							A_					)
 def 	UpperCamelCase__  (							self					)					->Optional[Any]:



       '''simple docstring'''





       __lowerCAmelCase					:						List[Any]					=					OwlViTProcessor(tokenizer=self.get_tokenizer()      ,							image_processor=self.get_image_processor()					)
       processor.save_pretrained(self.tmpdirname					)

       __lowerCAmelCase					:						Any					=					self.get_tokenizer(bos_token='''(BOS)'''      ,							eos_token='''(EOS)'''					)
       __lowerCAmelCase					:						Union[str, Any]					=					self.get_image_processor(do_normalize=A_					)

       __lowerCAmelCase					:						Optional[Any]					=					OwlViTProcessor.from_pretrained(
           self.tmpdirname      ,							bos_token='''(BOS)'''      ,							eos_token='''(EOS)'''      ,							do_normalize=A_					)

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

       self.assertEqual(processor.image_processor.to_json_string()      ,							image_processor_add_kwargs.to_json_string()					)
       self.assertIsInstance(processor.image_processor      ,							A_					)
 def 	UpperCamelCase__  (							self					)					->Tuple:



       '''simple docstring'''





       __lowerCAmelCase					:						Dict					=					self.get_image_processor()
       __lowerCAmelCase					:						List[Any]					=					self.get_tokenizer()

       __lowerCAmelCase					:						Optional[Any]					=					OwlViTProcessor(tokenizer=A_      ,							image_processor=A_					)

       __lowerCAmelCase					:						Tuple					=					self.prepare_image_inputs()

       __lowerCAmelCase					:						Optional[Any]					=					image_processor(A_      ,							return_tensors='''np'''					)
       __lowerCAmelCase					:						Union[str, Any]					=					processor(images=A_      ,							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					)					->Any:



       '''simple docstring'''





       __lowerCAmelCase					:						int					=					self.get_image_processor()
       __lowerCAmelCase					:						Optional[Any]					=					self.get_tokenizer()

       __lowerCAmelCase					:						Optional[int]					=					OwlViTProcessor(tokenizer=A_      ,							image_processor=A_					)

       __lowerCAmelCase					:						Tuple					=					'''lower newer'''

       __lowerCAmelCase					:						List[str]					=					processor(text=A_      ,							return_tensors='''np'''					)

       __lowerCAmelCase					:						List[str]					=					tokenizer(A_      ,							return_tensors='''np'''					)

       for key in encoded_tok.keys():
             self.assertListEqual(encoded_tok[key][0].tolist()      ,							encoded_processor[key][0].tolist()					)
 def 	UpperCamelCase__  (							self					)					->Tuple:



       '''simple docstring'''





       __lowerCAmelCase					:						str					=					self.get_image_processor()
       __lowerCAmelCase					:						Any					=					self.get_tokenizer()

       __lowerCAmelCase					:						List[str]					=					OwlViTProcessor(tokenizer=A_      ,							image_processor=A_					)

       __lowerCAmelCase					:						Tuple					=					'''lower newer'''
       __lowerCAmelCase					:						str					=					self.prepare_image_inputs()

       __lowerCAmelCase					:						int					=					processor(text=A_      ,							images=A_					)

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

       # test if it raises when no input is passed
       with pytest.raises(A_					):
             processor()
 def 	UpperCamelCase__  (							self					)					->List[Any]:



       '''simple docstring'''





       __lowerCAmelCase					:						Union[str, Any]					=					'''google/owlvit-base-patch32'''
       __lowerCAmelCase					:						Any					=					OwlViTProcessor.from_pretrained(A_					)

       __lowerCAmelCase					:						List[str]					=					['''cat''', '''nasa badge''']
       __lowerCAmelCase					:						str					=					processor(text=A_					)

       __lowerCAmelCase					:						Optional[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(A_					):
             processor()
 def 	UpperCamelCase__  (							self					)					->List[Any]:



       '''simple docstring'''





       __lowerCAmelCase					:						Union[str, Any]					=					'''google/owlvit-base-patch32'''
       __lowerCAmelCase					:						Optional[Any]					=					OwlViTProcessor.from_pretrained(A_					)

       __lowerCAmelCase					:						Dict					=					[['''cat''', '''nasa badge'''], ['''person''']]
       __lowerCAmelCase					:						List[Any]					=					processor(text=A_					)

       __lowerCAmelCase					:						List[Any]					=					16
       __lowerCAmelCase					:						List[str]					=					len(A_					)
       __lowerCAmelCase					:						Dict					=					max([len(A_					) 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(A_					):
             processor()
 def 	UpperCamelCase__  (							self					)					->List[str]:



       '''simple docstring'''





       __lowerCAmelCase					:						List[str]					=					'''google/owlvit-base-patch32'''
       __lowerCAmelCase					:						List[Any]					=					OwlViTProcessor.from_pretrained(A_					)

       __lowerCAmelCase					:						Tuple					=					['''cat''', '''nasa badge''']
       __lowerCAmelCase					:						List[str]					=					processor(text=A_					)

       __lowerCAmelCase					:						Dict					=					16
       __lowerCAmelCase					:						Optional[int]					=					inputs['''input_ids''']
       __lowerCAmelCase					:						List[Any]					=					[
           [4_9406, 2368, 4_9407, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
           [4_9406, 6841, 1_1301, 4_9407, 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					)					->List[Any]:



       '''simple docstring'''





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

       __lowerCAmelCase					:						Optional[Any]					=					OwlViTProcessor(tokenizer=A_      ,							image_processor=A_					)

       __lowerCAmelCase					:						List[str]					=					self.prepare_image_inputs()
       __lowerCAmelCase					:						Union[str, Any]					=					self.prepare_image_inputs()

       __lowerCAmelCase					:						Optional[Any]					=					processor(images=A_      ,							query_images=A_					)

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

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





 def 	UpperCamelCase__  (							self					)					->Optional[int]:



       '''simple docstring'''





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

       __lowerCAmelCase					:						str					=					OwlViTProcessor(tokenizer=A_      ,							image_processor=A_					)

       __lowerCAmelCase					:						Union[str, Any]					=					[[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

       __lowerCAmelCase					:						Any					=					processor.batch_decode(A_					)
       __lowerCAmelCase					:						Dict					=					tokenizer.batch_decode(A_					)

       self.assertListEqual(A_      ,							A_					)





def 		_lowercase (     lowercase__   ,	lowercase__						):
      if a < 0 or b < 0:
            raise ValueError('''the value of both inputs must be positive'''						)
      __lowerCAmelCase					:						int					=					str(bin(lowercase__						)						)[2:]  # remove the leading "0b"
      __lowerCAmelCase					:						Any					=					str(bin(lowercase__						)						)[2:]
      __lowerCAmelCase					:						List[str]					=					max(len(lowercase__						)   ,	len(lowercase__						)						)
      return "0b" + "".join(
          str(int('''1''' in (char_a, char_b)						)						)
          for char_a, char_b in zip(a_binary.zfill(lowercase__						)   ,	b_binary.zfill(lowercase__						)						)						)


if __name__ == "__main__":
 import doctest

 doctest.testmod()


