


"""simple docstring"""







import gc
import unittest

import numpy as np
import torch
from torch.backends.cuda import sdp_kernel

from diffusers import (
    CMStochasticIterativeScheduler,
    ConsistencyModelPipeline,
    UNetaDModel,
)
from diffusers.utils import randn_tensor, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_a, require_torch_gpu

from ..pipeline_params import UNCONDITIONAL_IMAGE_GENERATION_BATCH_PARAMS, UNCONDITIONAL_IMAGE_GENERATION_PARAMS
from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()


class 				SCREAMING_SNAKE_CASE__    (		lowercase       ,   unittest.TestCase    ):
       """simple docstring"""


       a  :    List[str]       =ConsistencyModelPipeline
       a  :    Optional[int]       =UNCONDITIONAL_IMAGE_GENERATION_PARAMS
       a  :    Dict       =UNCONDITIONAL_IMAGE_GENERATION_BATCH_PARAMS

       # Override required_optional_params to remove num_images_per_prompt
       a  :    Union[str, Any]       =frozenset(
           [
               "num_inference_steps",
               "generator",
               "latents",
               "output_type",
               "return_dict",
               "callback",
               "callback_steps",
           ]    )

       @property
       def 	lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase					:					str								=							UNetaDModel.from_pretrained(
             "diffusers/consistency-models-test"		,					subfolder="test_unet"		,					)
         return unet

       @property
       def 	lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase					:					List[Any]								=							UNetaDModel.from_pretrained(
             "diffusers/consistency-models-test"		,					subfolder="test_unet_class_cond"		,					)
         return unet

       def 	lowercase__							(						self		,					snake_case__=False						):






         """simple docstring"""





         if class_cond:
           lowerCAmelCase					:					List[str]								=							self.dummy_cond_unet
         else:
           lowerCAmelCase					:					List[Any]								=							self.dummy_uncond_unet

         # Default to CM multistep sampler
         lowerCAmelCase					:					List[str]								=							CMStochasticIterativeScheduler(
             num_train_timesteps=40		,					sigma_min=0.002		,					sigma_max=80.0		,					)

         lowerCAmelCase					:					List[str]								=							{
             "unet": unet,
             "scheduler": scheduler,
         }

         return components

       def 	lowercase__							(						self		,					snake_case__		,					snake_case__=0						):






         """simple docstring"""





         if str(snake_case__						).startswith("mps"						):
           lowerCAmelCase					:					Dict								=							torch.manual_seed(snake_case__						)
         else:
           lowerCAmelCase					:					List[Any]								=							torch.Generator(device=snake_case__						).manual_seed(snake_case__						)

         lowerCAmelCase					:					List[Any]								=							{
             "batch_size": 1,
             "num_inference_steps": None,
             "timesteps": [22, 0],
             "generator": generator,
             "output_type": "np",
         }

         return inputs

       def 	lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase					:					Tuple								=							"cpu"  # ensure determinism for the device-dependent torch.Generator
         lowerCAmelCase					:					Tuple								=							self.get_dummy_components()
         lowerCAmelCase					:					Dict								=							ConsistencyModelPipeline(**snake_case__						)
         lowerCAmelCase					:					Optional[int]								=							pipe.to(snake_case__						)
         pipe.set_progress_bar_config(disable=snake_case__						)

         lowerCAmelCase					:					List[str]								=							self.get_dummy_inputs(snake_case__						)
         lowerCAmelCase					:					Dict								=							pipe(**snake_case__						).images
         assert image.shape == (1, 32, 32, 3)

         lowerCAmelCase					:					List[Any]								=							image[0, -3:, -3:, -1]
         lowerCAmelCase					:					Tuple								=							np.array([0.3572, 0.6273, 0.4031, 0.3961, 0.4321, 0.5730, 0.5266, 0.4780, 0.5004]						)

         assert np.abs(image_slice.flatten() - expected_slice						).max() < 1e-3

       def 	lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase					:					Tuple								=							"cpu"  # ensure determinism for the device-dependent torch.Generator
         lowerCAmelCase					:					Any								=							self.get_dummy_components(class_cond=snake_case__						)
         lowerCAmelCase					:					Any								=							ConsistencyModelPipeline(**snake_case__						)
         lowerCAmelCase					:					Union[str, Any]								=							pipe.to(snake_case__						)
         pipe.set_progress_bar_config(disable=snake_case__						)

         lowerCAmelCase					:					str								=							self.get_dummy_inputs(snake_case__						)
         lowerCAmelCase					:					Optional[int]								=							0
         lowerCAmelCase					:					int								=							pipe(**snake_case__						).images
         assert image.shape == (1, 32, 32, 3)

         lowerCAmelCase					:					List[Any]								=							image[0, -3:, -3:, -1]
         lowerCAmelCase					:					Union[str, Any]								=							np.array([0.3572, 0.6273, 0.4031, 0.3961, 0.4321, 0.5730, 0.5266, 0.4780, 0.5004]						)

         assert np.abs(image_slice.flatten() - expected_slice						).max() < 1e-3

       def 	lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase					:					Tuple								=							"cpu"  # ensure determinism for the device-dependent torch.Generator
         lowerCAmelCase					:					str								=							self.get_dummy_components()
         lowerCAmelCase					:					Union[str, Any]								=							ConsistencyModelPipeline(**snake_case__						)
         lowerCAmelCase					:					Optional[Any]								=							pipe.to(snake_case__						)
         pipe.set_progress_bar_config(disable=snake_case__						)

         lowerCAmelCase					:					List[Any]								=							self.get_dummy_inputs(snake_case__						)
         lowerCAmelCase					:					Dict								=							1
         lowerCAmelCase					:					Dict								=							None
         lowerCAmelCase					:					Union[str, Any]								=							pipe(**snake_case__						).images
         assert image.shape == (1, 32, 32, 3)

         lowerCAmelCase					:					List[str]								=							image[0, -3:, -3:, -1]
         lowerCAmelCase					:					Union[str, Any]								=							np.array([0.5004, 0.5004, 0.4994, 0.5008, 0.4976, 0.5018, 0.4990, 0.4982, 0.4987]						)

         assert np.abs(image_slice.flatten() - expected_slice						).max() < 1e-3







       def 	lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase					:					List[Any]								=							"cpu"  # ensure determinism for the device-dependent torch.Generator
         lowerCAmelCase					:					Union[str, Any]								=							self.get_dummy_components(class_cond=snake_case__						)
         lowerCAmelCase					:					Optional[int]								=							ConsistencyModelPipeline(**snake_case__						)
         lowerCAmelCase					:					int								=							pipe.to(snake_case__						)
         pipe.set_progress_bar_config(disable=snake_case__						)

         lowerCAmelCase					:					Dict								=							self.get_dummy_inputs(snake_case__						)
         lowerCAmelCase					:					List[Any]								=							1
         lowerCAmelCase					:					Dict								=							None
         lowerCAmelCase					:					Union[str, Any]								=							0
         lowerCAmelCase					:					Optional[int]								=							pipe(**snake_case__						).images
         assert image.shape == (1, 32, 32, 3)

         lowerCAmelCase					:					List[str]								=							image[0, -3:, -3:, -1]
         lowerCAmelCase					:					str								=							np.array([0.5004, 0.5004, 0.4994, 0.5008, 0.4976, 0.5018, 0.4990, 0.4982, 0.4987]						)

         assert np.abs(image_slice.flatten() - expected_slice						).max() < 1e-3


