
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	):






				def 							_lowerCamelCase		(						self					:      Any   ):






							'''simple docstring'''







							lowerCAmelCase__      :      List[Any]         =		tempfile.mkdtemp()

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

							lowerCAmelCase__      :      int         =		os.path.join(self.tmpdirname    ,     VOCAB_FILES_NAMES['vocab_file']   )
							lowerCAmelCase__      :      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__      :      Any         =		{
							    'do_resize': True,
							    'size': 20,
							    'do_center_crop': True,
							    'crop_size': 18,
							    'do_normalize': True,
							    'image_mean': [0.4_8_1_4_5_4_6_6, 0.4_5_7_8_2_7_5, 0.4_0_8_2_1_0_7_3],
							    'image_std': [0.2_6_8_6_2_9_5_4, 0.2_6_1_3_0_2_5_8, 0.2_7_5_7_7_7_1_1],
							}
							lowerCAmelCase__      :      Union[str, Any]         =		os.path.join(self.tmpdirname    ,     a   )
							with open(self.image_processor_file    ,     'w'    ,     encoding='utf-8'   ) as fp:
										json.dump(a    ,     a   )






				def 							_lowerCamelCase		(						self					:      Tuple    ,     **a					:      Dict   ):






							'''simple docstring'''







							return CLIPTokenizer.from_pretrained(self.tmpdirname    ,     pad_token='!'    ,     **a   )






				def 							_lowerCamelCase		(						self					:      Optional[int]    ,     **a					:      Optional[Any]   ):






							'''simple docstring'''







							return CLIPTokenizerFast.from_pretrained(self.tmpdirname    ,     pad_token='!'    ,     **a   )






				def 							_lowerCamelCase		(						self					:      Tuple    ,     **a					:      Optional[int]   ):






							'''simple docstring'''







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






				def 							_lowerCamelCase		(						self					:      Optional[Any]   ):






							'''simple docstring'''







							shutil.rmtree(self.tmpdirname   )






				def 							_lowerCamelCase		(						self					:      Union[str, Any]   ):






							'''simple docstring'''







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

							lowerCAmelCase__      :      str         =		[Image.fromarray(np.moveaxis(a    ,     0    ,     -1   )   ) for x in image_inputs]

							return image_inputs






				def 							_lowerCamelCase		(						self					:      int   ):






							'''simple docstring'''







							lowerCAmelCase__      :      Dict         =		self.get_tokenizer()
							lowerCAmelCase__      :      int         =		self.get_rust_tokenizer()
							lowerCAmelCase__      :      Optional[int]         =		self.get_image_processor()

							lowerCAmelCase__      :      Any         =		OwlViTProcessor(tokenizer=a    ,     image_processor=a   )
							processor_slow.save_pretrained(self.tmpdirname   )
							lowerCAmelCase__      :      Optional[Any]         =		OwlViTProcessor.from_pretrained(self.tmpdirname    ,     use_fast=a   )

							lowerCAmelCase__      :      Dict         =		OwlViTProcessor(tokenizer=a    ,     image_processor=a   )
							processor_fast.save_pretrained(self.tmpdirname   )
							lowerCAmelCase__      :      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    ,     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 							_lowerCamelCase		(						self					:      int   ):






							'''simple docstring'''







							lowerCAmelCase__      :      Union[str, Any]         =		OwlViTProcessor(tokenizer=self.get_tokenizer()    ,     image_processor=self.get_image_processor()   )
							processor.save_pretrained(self.tmpdirname   )

							lowerCAmelCase__      :      int         =		self.get_tokenizer(bos_token='(BOS)'    ,     eos_token='(EOS)'   )
							lowerCAmelCase__      :      Optional[int]         =		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 							_lowerCamelCase		(						self					:      Tuple   ):






							'''simple docstring'''







							lowerCAmelCase__      :      Optional[Any]         =		self.get_image_processor()
							lowerCAmelCase__      :      Dict         =		self.get_tokenizer()

							lowerCAmelCase__      :      Any         =		OwlViTProcessor(tokenizer=a    ,     image_processor=a   )

							lowerCAmelCase__      :      Tuple         =		self.prepare_image_inputs()

							lowerCAmelCase__      :      Optional[Any]         =		image_processor(a    ,     return_tensors='np'   )
							lowerCAmelCase__      :      int         =		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 							_lowerCamelCase		(						self					:      Union[str, Any]   ):






							'''simple docstring'''







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

							lowerCAmelCase__      :      Optional[int]         =		OwlViTProcessor(tokenizer=a    ,     image_processor=a   )

							lowerCAmelCase__      :      Optional[Any]         =		'lower newer'

							lowerCAmelCase__      :      Optional[Any]         =		processor(text=a    ,     return_tensors='np'   )

							lowerCAmelCase__      :      Any         =		tokenizer(a    ,     return_tensors='np'   )

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






				def 							_lowerCamelCase		(						self					:      Optional[Any]   ):






							'''simple docstring'''







							lowerCAmelCase__      :      int         =		self.get_image_processor()
							lowerCAmelCase__      :      List[Any]         =		self.get_tokenizer()

							lowerCAmelCase__      :      List[Any]         =		OwlViTProcessor(tokenizer=a    ,     image_processor=a   )

							lowerCAmelCase__      :      Dict         =		'lower newer'
							lowerCAmelCase__      :      Optional[int]         =		self.prepare_image_inputs()

							lowerCAmelCase__      :      List[str]         =		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 							_lowerCamelCase		(						self					:      Union[str, Any]   ):






							'''simple docstring'''







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

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

							lowerCAmelCase__      :      str         =		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 							_lowerCamelCase		(						self					:      Dict   ):






							'''simple docstring'''







							lowerCAmelCase__      :      str         =		'google/owlvit-base-patch32'
							lowerCAmelCase__      :      Dict         =		OwlViTProcessor.from_pretrained(a   )

							lowerCAmelCase__      :      Optional[int]         =		[['cat', 'nasa badge'], ['person']]
							lowerCAmelCase__      :      List[Any]         =		processor(text=a   )

							lowerCAmelCase__      :      Union[str, Any]         =		16
							lowerCAmelCase__      :      Union[str, Any]         =		len(a   )
							lowerCAmelCase__      :      List[str]         =		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 							_lowerCamelCase		(						self					:      Any   ):






							'''simple docstring'''







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

							lowerCAmelCase__      :      Dict         =		['cat', 'nasa badge']
							lowerCAmelCase__      :      Optional[Any]         =		processor(text=a   )

							lowerCAmelCase__      :      List[Any]         =		16
							lowerCAmelCase__      :      Dict         =		inputs['input_ids']
							lowerCAmelCase__      :      str         =		[
							    [49_406, 2_368, 49_407, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
							    [49_406, 6_841, 11_301, 49_407, 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 							_lowerCamelCase		(						self					:      Any   ):






							'''simple docstring'''







							lowerCAmelCase__      :      Union[str, Any]         =		self.get_image_processor()
							lowerCAmelCase__      :      Tuple         =		self.get_tokenizer()

							lowerCAmelCase__      :      Union[str, Any]         =		OwlViTProcessor(tokenizer=a    ,     image_processor=a   )

							lowerCAmelCase__      :      Tuple         =		self.prepare_image_inputs()
							lowerCAmelCase__      :      Dict         =		self.prepare_image_inputs()

							lowerCAmelCase__      :      List[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 							_lowerCamelCase		(						self					:      Optional[Any]   ):






							'''simple docstring'''







							lowerCAmelCase__      :      Dict         =		self.get_image_processor()
							lowerCAmelCase__      :      Optional[int]         =		self.get_tokenizer()

							lowerCAmelCase__      :      Tuple         =		OwlViTProcessor(tokenizer=a    ,     image_processor=a   )

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

							lowerCAmelCase__      :      Optional[Any]         =		processor.batch_decode(a   )
							lowerCAmelCase__      :      Dict         =		tokenizer.batch_decode(a   )

							self.assertListEqual(a    ,     a   )

import re
def  lowerCAmelCase__			(  SCREAMING_SNAKE_CASE_     )				->		str:

			if len(re.findall('[ATCG]'       ,							SCREAMING_SNAKE_CASE_     )     ) != len(SCREAMING_SNAKE_CASE_     ):
						raise ValueError('Invalid Strand'     )

			return dna.translate(dna.maketrans('ATCG'       ,							'TAGC'     )     )


if __name__ == "__main__":
					import doctest

					doctest.testmod()