






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







				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__		:Union[str, Any]        =      tempfile.mkdtemp()

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

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

								__magic_name__		:Dict        =      {
								    '''do_resize''': True,
								    '''size''': 2_0,
								    '''do_center_crop''': True,
								    '''crop_size''': 1_8,
								    '''do_normalize''': True,
								    '''image_mean''': [0.48145466, 0.4578275, 0.40821073],
								    '''image_std''': [0.26862954, 0.26130258, 0.27577711],
								}
								__magic_name__		:Union[str, Any]        =      os.path.join(self.tmpdirname       ,					__lowerCAmelCase     )
								with open(self.image_processor_file       ,					'''w'''       ,					encoding='''utf-8'''     ) as fp:
												json.dump(__lowerCAmelCase       ,					__lowerCAmelCase     )







				def 			A	(						self       ,					**__lowerCAmelCase     ):
								"""simple docstring"""
								return CLIPTokenizer.from_pretrained(self.tmpdirname       ,					pad_token='''!'''       ,					**__lowerCAmelCase     )







				def 			A	(						self       ,					**__lowerCAmelCase     ):
								"""simple docstring"""
								return CLIPTokenizerFast.from_pretrained(self.tmpdirname       ,					pad_token='''!'''       ,					**__lowerCAmelCase     )







				def 			A	(						self       ,					**__lowerCAmelCase     ):
								"""simple docstring"""
								return OwlViTImageProcessor.from_pretrained(self.tmpdirname       ,					**__lowerCAmelCase     )







				def 			A	(						self     ):
								"""simple docstring"""
								shutil.rmtree(self.tmpdirname     )







				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__		:Dict        =      [np.random.randint(2_5_5       ,					size=(3, 3_0, 4_0_0)       ,					dtype=np.uinta     )]

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

								return image_inputs







				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__		:Tuple        =      self.get_tokenizer()
								__magic_name__		:Optional[int]        =      self.get_rust_tokenizer()
								__magic_name__		:List[str]        =      self.get_image_processor()

								__magic_name__		:Optional[Any]        =      OwlViTProcessor(tokenizer=__lowerCAmelCase       ,					image_processor=__lowerCAmelCase     )
								processor_slow.save_pretrained(self.tmpdirname     )
								__magic_name__		:Union[str, Any]        =      OwlViTProcessor.from_pretrained(self.tmpdirname       ,					use_fast=__lowerCAmelCase     )

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

								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       ,					__lowerCAmelCase     )
								self.assertIsInstance(processor_fast.image_processor       ,					__lowerCAmelCase     )







				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__		:int        =      OwlViTProcessor(tokenizer=self.get_tokenizer()       ,					image_processor=self.get_image_processor()     )
								processor.save_pretrained(self.tmpdirname     )

								__magic_name__		:Any        =      self.get_tokenizer(bos_token='''(BOS)'''       ,					eos_token='''(EOS)'''     )
								__magic_name__		:Tuple        =      self.get_image_processor(do_normalize=__lowerCAmelCase     )

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

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

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







				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__		:int        =      self.get_image_processor()
								__magic_name__		:str        =      self.get_tokenizer()

								__magic_name__		:List[Any]        =      OwlViTProcessor(tokenizer=__lowerCAmelCase       ,					image_processor=__lowerCAmelCase     )

								__magic_name__		:int        =      self.prepare_image_inputs()

								__magic_name__		:Dict        =      image_processor(__lowerCAmelCase       ,					return_tensors='''np'''     )
								__magic_name__		:List[Any]        =      processor(images=__lowerCAmelCase       ,					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     ):
								"""simple docstring"""
								__magic_name__		:int        =      self.get_image_processor()
								__magic_name__		:str        =      self.get_tokenizer()

								__magic_name__		:Tuple        =      OwlViTProcessor(tokenizer=__lowerCAmelCase       ,					image_processor=__lowerCAmelCase     )

								__magic_name__		:str        =      '''lower newer'''

								__magic_name__		:Any        =      processor(text=__lowerCAmelCase       ,					return_tensors='''np'''     )

								__magic_name__		:Dict        =      tokenizer(__lowerCAmelCase       ,					return_tensors='''np'''     )

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







				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__		:str        =      self.get_image_processor()
								__magic_name__		:Dict        =      self.get_tokenizer()

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

								__magic_name__		:Tuple        =      '''lower newer'''
								__magic_name__		:Tuple        =      self.prepare_image_inputs()

								__magic_name__		:Any        =      processor(text=__lowerCAmelCase       ,					images=__lowerCAmelCase     )

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

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







				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__		:str        =      '''google/owlvit-base-patch32'''
								__magic_name__		:int        =      OwlViTProcessor.from_pretrained(__lowerCAmelCase     )

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

								__magic_name__		:List[Any]        =      1_6
								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(__lowerCAmelCase     ):
												processor()







				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__		:Tuple        =      '''google/owlvit-base-patch32'''
								__magic_name__		:int        =      OwlViTProcessor.from_pretrained(__lowerCAmelCase     )

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

								__magic_name__		:List[Any]        =      1_6
								__magic_name__		:Union[str, Any]        =      len(__lowerCAmelCase     )
								__magic_name__		:int        =      max([len(__lowerCAmelCase     ) 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(__lowerCAmelCase     ):
												processor()







				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__		:Optional[Any]        =      '''google/owlvit-base-patch32'''
								__magic_name__		:Tuple        =      OwlViTProcessor.from_pretrained(__lowerCAmelCase     )

								__magic_name__		:List[Any]        =      ['''cat''', '''nasa badge''']
								__magic_name__		:Optional[Any]        =      processor(text=__lowerCAmelCase     )

								__magic_name__		:int        =      1_6
								__magic_name__		:Any        =      inputs['''input_ids''']
								__magic_name__		:Optional[int]        =      [
								    [4_9_4_0_6, 2_3_6_8, 4_9_4_0_7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
								    [4_9_4_0_6, 6_8_4_1, 1_1_3_0_1, 4_9_4_0_7, 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     ):
								"""simple docstring"""
								__magic_name__		:Dict        =      self.get_image_processor()
								__magic_name__		:Optional[int]        =      self.get_tokenizer()

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

								__magic_name__		:Tuple        =      self.prepare_image_inputs()
								__magic_name__		:Optional[Any]        =      self.prepare_image_inputs()

								__magic_name__		:Any        =      processor(images=__lowerCAmelCase       ,					query_images=__lowerCAmelCase     )

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

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







				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__		:List[Any]        =      self.get_image_processor()
								__magic_name__		:Dict        =      self.get_tokenizer()

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

								__magic_name__		:Any        =      [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

								__magic_name__		:Dict        =      processor.batch_decode(__lowerCAmelCase     )
								__magic_name__		:Dict        =      tokenizer.batch_decode(__lowerCAmelCase     )

								self.assertListEqual(__lowerCAmelCase       ,					__lowerCAmelCase     )














from __future__ import annotations

def      __lowercase					( snake_case,  snake_case ):







				"""simple docstring"""






				__magic_name__		:Tuple        =      0
				__magic_name__		:Tuple        =      len(snake_case ) - 1

				while i < j:
								if nums[i] + nums[j] == target:
												return [i, j]
								elif nums[i] + nums[j] < target:
												__magic_name__		:str        =      i + 1
								else:
												__magic_name__		:List[Any]        =      j - 1

				return []


if __name__ == "__main__":
					import doctest

					doctest.testmod()
					print(f"{two_pointer([2, 7, 11, 15], 9) = }")






