"""simple docstring"""







from __future__ import annotations

import os
import tempfile
import unittest

import numpy as np
from huggingface_hub import hf_hub_download

from transformers import is_tensorflow_text_available, is_tf_available
from transformers.testing_utils import require_tensorflow_text, require_tf, slow

from ..test_modeling_tf_common import floats_tensor
from .test_framework_agnostic import GenerationIntegrationTestsMixin


if is_tf_available():
       import tensorflow as tf

       from transformers import (
           AutoTokenizer,
           TFAutoModelForCausalLM,
           TFAutoModelForSeqaSeqLM,
           TFAutoModelForSpeechSeqaSeq,
           TFAutoModelForVisionaSeq,
           TFBartForConditionalGeneration,
           TFLogitsProcessorList,
           TFMinLengthLogitsProcessor,
           tf_top_k_top_p_filtering,
       )

if is_tensorflow_text_available():
       import tensorflow_text as text







@require_tf
class        UpperCamelCase		(			unittest.TestCase  ):
   def 			_UpperCAmelCase   (			self			)	->      List[str]:


        '''simple docstring'''


        lowercase_	:				List[str]													=	tf.convert_to_tensor(
            [
                [
                    8.222_0991,  # 3rd highest value; idx. 0
                    -0.562_0044,
                    5.2322_9752,
                    4.038_6393,
                    -6.879_8378,
                    -0.5478_5802,
                    -3.201_2153,
                    2.9277_7176,
                    1.8817_1953,
                    7.3534_1276,  # 5th highest value; idx. 9
                    8.4320_7833,  # 2nd highest value; idx. 10
                    -9.8571_1836,
                    -5.9620_9236,
                    -1.1303_9161,
                    -7.111_5294,
                    -0.836_9633,
                    -5.318_6408,
                    7.0642_7407,
                    0.8136_9344,
                    -0.8202_3817,
                    -5.917_9796,
                    0.5881_3443,
                    -6.9977_8438,
                    4.7155_1189,
                    -0.1877_1637,
                    7.4402_0759,  # 4th highest value; idx. 25
                    9.3845_0987,  # 1st highest value; idx. 26
                    2.1266_2941,
                    -9.3256_2038,
                    2.3565_2522,
                ],  # cummulative prob of 5 highest values <= 0.6
                [
                    0.5842_5518,
                    4.5313_9238,
                    -5.5751_0464,
                    -6.2803_0699,
                    -7.1952_9503,
                    -4.0212_2551,
                    1.3933_7037,
                    -6.0670_7057,
                    1.5948_0517,
                    -9.64_3119,
                    0.0390_7799,
                    0.6723_1762,
                    -8.8820_6726,
                    6.2711_5922,  # 4th highest value; idx. 13
                    2.2852_0723,
                    4.8276_7506,
                    4.3042_1368,
                    8.827_5313,  # 2nd highest value; idx. 17
                    5.4402_9958,  # 5th highest value; idx. 18
                    -4.473_5794,
                    7.3857_9536,  # 3rd highest value; idx. 20
                    -2.9105_1663,
                    2.6194_6077,
                    -2.567_4762,
                    -9.4895_9302,
                    -4.0292_2645,
                    -1.3541_6918,
                    9.6770_2323,  # 1st highest value; idx. 27
                    -5.8947_8553,
                    1.8537_0467,
                ],  # cummulative prob of 5 highest values <= 0.6
            ]     ,dtype=tf.floataa     ,)

        lowercase_	:				Any													=	tf.convert_to_tensor(
            [[0, 0], [0, 9], [0, 10], [0, 25], [0, 26], [1, 13], [1, 17], [1, 18], [1, 20], [1, 27]]     ,dtype=tf.intaa     ,)  # expected non filtered idx as noted above

        lowercase_	:				Any													=	tf.convert_to_tensor(
            [8.22_2099, 7.353_4126, 8.43_2078, 7.440_2075, 9.3_8451, 6.27_1159, 8.82_7531, 5.440_2995, 7.385_7956, 9.67_7023]     ,dtype=tf.floataa     ,)  # expected non filtered values as noted above

        lowercase_	:				List[str]													=	tf_top_k_top_p_filtering(__UpperCamelCase     ,top_k=10     ,top_p=0.6     ,min_tokens_to_keep=4			)

        lowercase_	:				Union[str, Any]													=	output[output != -float('inf'			)]
        lowercase_	:				Optional[Any]													=	tf.cast(
            tf.where(tf.not_equal(__UpperCamelCase     ,tf.constant(-float('inf'			)     ,dtype=tf.floataa			)			)			)     ,dtype=tf.intaa     ,)

        tf.debugging.assert_near(__UpperCamelCase     ,__UpperCamelCase     ,rtol=1e-12			)
        tf.debugging.assert_equal(__UpperCamelCase     ,__UpperCamelCase			)







