




'''simple docstring'''

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   A_ (		self    :					Tuple					):
									snake_case_									=				tempfile.mkdtemp()

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

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

									snake_case_									=				{
									    '''do_resize''': True,
									    '''size''': 20,
									    '''do_center_crop''': True,
									    '''crop_size''': 18,
									    '''do_normalize''': True,
									    '''image_mean''': [0.4814_5466, 0.457_8275, 0.4082_1073],
									    '''image_std''': [0.2686_2954, 0.2613_0258, 0.2757_7711],
									}
									snake_case_									=				os.path.join(self.tmpdirname       ,				lowercase_					)
									with open(self.image_processor_file       ,				'''w'''       ,				encoding='''utf-8'''					) as fp:
														json.dump(lowercase_       ,				lowercase_					)


				def   A_ (		self    :					Tuple       ,				**lowercase_    :					Tuple					):
									return CLIPTokenizer.from_pretrained(self.tmpdirname       ,				pad_token='''!'''       ,				**lowercase_					)


				def   A_ (		self    :					int       ,				**lowercase_    :					int					):
									return CLIPTokenizerFast.from_pretrained(self.tmpdirname       ,				pad_token='''!'''       ,				**lowercase_					)


				def   A_ (		self    :					Dict       ,				**lowercase_    :					Optional[Any]					):
									return OwlViTImageProcessor.from_pretrained(self.tmpdirname       ,				**lowercase_					)


				def   A_ (		self    :					Dict					):
									shutil.rmtree(self.tmpdirname					)


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

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

									return image_inputs


				def   A_ (		self    :					Dict					):
									snake_case_									=				self.get_tokenizer()
									snake_case_									=				self.get_rust_tokenizer()
									snake_case_									=				self.get_image_processor()

									snake_case_									=				OwlViTProcessor(tokenizer=lowercase_       ,				image_processor=lowercase_					)
									processor_slow.save_pretrained(self.tmpdirname					)
									snake_case_									=				OwlViTProcessor.from_pretrained(self.tmpdirname       ,				use_fast=lowercase_					)

									snake_case_									=				OwlViTProcessor(tokenizer=lowercase_       ,				image_processor=lowercase_					)
									processor_fast.save_pretrained(self.tmpdirname					)
									snake_case_									=				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       ,				lowercase_					)
									self.assertIsInstance(processor_fast.tokenizer       ,				lowercase_					)

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


				def   A_ (		self    :					Optional[Any]					):
									snake_case_									=				OwlViTProcessor(tokenizer=self.get_tokenizer()       ,				image_processor=self.get_image_processor()					)
									processor.save_pretrained(self.tmpdirname					)

									snake_case_									=				self.get_tokenizer(bos_token='''(BOS)'''       ,				eos_token='''(EOS)'''					)
									snake_case_									=				self.get_image_processor(do_normalize=lowercase_					)

									snake_case_									=				OwlViTProcessor.from_pretrained(
									    self.tmpdirname       ,				bos_token='''(BOS)'''       ,				eos_token='''(EOS)'''       ,				do_normalize=lowercase_					)

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

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


				def   A_ (		self    :					str					):
									snake_case_									=				self.get_image_processor()
									snake_case_									=				self.get_tokenizer()

									snake_case_									=				OwlViTProcessor(tokenizer=lowercase_       ,				image_processor=lowercase_					)

									snake_case_									=				self.prepare_image_inputs()

									snake_case_									=				image_processor(lowercase_       ,				return_tensors='''np'''					)
									snake_case_									=				processor(images=lowercase_       ,				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    :					Union[str, Any]					):
									snake_case_									=				self.get_image_processor()
									snake_case_									=				self.get_tokenizer()

									snake_case_									=				OwlViTProcessor(tokenizer=lowercase_       ,				image_processor=lowercase_					)

									snake_case_									=				'''lower newer'''

									snake_case_									=				processor(text=lowercase_       ,				return_tensors='''np'''					)

									snake_case_									=				tokenizer(lowercase_       ,				return_tensors='''np'''					)

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


				def   A_ (		self    :					Any					):
									snake_case_									=				self.get_image_processor()
									snake_case_									=				self.get_tokenizer()

									snake_case_									=				OwlViTProcessor(tokenizer=lowercase_       ,				image_processor=lowercase_					)

									snake_case_									=				'''lower newer'''
									snake_case_									=				self.prepare_image_inputs()

									snake_case_									=				processor(text=lowercase_       ,				images=lowercase_					)

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

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


				def   A_ (		self    :					int					):
									snake_case_									=				'''google/owlvit-base-patch32'''
									snake_case_									=				OwlViTProcessor.from_pretrained(lowercase_					)

									snake_case_									=				['''cat''', '''nasa badge''']
									snake_case_									=				processor(text=lowercase_					)

									snake_case_									=				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(lowercase_					):
														processor()


				def   A_ (		self    :					str					):
									snake_case_									=				'''google/owlvit-base-patch32'''
									snake_case_									=				OwlViTProcessor.from_pretrained(lowercase_					)

									snake_case_									=				[['''cat''', '''nasa badge'''], ['''person''']]
									snake_case_									=				processor(text=lowercase_					)

									snake_case_									=				16
									snake_case_									=				len(lowercase_					)
									snake_case_									=				max([len(lowercase_					) 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(lowercase_					):
														processor()


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

									snake_case_									=				['''cat''', '''nasa badge''']
									snake_case_									=				processor(text=lowercase_					)

									snake_case_									=				16
									snake_case_									=				inputs['''input_ids''']
									snake_case_									=				[
									    [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   A_ (		self    :					List[str]					):
									snake_case_									=				self.get_image_processor()
									snake_case_									=				self.get_tokenizer()

									snake_case_									=				OwlViTProcessor(tokenizer=lowercase_       ,				image_processor=lowercase_					)

									snake_case_									=				self.prepare_image_inputs()
									snake_case_									=				self.prepare_image_inputs()

									snake_case_									=				processor(images=lowercase_       ,				query_images=lowercase_					)

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

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


				def   A_ (		self    :					Any					):
									snake_case_									=				self.get_image_processor()
									snake_case_									=				self.get_tokenizer()

									snake_case_									=				OwlViTProcessor(tokenizer=lowercase_       ,				image_processor=lowercase_					)

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

									snake_case_									=				processor.batch_decode(lowercase_					)
									snake_case_									=				tokenizer.batch_decode(lowercase_					)

									self.assertListEqual(lowercase_       ,				lowercase_					)







'''simple docstring'''

# tests directory-specific settings - this file is run automatically
# by pytest before any tests are run

import doctest
import sys
import warnings
from os.path import abspath, dirname, join

import _pytest

from transformers.testing_utils import HfDoctestModule, HfDocTestParser


# allow having multiple repository checkouts and not needing to remember to rerun
# 'pip install -e .[dev]' when switching between checkouts and running tests.
a  :				int									=  abspath(join(dirname(__file__), 'src'))
sys.path.insert(1, git_repo_path)

# silence FutureWarning warnings in tests since often we can't act on them until
# they become normal warnings - i.e. the tests still need to test the current functionality
warnings.simplefilter(action='ignore', category=FutureWarning)


def 		__magic_name__    (	__UpperCAmelCase	)		->					Optional[int]:

					'''simple docstring'''

					config.addinivalue_line(
					    '''markers''',      '''is_pt_tf_cross_test: mark test to run only when PT and TF interactions are tested'''	)
					config.addinivalue_line(
					    '''markers''',      '''is_pt_flax_cross_test: mark test to run only when PT and FLAX interactions are tested'''	)
					config.addinivalue_line('''markers''',      '''is_pipeline_test: mark test to run only when pipelines are tested'''	)
					config.addinivalue_line('''markers''',      '''is_staging_test: mark test to run only in the staging environment'''	)
					config.addinivalue_line('''markers''',      '''accelerate_tests: mark test that require accelerate'''	)
					config.addinivalue_line('''markers''',      '''tool_tests: mark the tool tests that are run on their specific schedule'''	)


def 		__magic_name__    (	__UpperCAmelCase	)		->					int:

					'''simple docstring'''

					from transformers.testing_utils import pytest_addoption_shared

					pytest_addoption_shared(__UpperCAmelCase	)


def 		__magic_name__    (	__UpperCAmelCase	)		->					Union[str, Any]:

					'''simple docstring'''

					from transformers.testing_utils import pytest_terminal_summary_main

					snake_case_									=				terminalreporter.config.getoption('''--make-reports'''	)
					if make_reports:
										pytest_terminal_summary_main(__UpperCAmelCase,      id=__UpperCAmelCase	)


def 		__magic_name__    (	__UpperCAmelCase,      __UpperCAmelCase	)		->					Optional[int]:

					'''simple docstring'''

					if exitstatus == 5:
										snake_case_									=				0


# Doctest custom flag to ignore output.
a  :				Union[str, Any]									=  doctest.register_optionflag('IGNORE_RESULT')

a  :				Optional[int]									=  doctest.OutputChecker






class 						a				(   _lowerCamelCase     ):


				def   A_ (		self    :					List[Any]       ,				lowercase_    :					int       ,				lowercase_    :					Tuple       ,				lowercase_    :					Optional[int]					):
									if IGNORE_RESULT & optionflags:
														return True
									return OutputChecker.check_output(self       ,				lowercase_       ,				lowercase_       ,				lowercase_					)







a  :				List[Any]									=  CustomOutputChecker
a  :				Optional[int]									=  HfDoctestModule

a  :				Tuple									=  HfDocTestParser

