import unittest

from transformers import MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING, is_vision_available, pipeline
from transformers.testing_utils import (
    is_pipeline_test,
    nested_simplify,
    require_tf,
    require_torch,
    require_vision,
    slow,
)

from .test_pipelines_common import ANY


if is_vision_available():
					from PIL import Image
else:
					class     lowerCAmelCase_     :







												@staticmethod
												def  UpperCamelCase_						(   *_A      :     Optional[int] ,			**_A      :     Optional[Any]		):
																	pass
@is_pipeline_test
@require_vision
@require_torch
class     lowerCAmelCase_     (       unittest.TestCase ):
							UpperCAmelCase				   =     MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING







							def  UpperCamelCase_						(   self      :     Optional[Any] ,			_A      :     List[Any] ,			_A      :     Optional[Any] ,			_A      :     List[str]		):
												_UpperCamelCase			     =     pipeline(
												    '''zero-shot-object-detection''' ,			model='''hf-internal-testing/tiny-random-owlvit-object-detection'''		)

												_UpperCamelCase			     =     [
												    {
												        '''image''': '''./tests/fixtures/tests_samples/COCO/000000039769.png''',
												        '''candidate_labels''': ['''cat''', '''remote''', '''couch'''],
												    }
												]
												return object_detector, examples







							def  UpperCamelCase_						(   self      :     Dict ,			_A      :     Tuple ,			_A      :     str		):
												_UpperCamelCase			     =     object_detector(examples[0] ,			threshold=0.0		)

												_UpperCamelCase			     =     len(_A		)
												self.assertGreater(_A ,			0		)
												self.assertEqual(
												    _A ,			[
												        {
												            '''score''': ANY(_A		),
												            '''label''': ANY(_A		),
												            '''box''': {'''xmin''': ANY(_A		), '''ymin''': ANY(_A		), '''xmax''': ANY(_A		), '''ymax''': ANY(_A		)},
												        }
												        for i in range(_A		)
												    ] ,			)







							@require_tf
							@unittest.skip('''Zero Shot Object Detection not implemented in TF'''		)
							def  UpperCamelCase_						(   self      :     List[Any]		):
												pass







							@require_torch
							def  UpperCamelCase_						(   self      :     Optional[int]		):
												_UpperCamelCase			     =     pipeline(
												    '''zero-shot-object-detection''' ,			model='''hf-internal-testing/tiny-random-owlvit-object-detection'''		)

												_UpperCamelCase			     =     object_detector(
												    '''./tests/fixtures/tests_samples/COCO/000000039769.png''' ,			candidate_labels=['''cat''', '''remote''', '''couch'''] ,			threshold=0.64 ,			)

												self.assertEqual(
												    nested_simplify(_A ,			decimals=4		) ,			[
												        {'''score''': 0.7235, '''label''': '''cat''', '''box''': {'''xmin''': 204, '''ymin''': 167, '''xmax''': 232, '''ymax''': 190}},
												        {'''score''': 0.7218, '''label''': '''remote''', '''box''': {'''xmin''': 204, '''ymin''': 167, '''xmax''': 232, '''ymax''': 190}},
												        {'''score''': 0.7184, '''label''': '''couch''', '''box''': {'''xmin''': 204, '''ymin''': 167, '''xmax''': 232, '''ymax''': 190}},
												        {'''score''': 0.6748, '''label''': '''remote''', '''box''': {'''xmin''': 571, '''ymin''': 83, '''xmax''': 598, '''ymax''': 103}},
												        {'''score''': 0.6656, '''label''': '''cat''', '''box''': {'''xmin''': 571, '''ymin''': 83, '''xmax''': 598, '''ymax''': 103}},
												        {'''score''': 0.6614, '''label''': '''couch''', '''box''': {'''xmin''': 571, '''ymin''': 83, '''xmax''': 598, '''ymax''': 103}},
												        {'''score''': 0.6456, '''label''': '''remote''', '''box''': {'''xmin''': 494, '''ymin''': 105, '''xmax''': 521, '''ymax''': 127}},
												        {'''score''': 0.642, '''label''': '''remote''', '''box''': {'''xmin''': 67, '''ymin''': 274, '''xmax''': 93, '''ymax''': 297}},
												        {'''score''': 0.6419, '''label''': '''cat''', '''box''': {'''xmin''': 494, '''ymin''': 105, '''xmax''': 521, '''ymax''': 127}},
												    ] ,			)

												_UpperCamelCase			     =     object_detector(
												    [
												        {
												            '''image''': '''./tests/fixtures/tests_samples/COCO/000000039769.png''',
												            '''candidate_labels''': ['''cat''', '''remote''', '''couch'''],
												        }
												    ] ,			threshold=0.64 ,			)

												self.assertEqual(
												    nested_simplify(_A ,			decimals=4		) ,			[
												        [
												            {'''score''': 0.7235, '''label''': '''cat''', '''box''': {'''xmin''': 204, '''ymin''': 167, '''xmax''': 232, '''ymax''': 190}},
												            {'''score''': 0.7218, '''label''': '''remote''', '''box''': {'''xmin''': 204, '''ymin''': 167, '''xmax''': 232, '''ymax''': 190}},
												            {'''score''': 0.7184, '''label''': '''couch''', '''box''': {'''xmin''': 204, '''ymin''': 167, '''xmax''': 232, '''ymax''': 190}},
												            {'''score''': 0.6748, '''label''': '''remote''', '''box''': {'''xmin''': 571, '''ymin''': 83, '''xmax''': 598, '''ymax''': 103}},
												            {'''score''': 0.6656, '''label''': '''cat''', '''box''': {'''xmin''': 571, '''ymin''': 83, '''xmax''': 598, '''ymax''': 103}},
												            {'''score''': 0.6614, '''label''': '''couch''', '''box''': {'''xmin''': 571, '''ymin''': 83, '''xmax''': 598, '''ymax''': 103}},
												            {'''score''': 0.6456, '''label''': '''remote''', '''box''': {'''xmin''': 494, '''ymin''': 105, '''xmax''': 521, '''ymax''': 127}},
												            {'''score''': 0.642, '''label''': '''remote''', '''box''': {'''xmin''': 67, '''ymin''': 274, '''xmax''': 93, '''ymax''': 297}},
												            {'''score''': 0.6419, '''label''': '''cat''', '''box''': {'''xmin''': 494, '''ymin''': 105, '''xmax''': 521, '''ymax''': 127}},
												        ]
												    ] ,			)







							@require_torch
							@slow
							def  UpperCamelCase_						(   self      :     Dict		):
												_UpperCamelCase			     =     pipeline('''zero-shot-object-detection'''		)

												_UpperCamelCase			     =     object_detector(
												    '''http://images.cocodataset.org/val2017/000000039769.jpg''' ,			candidate_labels=['''cat''', '''remote''', '''couch'''] ,			)
												self.assertEqual(
												    nested_simplify(_A ,			decimals=4		) ,			[
												        {'''score''': 0.2868, '''label''': '''cat''', '''box''': {'''xmin''': 324, '''ymin''': 20, '''xmax''': 640, '''ymax''': 373}},
												        {'''score''': 0.277, '''label''': '''remote''', '''box''': {'''xmin''': 40, '''ymin''': 72, '''xmax''': 177, '''ymax''': 115}},
												        {'''score''': 0.2537, '''label''': '''cat''', '''box''': {'''xmin''': 1, '''ymin''': 55, '''xmax''': 315, '''ymax''': 472}},
												        {'''score''': 0.1474, '''label''': '''remote''', '''box''': {'''xmin''': 335, '''ymin''': 74, '''xmax''': 371, '''ymax''': 187}},
												        {'''score''': 0.1208, '''label''': '''couch''', '''box''': {'''xmin''': 4, '''ymin''': 0, '''xmax''': 642, '''ymax''': 476}},
												    ] ,			)

												_UpperCamelCase			     =     object_detector(
												    [
												        {
												            '''image''': '''http://images.cocodataset.org/val2017/000000039769.jpg''',
												            '''candidate_labels''': ['''cat''', '''remote''', '''couch'''],
												        },
												        {
												            '''image''': '''http://images.cocodataset.org/val2017/000000039769.jpg''',
												            '''candidate_labels''': ['''cat''', '''remote''', '''couch'''],
												        },
												    ] ,			)
												self.assertEqual(
												    nested_simplify(_A ,			decimals=4		) ,			[
												        [
												            {'''score''': 0.2868, '''label''': '''cat''', '''box''': {'''xmin''': 324, '''ymin''': 20, '''xmax''': 640, '''ymax''': 373}},
												            {'''score''': 0.277, '''label''': '''remote''', '''box''': {'''xmin''': 40, '''ymin''': 72, '''xmax''': 177, '''ymax''': 115}},
												            {'''score''': 0.2537, '''label''': '''cat''', '''box''': {'''xmin''': 1, '''ymin''': 55, '''xmax''': 315, '''ymax''': 472}},
												            {'''score''': 0.1474, '''label''': '''remote''', '''box''': {'''xmin''': 335, '''ymin''': 74, '''xmax''': 371, '''ymax''': 187}},
												            {'''score''': 0.1208, '''label''': '''couch''', '''box''': {'''xmin''': 4, '''ymin''': 0, '''xmax''': 642, '''ymax''': 476}},
												        ],
												        [
												            {'''score''': 0.2868, '''label''': '''cat''', '''box''': {'''xmin''': 324, '''ymin''': 20, '''xmax''': 640, '''ymax''': 373}},
												            {'''score''': 0.277, '''label''': '''remote''', '''box''': {'''xmin''': 40, '''ymin''': 72, '''xmax''': 177, '''ymax''': 115}},
												            {'''score''': 0.2537, '''label''': '''cat''', '''box''': {'''xmin''': 1, '''ymin''': 55, '''xmax''': 315, '''ymax''': 472}},
												            {'''score''': 0.1474, '''label''': '''remote''', '''box''': {'''xmin''': 335, '''ymin''': 74, '''xmax''': 371, '''ymax''': 187}},
												            {'''score''': 0.1208, '''label''': '''couch''', '''box''': {'''xmin''': 4, '''ymin''': 0, '''xmax''': 642, '''ymax''': 476}},
												        ],
												    ] ,			)







							@require_tf
							@unittest.skip('''Zero Shot Object Detection not implemented in TF'''		)
							def  UpperCamelCase_						(   self      :     List[Any]		):
												pass







							@require_torch
							@slow
							def  UpperCamelCase_						(   self      :     List[str]		):
												_UpperCamelCase			     =     0.2
												_UpperCamelCase			     =     pipeline('''zero-shot-object-detection'''		)

												_UpperCamelCase			     =     object_detector(
												    '''http://images.cocodataset.org/val2017/000000039769.jpg''' ,			candidate_labels=['''cat''', '''remote''', '''couch'''] ,			threshold=_A ,			)
												self.assertEqual(
												    nested_simplify(_A ,			decimals=4		) ,			[
												        {'''score''': 0.2868, '''label''': '''cat''', '''box''': {'''xmin''': 324, '''ymin''': 20, '''xmax''': 640, '''ymax''': 373}},
												        {'''score''': 0.277, '''label''': '''remote''', '''box''': {'''xmin''': 40, '''ymin''': 72, '''xmax''': 177, '''ymax''': 115}},
												        {'''score''': 0.2537, '''label''': '''cat''', '''box''': {'''xmin''': 1, '''ymin''': 55, '''xmax''': 315, '''ymax''': 472}},
												    ] ,			)







							@require_torch
							@slow
							def  UpperCamelCase_						(   self      :     Any		):
												_UpperCamelCase			     =     2
												_UpperCamelCase			     =     pipeline('''zero-shot-object-detection'''		)

												_UpperCamelCase			     =     object_detector(
												    '''http://images.cocodataset.org/val2017/000000039769.jpg''' ,			candidate_labels=['''cat''', '''remote''', '''couch'''] ,			top_k=_A ,			)
												self.assertEqual(
												    nested_simplify(_A ,			decimals=4		) ,			[
												        {'''score''': 0.2868, '''label''': '''cat''', '''box''': {'''xmin''': 324, '''ymin''': 20, '''xmax''': 640, '''ymax''': 373}},
												        {'''score''': 0.277, '''label''': '''remote''', '''box''': {'''xmin''': 40, '''ymin''': 72, '''xmax''': 177, '''ymax''': 115}},
												    ] ,			)

