





from typing import List, Union

import numpy as np

from ..tokenization_utils import TruncationStrategy
from ..utils import add_end_docstrings, logging
from .base import PIPELINE_INIT_ARGS, ArgumentHandler, ChunkPipeline


UpperCAmelCase						:   int			  =     logging.get_logger(__name__)





class 						_A(					snake_case__   ):


				"""simple docstring"""


				def 					UpperCAmelCase_		(			self     ,					_A     ):
									if isinstance(_A     ,					_A     ):
														__A	:						Optional[Any]       =				[label.strip() for label in labels.split(','     ) if label.strip()]
									return labels





				def __call__(			self     ,					_A     ,					_A     ,					_A     ):
									if len(_A     ) == 0 or len(_A     ) == 0:
														raise ValueError('You must include at least one label and at least one sequence.'     )
									if hypothesis_template.format(labels[0]     ) == hypothesis_template:
														raise ValueError(
														    (
														        'The provided hypothesis_template "{}" was not able to be formatted with the target labels. '
														        'Make sure the passed template includes formatting syntax such as {{}} where the label should go.'
														    ).format(_A     )     )

									if isinstance(_A     ,					_A     ):
														__A	:						Optional[int]       =				[sequences]

									__A	:						Any       =				[]
									for sequence in sequences:
														sequence_pairs.extend([[sequence, hypothesis_template.format(_A     )] for label in labels]     )

									return sequence_pairs, sequences