@slow
@require_torch_gpu
class 				SCREAMING_SNAKE_CASE__    (		unittest.TestCase    ):
       """simple docstring"""


       def 	lowercase__							(						self						):






         """simple docstring"""





         super().tearDown()
         gc.collect()
         torch.cuda.empty_cache()

       def 	lowercase__							(						self		,					snake_case__=0		,					snake_case__=False		,					snake_case__="cpu"		,					snake_case__=torch.floataa		,					snake_case__=(1, 3, 64, 64)						):






         """simple docstring"""





         lowerCAmelCase					:					Tuple								=							torch.manual_seed(snake_case__						)

         lowerCAmelCase					:					Dict								=							{
             "num_inference_steps": None,
             "timesteps": [22, 0],
             "class_labels": 0,
             "generator": generator,
             "output_type": "np",
         }

         if get_fixed_latents:
           lowerCAmelCase					:					int								=							self.get_fixed_latents(seed=snake_case__		,					device=snake_case__		,					dtype=snake_case__		,					shape=snake_case__						)
           lowerCAmelCase					:					Dict								=							latents

         return inputs

       def 	lowercase__							(						self		,					snake_case__=0		,					snake_case__="cpu"		,					snake_case__=torch.floataa		,					snake_case__=(1, 3, 64, 64)						):






         """simple docstring"""





         if type(snake_case__						) == str:
           lowerCAmelCase					:					Tuple								=							torch.device(snake_case__						)
         lowerCAmelCase					:					Optional[Any]								=							torch.Generator(device=snake_case__						).manual_seed(snake_case__						)
         lowerCAmelCase					:					List[str]								=							randn_tensor(snake_case__		,					generator=snake_case__		,					device=snake_case__		,					dtype=snake_case__						)
         return latents

       def 	lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase					:					Optional[Any]								=							UNetaDModel.from_pretrained("diffusers/consistency_models"		,					subfolder="diffusers_cd_imagenet64_l2"						)
         lowerCAmelCase					:					List[str]								=							CMStochasticIterativeScheduler(
             num_train_timesteps=40		,					sigma_min=0.002		,					sigma_max=80.0		,					)
         lowerCAmelCase					:					Tuple								=							ConsistencyModelPipeline(unet=snake_case__		,					scheduler=snake_case__						)
         pipe.to(torch_device=snake_case__						)
         pipe.set_progress_bar_config(disable=snake_case__						)

         lowerCAmelCase					:					Optional[int]								=							self.get_inputs()
         lowerCAmelCase					:					List[str]								=							pipe(**snake_case__						).images
         assert image.shape == (1, 64, 64, 3)

         lowerCAmelCase					:					Dict								=							image[0, -3:, -3:, -1]

         lowerCAmelCase					:					Optional[int]								=							np.array([0.0888, 0.0881, 0.0666, 0.0479, 0.0292, 0.0195, 0.0201, 0.0163, 0.0254]						)

         assert np.abs(image_slice.flatten() - expected_slice						).max() < 2e-2

       def 	lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase					:					Any								=							UNetaDModel.from_pretrained("diffusers/consistency_models"		,					subfolder="diffusers_cd_imagenet64_l2"						)
         lowerCAmelCase					:					List[str]								=							CMStochasticIterativeScheduler(
             num_train_timesteps=40		,					sigma_min=0.002		,					sigma_max=80.0		,					)
         lowerCAmelCase					:					Union[str, Any]								=							ConsistencyModelPipeline(unet=snake_case__		,					scheduler=snake_case__						)
         pipe.to(torch_device=snake_case__						)
         pipe.set_progress_bar_config(disable=snake_case__						)

         lowerCAmelCase					:					Any								=							self.get_inputs()
         lowerCAmelCase					:					str								=							1
         lowerCAmelCase					:					List[str]								=							None
         lowerCAmelCase					:					Tuple								=							pipe(**snake_case__						).images
         assert image.shape == (1, 64, 64, 3)

         lowerCAmelCase					:					Any								=							image[0, -3:, -3:, -1]

         lowerCAmelCase					:					List[Any]								=							np.array([0.0340, 0.0152, 0.0063, 0.0267, 0.0221, 0.0107, 0.0416, 0.0186, 0.0217]						)

         assert np.abs(image_slice.flatten() - expected_slice						).max() < 2e-2

       @require_torch_a
       def 	lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase					:					str								=							UNetaDModel.from_pretrained("diffusers/consistency_models"		,					subfolder="diffusers_cd_imagenet64_l2"						)
         lowerCAmelCase					:					List[str]								=							CMStochasticIterativeScheduler(
             num_train_timesteps=40		,					sigma_min=0.002		,					sigma_max=80.0		,					)
         lowerCAmelCase					:					int								=							ConsistencyModelPipeline(unet=snake_case__		,					scheduler=snake_case__						)
         pipe.to(torch_device=snake_case__		,					torch_dtype=torch.floataa						)
         pipe.set_progress_bar_config(disable=snake_case__						)

         lowerCAmelCase					:					Optional[int]								=							self.get_inputs(get_fixed_latents=snake_case__		,					device=snake_case__						)
         # Ensure usage of flash attention in torch 2.0
         with sdp_kernel(enable_flash=snake_case__		,					enable_math=snake_case__		,					enable_mem_efficient=snake_case__						):
           lowerCAmelCase					:					Dict								=							pipe(**snake_case__						).images
         assert image.shape == (1, 64, 64, 3)

         lowerCAmelCase					:					List[str]								=							image[0, -3:, -3:, -1]

         lowerCAmelCase					:					int								=							np.array([0.1875, 0.1428, 0.1289, 0.2151, 0.2092, 0.1477, 0.1877, 0.1641, 0.1353]						)

         assert np.abs(image_slice.flatten() - expected_slice						).max() < 1e-3







       @require_torch_a
       def 	lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase					:					List[Any]								=							UNetaDModel.from_pretrained("diffusers/consistency_models"		,					subfolder="diffusers_cd_imagenet64_l2"						)
         lowerCAmelCase					:					Union[str, Any]								=							CMStochasticIterativeScheduler(
             num_train_timesteps=40		,					sigma_min=0.002		,					sigma_max=80.0		,					)
         lowerCAmelCase					:					Dict								=							ConsistencyModelPipeline(unet=snake_case__		,					scheduler=snake_case__						)
         pipe.to(torch_device=snake_case__		,					torch_dtype=torch.floataa						)
         pipe.set_progress_bar_config(disable=snake_case__						)

         lowerCAmelCase					:					Any								=							self.get_inputs(get_fixed_latents=snake_case__		,					device=snake_case__						)
         lowerCAmelCase					:					Tuple								=							1
         lowerCAmelCase					:					Tuple								=							None
         # Ensure usage of flash attention in torch 2.0
         with sdp_kernel(enable_flash=snake_case__		,					enable_math=snake_case__		,					enable_mem_efficient=snake_case__						):
           lowerCAmelCase					:					str								=							pipe(**snake_case__						).images
         assert image.shape == (1, 64, 64, 3)

         lowerCAmelCase					:					Any								=							image[0, -3:, -3:, -1]

         lowerCAmelCase					:					Union[str, Any]								=							np.array([0.1663, 0.1948, 0.2275, 0.1680, 0.1204, 0.1245, 0.1858, 0.1338, 0.2095]						)

         assert np.abs(image_slice.flatten() - expected_slice						).max() < 1e-3