@require_tf
class        UpperCamelCase		(			unittest.TestCase						,      lowercase_  ):
   # setting framework_dependent_parameters needs to be gated, just like its contents' imports
   if is_tf_available():
      lowercase							=  {
          'AutoModelForCausalLM': TFAutoModelForCausalLM,
          'AutoModelForSpeechSeq2Seq': TFAutoModelForSpeechSeqaSeq,
          'AutoModelForSeq2SeqLM': TFAutoModelForSeqaSeqLM,
          'AutoModelForVision2Seq': TFAutoModelForVisionaSeq,
          'LogitsProcessorList': TFLogitsProcessorList,
          'MinLengthLogitsProcessor': TFMinLengthLogitsProcessor,
          'create_tensor_fn': tf.convert_to_tensor,
          'floats_tensor': floats_tensor,
          'return_tensors': 'tf',
      }
   @slow
   def 			_UpperCAmelCase   (			self			)	->      List[str]:


        '''simple docstring'''


        lowercase_	:				Any													=	TFAutoModelForCausalLM.from_pretrained('hf-internal-testing/tiny-random-gpt2'			)
        lowercase_	:				List[Any]													=	2
        lowercase_	:				int													=	2







        class        UpperCamelCase		(			tf.Module  ):
           def __init__(			self     ,__UpperCamelCase			)	->      int:


                '''simple docstring'''


                super(__UpperCamelCase     ,self			).__init__()
                lowercase_	:				List[str]													=	model







           @tf.function(
               input_signature=(
                   tf.TensorSpec((None, input_length)     ,tf.intaa     ,name='input_ids'			),
                   tf.TensorSpec((None, input_length)     ,tf.intaa     ,name='attention_mask'			),
               )     ,jit_compile=__UpperCamelCase     ,)
           def 			_UpperCAmelCase   (			self     ,__UpperCamelCase     ,__UpperCamelCase			)	->      Optional[Any]:


                '''simple docstring'''


                lowercase_	:				Optional[int]													=	self.model.generate(
                    input_ids=__UpperCamelCase     ,attention_mask=__UpperCamelCase     ,max_new_tokens=__UpperCamelCase     ,return_dict_in_generate=__UpperCamelCase     ,)
                return {"sequences": outputs["sequences"]}






        lowercase_	:				Optional[int]													=	[[2, 0], [102, 103]]
        lowercase_	:				str													=	[[1, 0], [1, 1]]
        lowercase_	:				Optional[int]													=	DummyModel(model=__UpperCamelCase			)
        with tempfile.TemporaryDirectory() as tmp_dir:
             tf.saved_model.save(__UpperCamelCase     ,__UpperCamelCase     ,signatures={'serving_default': dummy_model.serving}			)
             lowercase_	:				Any													=	tf.saved_model.load(__UpperCamelCase			).signatures['serving_default']
             for batch_size in range(1     ,len(__UpperCamelCase			) + 1			):
                  lowercase_	:				Any													=	{
                      'input_ids': tf.constant(dummy_input_ids[:batch_size]			),
                      'attention_mask': tf.constant(dummy_attention_masks[:batch_size]			),
                  }
                  lowercase_	:				Optional[Any]													=	serving_func(**__UpperCamelCase			)['sequences']
                  lowercase_	:				List[str]													=	test_model.generate(**__UpperCamelCase     ,max_new_tokens=__UpperCamelCase			)
                  tf.debugging.assert_equal(__UpperCamelCase     ,__UpperCamelCase			)
   @slow
   def 			_UpperCAmelCase   (			self			)	->      Dict:


        '''simple docstring'''


        lowercase_	:				Union[str, Any]													=	TFAutoModelForCausalLM.from_pretrained('hf-internal-testing/tiny-random-gpt2'			)
        lowercase_	:				Union[str, Any]													=	1
        lowercase_	:				Optional[Any]													=	2







        class        UpperCamelCase		(			tf.Module  ):
           def __init__(			self     ,__UpperCamelCase			)	->      List[str]:


                '''simple docstring'''


                super(__UpperCamelCase     ,self			).__init__()
                lowercase_	:				int													=	model







           @tf.function(
               input_signature=(
                   tf.TensorSpec((batch_size, None)     ,tf.intaa     ,name='input_ids'			),
                   tf.TensorSpec((batch_size, None)     ,tf.intaa     ,name='attention_mask'			),
               )     ,jit_compile=__UpperCamelCase     ,)
           def 			_UpperCAmelCase   (			self     ,__UpperCamelCase     ,__UpperCamelCase			)	->      Tuple:


                '''simple docstring'''


                lowercase_	:				List[str]													=	self.model.generate(
                    input_ids=__UpperCamelCase     ,attention_mask=__UpperCamelCase     ,max_new_tokens=__UpperCamelCase     ,return_dict_in_generate=__UpperCamelCase     ,)
                return {"sequences": outputs["sequences"]}






        lowercase_	:				Any													=	[[2], [102, 103]]
        lowercase_	:				Dict													=	[[1], [1, 1]]
        lowercase_	:				List[Any]													=	DummyModel(model=__UpperCamelCase			)
        with tempfile.TemporaryDirectory() as tmp_dir:
             tf.saved_model.save(__UpperCamelCase     ,__UpperCamelCase     ,signatures={'serving_default': dummy_model.serving}			)
             lowercase_	:				List[str]													=	tf.saved_model.load(__UpperCamelCase			).signatures['serving_default']
             for input_row in range(len(__UpperCamelCase			)			):
                  lowercase_	:				Optional[Any]													=	{
                      'input_ids': tf.constant([dummy_input_ids[input_row]]			),
                      'attention_mask': tf.constant([dummy_attention_masks[input_row]]			),
                  }
                  lowercase_	:				Union[str, Any]													=	serving_func(**__UpperCamelCase			)['sequences']
                  lowercase_	:				int													=	test_model.generate(**__UpperCamelCase     ,max_new_tokens=__UpperCamelCase			)
                  tf.debugging.assert_equal(__UpperCamelCase     ,__UpperCamelCase			)
   @slow
   @require_tensorflow_text
   def 			_UpperCAmelCase   (			self			)	->      Optional[Any]:


        '''simple docstring'''


        with tempfile.TemporaryDirectory() as tmp_dir:
             # file needed to load the TF tokenizer
             hf_hub_download(repo_id='google/flan-t5-small'     ,filename='spiece.model'     ,local_dir=__UpperCamelCase			)







             class        UpperCamelCase		(			tf.keras.layers.Layer  ):
                def __init__(			self			)	->      Union[str, Any]:


                     '''simple docstring'''


                     super().__init__()
                     lowercase_	:				int													=	text.SentencepieceTokenizer(
                         model=tf.io.gfile.GFile(os.path.join(__UpperCamelCase     ,'spiece.model'			)     ,'rb'			).read()			)
                     lowercase_	:				Union[str, Any]													=	TFAutoModelForSeqaSeqLM.from_pretrained('hf-internal-testing/tiny-random-t5'			)







                def 			_UpperCAmelCase   (			self     ,__UpperCamelCase     ,*__UpperCamelCase     ,**__UpperCamelCase			)	->      Any:


                     '''simple docstring'''


                     lowercase_	:				str													=	self.tokenizer.tokenize(__UpperCamelCase			)
                     lowercase_							,  lowercase_	:				Any													=	text.pad_model_inputs(
                         __UpperCamelCase     ,max_seq_length=64     ,pad_value=self.model.config.pad_token_id			)
                     lowercase_	:				Union[str, Any]													=	self.model.generate(input_ids=__UpperCamelCase     ,attention_mask=__UpperCamelCase			)
                     return self.tokenizer.detokenize(__UpperCamelCase			)






             lowercase_	:				Any													=	CompleteSentenceTransformer()
             lowercase_	:				Dict													=	tf.keras.layers.Input(shape=(1,)     ,dtype=tf.string     ,name='inputs'			)
             lowercase_	:				Tuple													=	complete_model(__UpperCamelCase			)
             lowercase_	:				int													=	tf.keras.Model(__UpperCamelCase     ,__UpperCamelCase			)
             keras_model.save(__UpperCamelCase			)
   def 			_UpperCAmelCase   (			self			)	->      str:


        '''simple docstring'''


        lowercase_	:				Dict													=	{
            'do_sample': True,
            'num_beams': 1,
            'top_p': 0.7,
            'top_k': 10,
            'temperature': 0.7,
        }
        lowercase_	:				int													=	14

        lowercase_	:				List[Any]													=	AutoTokenizer.from_pretrained('hf-internal-testing/tiny-random-gpt2'			)
        lowercase_	:				str													=	'Hello, my dog is cute and'
        lowercase_	:				Any													=	tokenizer(__UpperCamelCase     ,return_tensors='tf'			)
        lowercase_	:				List[str]													=	TFAutoModelForCausalLM.from_pretrained('hf-internal-testing/tiny-random-gpt2'			)

        lowercase_	:				Any													=	638
        # forces the generation to happen on CPU, to avoid GPU-related quirks
        with tf.device(':/CPU:0'			):
             tf.random.set_seed(0			)
             lowercase_	:				Tuple													=	model.generate(**__UpperCamelCase     ,eos_token_id=__UpperCamelCase     ,**__UpperCamelCase			)
        self.assertTrue(expectation == len(generated_tokens[0]			)			)

        lowercase_	:				List[Any]													=	[638, 198]
        with tf.device(':/CPU:0'			):
             tf.random.set_seed(0			)
             lowercase_	:				Union[str, Any]													=	model.generate(**__UpperCamelCase     ,eos_token_id=__UpperCamelCase     ,**__UpperCamelCase			)
        self.assertTrue(expectation == len(generated_tokens[0]			)			)







   def 			_UpperCAmelCase   (			self			)	->      List[str]:


        '''simple docstring'''


        lowercase_	:				int													=	AutoTokenizer.from_pretrained('hf-internal-testing/tiny-random-bart'			)
        lowercase_	:				List[str]													=	'Hugging Face is a technology company based in New York and Paris.'
        lowercase_	:				Dict													=	bart_tokenizer(__UpperCamelCase     ,return_tensors='tf'			).input_ids
        lowercase_	:				Optional[int]													=	TFBartForConditionalGeneration.from_pretrained('hf-internal-testing/tiny-random-bart'			)
        lowercase_	:				Optional[Any]													=	bart_model.generate(__UpperCamelCase			).numpy()







        class        UpperCamelCase		(			lowercase_  ):
           def 			_UpperCAmelCase   (			self     ,__UpperCamelCase     ,__UpperCamelCase=None     ,**__UpperCamelCase			)	->      Optional[Any]:


                '''simple docstring'''


                return super().call(__UpperCamelCase     ,**__UpperCamelCase			)






        lowercase_	:				int													=	FakeBart.from_pretrained('hf-internal-testing/tiny-random-bart'			)
        lowercase_	:				Optional[int]													=	bart_model.generate(__UpperCamelCase     ,foo='bar'			).numpy()
        self.assertTrue(np.array_equal(__UpperCamelCase     ,__UpperCamelCase			)			)







        class        UpperCamelCase		(			bart_model.model.encoder.__class__  ):
           def 			_UpperCAmelCase   (			self     ,__UpperCamelCase     ,**__UpperCamelCase			)	->      int:


                '''simple docstring'''


                return super().call(__UpperCamelCase     ,**__UpperCamelCase			)






        lowercase_	:				int													=	FakeEncoder(bart_model.config     ,bart_model.model.shared			)
        lowercase_	:				str													=	fake_encoder

        # Normal generation still works (the output will be different because the encoder weights are different)
        lowercase_	:				Any													=	bart_model.generate(__UpperCamelCase			).numpy()
        with self.assertRaises(__UpperCamelCase			):
             # FakeEncoder.call() accepts **kwargs -> no filtering -> value error due to unexpected input "foo"
             bart_model.generate(__UpperCamelCase     ,foo='bar'			)