@add_end_docstrings(snake_case__   )
class 						_A(					snake_case__   ):


				"""simple docstring"""


				def __init__(			self     ,					_A=ZeroShotClassificationArgumentHandler()     ,					*_A     ,					**_A     ):
									__A	:						Optional[int]       =				args_parser
									super().__init__(*_A     ,					**_A     )
									if self.entailment_id == -1:
														logger.warning(
														    'Failed to determine \'entailment\' label id from the label2id mapping in the model config. Setting to '
														    '-1. Define a descriptive label2id mapping in the model config to ensure correct outputs.'     )



				@property
				def 					UpperCAmelCase_		(			self     ):
									for label, ind in self.model.config.labelaid.items():
														if label.lower().startswith('entail'     ):
																			return ind
									return -1



				def 					UpperCAmelCase_		(			self     ,					_A     ,					_A=True     ,					_A=True     ,					_A=TruncationStrategy.ONLY_FIRST     ,					**_A     ):
									__A	:						Union[str, Any]       =				self.framework
									if self.tokenizer.pad_token is None:
														# Override for tokenizers not supporting padding
														logger.error(
														    'Tokenizer was not supporting padding necessary for zero-shot, attempting to use '
														    ' `pad_token=eos_token`'     )
														__A	:						Tuple       =				self.tokenizer.eos_token
									try:
														__A	:						Tuple       =				self.tokenizer(
														    _A     ,					add_special_tokens=_A     ,					return_tensors=_A     ,					padding=_A     ,					truncation=_A     ,					)
									except Exception as e:
														if "too short" in str(_A     ):
																			# tokenizers might yell that we want to truncate
																			# to a value that is not even reached by the input.
																			# In that case we don't want to truncate.
																			# It seems there's not a really better way to catch that
																			# exception.

																			__A	:						Optional[int]       =				self.tokenizer(
																			    _A     ,					add_special_tokens=_A     ,					return_tensors=_A     ,					padding=_A     ,					truncation=TruncationStrategy.DO_NOT_TRUNCATE     ,					)
														else:
																			raise e

									return inputs



				def 					UpperCAmelCase_		(			self     ,					**_A     ):
									if kwargs.get('multi_class'     ,					_A     ) is not None:
														__A	:						Optional[int]       =				kwargs['multi_class']
														logger.warning(
														    'The `multi_class` argument has been deprecated and renamed to `multi_label`. '
														    '`multi_class` will be removed in a future version of Transformers.'     )
									__A	:						int       =				{}
									if "candidate_labels" in kwargs:
														__A	:						Union[str, Any]       =				self._args_parser._parse_labels(kwargs['candidate_labels']     )
									if "hypothesis_template" in kwargs:
														__A	:						int       =				kwargs['hypothesis_template']

									__A	:						Dict       =				{}
									if "multi_label" in kwargs:
														__A	:						Union[str, Any]       =				kwargs['multi_label']
									return preprocess_params, {}, postprocess_params



				def __call__(			self     ,					_A     ,					*_A     ,					**_A     ,					):
									if len(_A     ) == 0:
														pass
									elif len(_A     ) == 1 and "candidate_labels" not in kwargs:
														__A	:						Optional[int]       =				args[0]
									else:
														raise ValueError(F"""Unable to understand extra arguments {args}"""     )

									return super().__call__(_A     ,					**_A     )



				def 					UpperCAmelCase_		(			self     ,					_A     ,					_A=None     ,					_A="This example is {}."     ):
									__A    ,				__A	:						Union[str, Any]       =				self._args_parser(_A     ,					_A     ,					_A     )

									for i, (candidate_label, sequence_pair) in enumerate(zip(_A     ,					_A     )     ):
														__A	:						Union[str, Any]       =				self._parse_and_tokenize([sequence_pair]     )

														yield {
														    "candidate_label": candidate_label,
														    "sequence": sequences[0],
														    "is_last": i == len(_A     ) - 1,
														    **model_input,
														}



				def 					UpperCAmelCase_		(			self     ,					_A     ):
									__A	:						Dict       =				inputs['candidate_label']
									__A	:						Optional[Any]       =				inputs['sequence']
									__A	:						List[Any]       =				{k: inputs[k] for k in self.tokenizer.model_input_names}
									__A	:						Optional[Any]       =				self.model(**_A     )

									__A	:						Optional[Any]       =				{
									    'candidate_label': candidate_label,
									    'sequence': sequence,
									    'is_last': inputs['is_last'],
									    **outputs,
									}
									return model_outputs





				def 					UpperCAmelCase_		(			self     ,					_A     ,					_A=False     ):
									__A	:						List[Any]       =				[outputs['candidate_label'] for outputs in model_outputs]
									__A	:						Optional[Any]       =				[outputs['sequence'] for outputs in model_outputs]
									__A	:						Optional[Any]       =				np.concatenate([output['logits'].numpy() for output in model_outputs]     )
									__A	:						str       =				logits.shape[0]
									__A	:						Optional[int]       =				len(_A     )
									__A	:						Tuple       =				N // n
									__A	:						Optional[int]       =				logits.reshape((num_sequences, n, -1)     )

									if multi_label or len(_A     ) == 1:
														# softmax over the entailment vs. contradiction dim for each label independently
														__A	:						Union[str, Any]       =				self.entailment_id
														__A	:						Tuple       =				-1 if entailment_id == 0 else 0
														__A	:						Dict       =				reshaped_outputs[..., [contradiction_id, entailment_id]]
														__A	:						Any       =				np.exp(_A     ) / np.exp(_A     ).sum(-1     ,					keepdims=_A     )
														__A	:						List[str]       =				scores[..., 1]
									else:
														# softmax the "entailment" logits over all candidate labels
														__A	:						Any       =				reshaped_outputs[..., self.entailment_id]
														__A	:						Union[str, Any]       =				np.exp(_A     ) / np.exp(_A     ).sum(-1     ,					keepdims=_A     )

									__A	:						Union[str, Any]       =				list(reversed(scores[0].argsort()     )     )
									return {
									    "sequence": sequences[0],
									    "labels": [candidate_labels[i] for i in top_inds],
									    "scores": scores[0, top_inds].tolist(),
									}











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 					UpperCAmelCase_		(			self     ):
									__A	:						List[Any]       =				tempfile.mkdtemp()

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

									__A	:						Optional[int]       =				os.path.join(self.tmpdirname     ,					VOCAB_FILES_NAMES['vocab_file']     )
									__A	:						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     )     )

									__A	:						List[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],
									}
									__A	:						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     ):
									return CLIPTokenizer.from_pretrained(self.tmpdirname     ,					pad_token='!'     ,					**_A     )



				def 					UpperCAmelCase_		(			self     ,					**_A     ):
									return CLIPTokenizerFast.from_pretrained(self.tmpdirname     ,					pad_token='!'     ,					**_A     )



				def 					UpperCAmelCase_		(			self     ,					**_A     ):
									return OwlViTImageProcessor.from_pretrained(self.tmpdirname     ,					**_A     )



				def 					UpperCAmelCase_		(			self     ):
									shutil.rmtree(self.tmpdirname     )



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

									__A	:						Optional[int]       =				[Image.fromarray(np.moveaxis(_A     ,					0     ,					-1     )     ) for x in image_inputs]

									return image_inputs



				def 					UpperCAmelCase_		(			self     ):
									__A	:						List[Any]       =				self.get_tokenizer()
									__A	:						str       =				self.get_rust_tokenizer()
									__A	:						List[str]       =				self.get_image_processor()

									__A	:						Optional[int]       =				OwlViTProcessor(tokenizer=_A     ,					image_processor=_A     )
									processor_slow.save_pretrained(self.tmpdirname     )
									__A	:						int       =				OwlViTProcessor.from_pretrained(self.tmpdirname     ,					use_fast=_A     )

									__A	:						Optional[Any]       =				OwlViTProcessor(tokenizer=_A     ,					image_processor=_A     )
									processor_fast.save_pretrained(self.tmpdirname     )
									__A	:						Optional[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     ):
									__A	:						List[str]       =				OwlViTProcessor(tokenizer=self.get_tokenizer()     ,					image_processor=self.get_image_processor()     )
									processor.save_pretrained(self.tmpdirname     )

									__A	:						Optional[int]       =				self.get_tokenizer(bos_token='(BOS)'     ,					eos_token='(EOS)'     )
									__A	:						Optional[int]       =				self.get_image_processor(do_normalize=_A     )

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

									__A	:						Union[str, Any]       =				OwlViTProcessor(tokenizer=_A     ,					image_processor=_A     )

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

									__A	:						int       =				image_processor(_A     ,					return_tensors='np'     )
									__A	:						str       =				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     ):
									__A	:						str       =				self.get_image_processor()
									__A	:						str       =				self.get_tokenizer()

									__A	:						Tuple       =				OwlViTProcessor(tokenizer=_A     ,					image_processor=_A     )

									__A	:						str       =				'lower newer'

									__A	:						str       =				processor(text=_A     ,					return_tensors='np'     )

									__A	:						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     ):
									__A	:						int       =				self.get_image_processor()
									__A	:						Optional[int]       =				self.get_tokenizer()

									__A	:						List[str]       =				OwlViTProcessor(tokenizer=_A     ,					image_processor=_A     )

									__A	:						Any       =				'lower newer'
									__A	:						Optional[Any]       =				self.prepare_image_inputs()

									__A	:						List[Any]       =				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     ):
									__A	:						Any       =				'google/owlvit-base-patch32'
									__A	:						int       =				OwlViTProcessor.from_pretrained(_A     )

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

									__A	:						Optional[int]       =				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     ):
									__A	:						Tuple       =				'google/owlvit-base-patch32'
									__A	:						Any       =				OwlViTProcessor.from_pretrained(_A     )

									__A	:						Dict       =				[['cat', 'nasa badge'], ['person']]
									__A	:						Dict       =				processor(text=_A     )

									__A	:						Optional[int]       =				16
									__A	:						Any       =				len(_A     )
									__A	:						Union[str, Any]       =				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     ):
									__A	:						List[Any]       =				'google/owlvit-base-patch32'
									__A	:						str       =				OwlViTProcessor.from_pretrained(_A     )

									__A	:						Union[str, Any]       =				['cat', 'nasa badge']
									__A	:						Tuple       =				processor(text=_A     )

									__A	:						str       =				16
									__A	:						int       =				inputs['input_ids']
									__A	:						List[Any]       =				[
									    [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 					UpperCAmelCase_		(			self     ):
									__A	:						Optional[Any]       =				self.get_image_processor()
									__A	:						List[str]       =				self.get_tokenizer()

									__A	:						Optional[Any]       =				OwlViTProcessor(tokenizer=_A     ,					image_processor=_A     )

									__A	:						Optional[int]       =				self.prepare_image_inputs()
									__A	:						Optional[int]       =				self.prepare_image_inputs()

									__A	:						Optional[int]       =				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     ):
									__A	:						Optional[Any]       =				self.get_image_processor()
									__A	:						Union[str, Any]       =				self.get_tokenizer()

									__A	:						str       =				OwlViTProcessor(tokenizer=_A     ,					image_processor=_A     )

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

									__A	:						Any       =				processor.batch_decode(_A     )
									__A	:						Tuple       =				tokenizer.batch_decode(_A     )

									self.assertListEqual(_A     ,					_A     )