"""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 				SCREAMING_SNAKE_CASE__    :
            """simple docstring"""


            @staticmethod
            def 	lowercase__							(						*snake_case__		,					**snake_case__						):






              """simple docstring"""





              pass


@is_pipeline_test
@require_vision
@require_torch
class 				SCREAMING_SNAKE_CASE__    (		unittest.TestCase    ):
       """simple docstring"""


       a  :    Optional[Any]       =MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING

       def 	lowercase__							(						self		,					snake_case__		,					snake_case__		,					snake_case__						):






         """simple docstring"""





         lowerCAmelCase					:					str								=							pipeline(
             "zero-shot-object-detection"		,					model="hf-internal-testing/tiny-random-owlvit-object-detection"						)

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

       def 	lowercase__							(						self		,					snake_case__		,					snake_case__						):






         """simple docstring"""





         lowerCAmelCase					:					Optional[Any]								=							object_detector(examples[0]		,					threshold=0.0						)

         lowerCAmelCase					:					Dict								=							len(snake_case__						)
         self.assertGreater(snake_case__		,					0						)
         self.assertEqual(
             snake_case__		,					[
                 {
                     "score": ANY(snake_case__						),
                     "label": ANY(snake_case__						),
                     "box": {"xmin": ANY(snake_case__						), "ymin": ANY(snake_case__						), "xmax": ANY(snake_case__						), "ymax": ANY(snake_case__						)},
                 }
                 for i in range(snake_case__						)
             ]		,					)

       @require_tf
       @unittest.skip("Zero Shot Object Detection not implemented in TF"						)
       def 	lowercase__							(						self						):






         """simple docstring"""





         pass

       @require_torch
       def 	lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase					:					str								=							pipeline(
             "zero-shot-object-detection"		,					model="hf-internal-testing/tiny-random-owlvit-object-detection"						)

         lowerCAmelCase					:					Tuple								=							object_detector(
             "./tests/fixtures/tests_samples/COCO/000000039769.png"		,					candidate_labels=["cat", "remote", "couch"]		,					threshold=0.64		,					)

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

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

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






         """simple docstring"""





         lowerCAmelCase					:					Dict								=							pipeline("zero-shot-object-detection"						)

         lowerCAmelCase					:					Dict								=							object_detector(
             "http://images.cocodataset.org/val2017/000000039769.jpg"		,					candidate_labels=["cat", "remote", "couch"]		,					)
         self.assertEqual(
             nested_simplify(snake_case__		,					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}},
             ]		,					)

         lowerCAmelCase					:					Dict								=							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(snake_case__		,					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 	lowercase__							(						self						):






         """simple docstring"""





         pass

       @require_torch
       @slow
       def 	lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase					:					Dict								=							0.2
         lowerCAmelCase					:					List[Any]								=							pipeline("zero-shot-object-detection"						)

         lowerCAmelCase					:					Union[str, Any]								=							object_detector(
             "http://images.cocodataset.org/val2017/000000039769.jpg"		,					candidate_labels=["cat", "remote", "couch"]		,					threshold=snake_case__		,					)
         self.assertEqual(
             nested_simplify(snake_case__		,					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 	lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase					:					int								=							2
         lowerCAmelCase					:					Any								=							pipeline("zero-shot-object-detection"						)

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