"""simple docstring"""







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        UpperCamelCase		:
          @staticmethod
          def 			_UpperCAmelCase   (			*__UpperCamelCase     ,**__UpperCamelCase			)	->      Union[str, Any]:


               '''simple docstring'''


               pass







@is_pipeline_test
@require_vision
@require_torch
class        UpperCamelCase		(			unittest.TestCase  ):
   lowercase							=  MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING
   def 			_UpperCAmelCase   (			self     ,__UpperCamelCase     ,__UpperCamelCase     ,__UpperCamelCase			)	->      Tuple:


        '''simple docstring'''


        lowercase_	:				int													=	pipeline(
            'zero-shot-object-detection'     ,model='hf-internal-testing/tiny-random-owlvit-object-detection'			)

        lowercase_	:				Optional[int]													=	[
            {
                'image': './tests/fixtures/tests_samples/COCO/000000039769.png',
                'candidate_labels': ['cat', 'remote', 'couch'],
            }
        ]
        return object_detector, examples
   def 			_UpperCAmelCase   (			self     ,__UpperCamelCase     ,__UpperCamelCase			)	->      str:


        '''simple docstring'''


        lowercase_	:				Tuple													=	object_detector(examples[0]     ,threshold=0.0			)

        lowercase_	:				Any													=	len(__UpperCamelCase			)
        self.assertGreater(__UpperCamelCase     ,0			)
        self.assertEqual(
            __UpperCamelCase     ,[
                {
                    'score': ANY(__UpperCamelCase			),
                    'label': ANY(__UpperCamelCase			),
                    'box': {'xmin': ANY(__UpperCamelCase			), 'ymin': ANY(__UpperCamelCase			), 'xmax': ANY(__UpperCamelCase			), 'ymax': ANY(__UpperCamelCase			)},
                }
                for i in range(__UpperCamelCase			)
            ]     ,)
   @require_tf
   @unittest.skip('Zero Shot Object Detection not implemented in TF'			)
   def 			_UpperCAmelCase   (			self			)	->      Optional[Any]:


        '''simple docstring'''


        pass
   @require_torch
   def 			_UpperCAmelCase   (			self			)	->      int:


        '''simple docstring'''


        lowercase_	:				List[Any]													=	pipeline(
            'zero-shot-object-detection'     ,model='hf-internal-testing/tiny-random-owlvit-object-detection'			)

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

        self.assertEqual(
            nested_simplify(__UpperCamelCase     ,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}},
            ]     ,)

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

        self.assertEqual(
            nested_simplify(__UpperCamelCase     ,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			)	->      Tuple:


        '''simple docstring'''


        lowercase_	:				Any													=	pipeline('zero-shot-object-detection'			)

        lowercase_	:				List[str]													=	object_detector(
            'http://images.cocodataset.org/val2017/000000039769.jpg'     ,candidate_labels=['cat', 'remote', 'couch']     ,)
        self.assertEqual(
            nested_simplify(__UpperCamelCase     ,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}},
            ]     ,)

        lowercase_	:				Union[str, Any]													=	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(__UpperCamelCase     ,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			)	->      Union[str, Any]:


        '''simple docstring'''


        pass
   @require_torch
   @slow
   def 			_UpperCAmelCase   (			self			)	->      Optional[int]:


        '''simple docstring'''


        lowercase_	:				Union[str, Any]													=	0.2
        lowercase_	:				Any													=	pipeline('zero-shot-object-detection'			)

        lowercase_	:				str													=	object_detector(
            'http://images.cocodataset.org/val2017/000000039769.jpg'     ,candidate_labels=['cat', 'remote', 'couch']     ,threshold=__UpperCamelCase     ,)
        self.assertEqual(
            nested_simplify(__UpperCamelCase     ,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:


        '''simple docstring'''


        lowercase_	:				Tuple													=	2
        lowercase_	:				Optional[Any]													=	pipeline('zero-shot-object-detection'			)

        lowercase_	:				List[Any]													=	object_detector(
            'http://images.cocodataset.org/val2017/000000039769.jpg'     ,candidate_labels=['cat', 'remote', 'couch']     ,top_k=__UpperCamelCase     ,)
        self.assertEqual(
            nested_simplify(__UpperCamelCase     ,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}},
            ]     ,)