from __future__ import annotations

import unittest

import numpy as np

from transformers import BlipTextConfig
from transformers.testing_utils import require_tf, slow
from transformers.utils import is_tf_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask


if is_tf_available():
					import tensorflow as tf

					from transformers import TFBlipTextModel
					from transformers.models.blip.modeling_tf_blip import TF_BLIP_PRETRAINED_MODEL_ARCHIVE_LIST
class     lowerCAmelCase_     :







							def __init__(   self      :     Any ,			_A      :     int ,			_A      :     int=12 ,			_A      :     int=7 ,			_A      :     Tuple=True ,			_A      :     Optional[int]=True ,			_A      :     Union[str, Any]=True ,			_A      :     str=99 ,			_A      :     str=32 ,			_A      :     int=32 ,			_A      :     Optional[Any]=2 ,			_A      :     Dict=4 ,			_A      :     int=37 ,			_A      :     List[Any]=0.1 ,			_A      :     str=0.1 ,			_A      :     Any=512 ,			_A      :     int=0.02 ,			_A      :     Optional[Any]=0 ,			_A      :     Dict=None ,			):
												_UpperCamelCase			     =     parent
												_UpperCamelCase			     =     batch_size
												_UpperCamelCase			     =     seq_length
												_UpperCamelCase			     =     is_training
												_UpperCamelCase			     =     use_input_mask
												_UpperCamelCase			     =     use_labels
												_UpperCamelCase			     =     vocab_size
												_UpperCamelCase			     =     hidden_size
												_UpperCamelCase			     =     projection_dim
												_UpperCamelCase			     =     num_hidden_layers
												_UpperCamelCase			     =     num_attention_heads
												_UpperCamelCase			     =     intermediate_size
												_UpperCamelCase			     =     dropout
												_UpperCamelCase			     =     attention_dropout
												_UpperCamelCase			     =     max_position_embeddings
												_UpperCamelCase			     =     initializer_range
												_UpperCamelCase			     =     scope
												_UpperCamelCase			     =     bos_token_id







							def  UpperCamelCase_						(   self      :     List[str]		):
												_UpperCamelCase			     =     ids_tensor([self.batch_size, self.seq_length] ,			self.vocab_size		)

												_UpperCamelCase			     =     None
												if self.use_input_mask:
																	_UpperCamelCase			     =     random_attention_mask([self.batch_size, self.seq_length]		)

												if input_mask is not None:
																	_UpperCamelCase			     =     input_mask.numpy()
																	_UpperCamelCase     ,    _UpperCamelCase			     =     input_mask.shape
																	_UpperCamelCase			     =     np.random.randint(1 ,			seq_length - 1 ,			size=(batch_size,)		)
																	for batch_idx, start_index in enumerate(_A		):
																						_UpperCamelCase			     =     1
																						_UpperCamelCase			     =     0

												_UpperCamelCase			     =     self.get_config()

												return config, input_ids, tf.convert_to_tensor(_A		)







							def  UpperCamelCase_						(   self      :     str		):
												return BlipTextConfig(
												    vocab_size=self.vocab_size ,			hidden_size=self.hidden_size ,			projection_dim=self.projection_dim ,			num_hidden_layers=self.num_hidden_layers ,			num_attention_heads=self.num_attention_heads ,			intermediate_size=self.intermediate_size ,			dropout=self.dropout ,			attention_dropout=self.attention_dropout ,			max_position_embeddings=self.max_position_embeddings ,			initializer_range=self.initializer_range ,			bos_token_id=self.bos_token_id ,			)







							def  UpperCamelCase_						(   self      :     List[str] ,			_A      :     Tuple ,			_A      :     str ,			_A      :     Optional[Any]		):
												_UpperCamelCase			     =     TFBlipTextModel(config=_A		)
												_UpperCamelCase			     =     model(_A ,			attention_mask=_A ,			training=_A		)
												_UpperCamelCase			     =     model(_A ,			training=_A		)
												self.parent.assertEqual(result.last_hidden_state.shape ,			(self.batch_size, self.seq_length, self.hidden_size)		)
												self.parent.assertEqual(result.pooler_output.shape ,			(self.batch_size, self.hidden_size)		)







							def  UpperCamelCase_						(   self      :     Tuple		):
												_UpperCamelCase			     =     self.prepare_config_and_inputs()
												_UpperCamelCase     ,    _UpperCamelCase     ,    _UpperCamelCase			     =     config_and_inputs
												_UpperCamelCase			     =     {'''input_ids''': input_ids, '''attention_mask''': input_mask}
												return config, inputs_dict




@require_tf
class     lowerCAmelCase_     (       __lowercase,  unittest.TestCase ):
							UpperCAmelCase				   =     (TFBlipTextModel,) if is_tf_available() else ()
							UpperCAmelCase				   =     False
							UpperCAmelCase				   =     False
							UpperCAmelCase				   =     False







							def  UpperCamelCase_						(   self      :     Dict		):
												_UpperCamelCase			     =     BlipTextModelTester(self		)
												_UpperCamelCase			     =     ConfigTester(self ,			config_class=_A ,			hidden_size=37		)







							def  UpperCamelCase_						(   self      :     Dict		):
												self.config_tester.run_common_tests()







							def  UpperCamelCase_						(   self      :     int		):
												_UpperCamelCase			     =     self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_model(*_A		)







							def  UpperCamelCase_						(   self      :     List[Any]		):
												pass







							def  UpperCamelCase_						(   self      :     Tuple		):
												pass







							@unittest.skip(reason='''Blip does not use inputs_embeds'''		)
							def  UpperCamelCase_						(   self      :     Dict		):
												pass







							@unittest.skip(reason='''BlipTextModel has no base class and is not available in MODEL_MAPPING'''		)
							def  UpperCamelCase_						(   self      :     Dict		):
												pass







							@unittest.skip(reason='''BlipTextModel has no base class and is not available in MODEL_MAPPING'''		)
							def  UpperCamelCase_						(   self      :     List[str]		):
												pass







							@slow
							def  UpperCamelCase_						(   self      :     Optional[int]		):
												for model_name in TF_BLIP_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																	_UpperCamelCase			     =     TFBlipTextModel.from_pretrained(_A		)
																	self.assertIsNotNone(_A		)







							def  UpperCamelCase_						(   self      :     int ,			_A      :     Optional[int]=True		):
												super().test_pt_tf_model_equivalence(allow_missing_keys=_A		)
