


"""simple docstring"""







from typing import Dict, List, Optional, Union

import numpy as np

from transformers.utils import is_vision_available
from transformers.utils.generic import TensorType

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import (
    center_crop,
    get_resize_output_image_size,
    normalize,
    rescale,
    resize,
    to_channel_dimension_format,
)
from ...image_utils import (
    IMAGENET_STANDARD_MEAN,
    IMAGENET_STANDARD_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    is_valid_image,
    to_numpy_array,
    valid_images,
)
from ...utils import logging


if is_vision_available():
     import PIL

lowerCAmelCase__				    =       logging.get_logger(__name__)
def  a__      (    SCREAMING_SNAKE_CASE   :   Optional[int]    ):


  '''simple docstring'''







  if isinstance(SCREAMING_SNAKE_CASE    ,				(list, tuple)    ) and isinstance(videos[0]    ,				(list, tuple)    ) and is_valid_image(videos[0][0]    ):
    return videos

  elif isinstance(SCREAMING_SNAKE_CASE    ,				(list, tuple)    ) and is_valid_image(videos[0]    ):
    return [videos]

  elif is_valid_image(SCREAMING_SNAKE_CASE    ):
    return [[videos]]

  raise ValueError(f"""Could not make batched video from {videos}"""    )





class 				SCREAMING_SNAKE_CASE__    (		lowercase    ):
       """simple docstring"""


       a  :    Any       =["pixel_values"]

       def __init__(						self		,					snake_case__ = True		,					snake_case__ = None		,					snake_case__ = PILImageResampling.BILINEAR		,					snake_case__ = True		,					snake_case__ = None		,					snake_case__ = True		,					snake_case__ = 1 / 255		,					snake_case__ = True		,					snake_case__ = True		,					snake_case__ = None		,					snake_case__ = None		,					**snake_case__		,					):






         """simple docstring"""





         super().__init__(**snake_case__						)
         lowerCAmelCase					:					Optional[Any]								=							size if size is not None else {"shortest_edge": 256}
         lowerCAmelCase					:					Tuple								=							get_size_dict(snake_case__		,					default_to_square=snake_case__						)
         lowerCAmelCase					:					Any								=							crop_size if crop_size is not None else {"height": 224, "width": 224}
         lowerCAmelCase					:					Optional[Any]								=							get_size_dict(snake_case__		,					param_name="crop_size"						)

         lowerCAmelCase					:					Any								=							do_resize
         lowerCAmelCase					:					int								=							size
         lowerCAmelCase					:					str								=							do_center_crop
         lowerCAmelCase					:					Union[str, Any]								=							crop_size
         lowerCAmelCase					:					Optional[Any]								=							resample
         lowerCAmelCase					:					Optional[Any]								=							do_rescale
         lowerCAmelCase					:					Optional[Any]								=							rescale_factor
         lowerCAmelCase					:					Optional[int]								=							offset
         lowerCAmelCase					:					Tuple								=							do_normalize
         lowerCAmelCase					:					Union[str, Any]								=							image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
         lowerCAmelCase					:					List[Any]								=							image_std if image_std is not None else IMAGENET_STANDARD_STD

       def 	lowercase__							(						self		,					snake_case__		,					snake_case__		,					snake_case__ = PILImageResampling.BILINEAR		,					snake_case__ = None		,					**snake_case__		,					):






         """simple docstring"""





         lowerCAmelCase					:					Tuple								=							get_size_dict(snake_case__		,					default_to_square=snake_case__						)
         if "shortest_edge" in size:
           lowerCAmelCase					:					Optional[int]								=							get_resize_output_image_size(snake_case__		,					size["shortest_edge"]		,					default_to_square=snake_case__						)
         elif "height" in size and "width" in size:
           lowerCAmelCase					:					int								=							(size["height"], size["width"])
         else:
           raise ValueError(f"""Size must have 'height' and 'width' or 'shortest_edge' as keys. Got {size.keys()}"""						)
         return resize(snake_case__		,					size=snake_case__		,					resample=snake_case__		,					data_format=snake_case__		,					**snake_case__						)

       def 	lowercase__							(						self		,					snake_case__		,					snake_case__		,					snake_case__ = None		,					**snake_case__		,					):






         """simple docstring"""





         lowerCAmelCase					:					Optional[Any]								=							get_size_dict(snake_case__						)
         if "height" not in size or "width" not in size:
           raise ValueError(f"""Size must have 'height' and 'width' as keys. Got {size.keys()}"""						)
         return center_crop(snake_case__		,					size=(size["height"], size["width"])		,					data_format=snake_case__		,					**snake_case__						)

       def 	lowercase__							(						self		,					snake_case__		,					snake_case__		,					snake_case__ = True		,					snake_case__ = None		,					**snake_case__		,					):






         """simple docstring"""





         lowerCAmelCase					:					List[str]								=							image.astype(np.floataa						)
         if offset:
           lowerCAmelCase					:					Tuple								=							image - (scale / 2)
         return rescale(snake_case__		,					scale=snake_case__		,					data_format=snake_case__		,					**snake_case__						)

       def 	lowercase__							(						self		,					snake_case__		,					snake_case__		,					snake_case__		,					snake_case__ = None		,					**snake_case__		,					):






         """simple docstring"""





         return normalize(snake_case__		,					mean=snake_case__		,					std=snake_case__		,					data_format=snake_case__		,					**snake_case__						)

       def 	lowercase__							(						self		,					snake_case__		,					snake_case__ = None		,					snake_case__ = None		,					snake_case__ = None		,					snake_case__ = None		,					snake_case__ = None		,					snake_case__ = None		,					snake_case__ = None		,					snake_case__ = None		,					snake_case__ = None		,					snake_case__ = None		,					snake_case__ = None		,					snake_case__ = ChannelDimension.FIRST		,					):






         """simple docstring"""





         if do_resize and size is None or resample is None:
           raise ValueError("Size and resample must be specified if do_resize is True."						)

         if do_center_crop and crop_size is None:
           raise ValueError("Crop size must be specified if do_center_crop is True."						)

         if do_rescale and rescale_factor is None:
           raise ValueError("Rescale factor must be specified if do_rescale is True."						)

         if do_normalize and (image_mean is None or image_std is None):
           raise ValueError("Image mean and std must be specified if do_normalize is True."						)

         if offset and not do_rescale:
           raise ValueError("For offset, do_rescale must also be set to True."						)

         # All transformations expect numpy arrays.
         lowerCAmelCase					:					Tuple								=							to_numpy_array(snake_case__						)

         if do_resize:
           lowerCAmelCase					:					Any								=							self.resize(image=snake_case__		,					size=snake_case__		,					resample=snake_case__						)

         if do_center_crop:
           lowerCAmelCase					:					Union[str, Any]								=							self.center_crop(snake_case__		,					size=snake_case__						)

         if do_rescale:
           lowerCAmelCase					:					List[Any]								=							self.rescale(image=snake_case__		,					scale=snake_case__		,					offset=snake_case__						)

         if do_normalize:
           lowerCAmelCase					:					Tuple								=							self.normalize(image=snake_case__		,					mean=snake_case__		,					std=snake_case__						)

         lowerCAmelCase					:					Any								=							to_channel_dimension_format(snake_case__		,					snake_case__						)
         return image







       def 	lowercase__							(						self		,					snake_case__		,					snake_case__ = None		,					snake_case__ = None		,					snake_case__ = None		,					snake_case__ = None		,					snake_case__ = None		,					snake_case__ = None		,					snake_case__ = None		,					snake_case__ = None		,					snake_case__ = None		,					snake_case__ = None		,					snake_case__ = None		,					snake_case__ = None		,					snake_case__ = ChannelDimension.FIRST		,					**snake_case__		,					):






         """simple docstring"""





         lowerCAmelCase					:					str								=							do_resize if do_resize is not None else self.do_resize
         lowerCAmelCase					:					Union[str, Any]								=							resample if resample is not None else self.resample
         lowerCAmelCase					:					List[str]								=							do_center_crop if do_center_crop is not None else self.do_center_crop
         lowerCAmelCase					:					Dict								=							do_rescale if do_rescale is not None else self.do_rescale
         lowerCAmelCase					:					Optional[int]								=							rescale_factor if rescale_factor is not None else self.rescale_factor
         lowerCAmelCase					:					int								=							offset if offset is not None else self.offset
         lowerCAmelCase					:					Optional[int]								=							do_normalize if do_normalize is not None else self.do_normalize
         lowerCAmelCase					:					int								=							image_mean if image_mean is not None else self.image_mean
         lowerCAmelCase					:					Optional[Any]								=							image_std if image_std is not None else self.image_std

         lowerCAmelCase					:					Optional[int]								=							size if size is not None else self.size
         lowerCAmelCase					:					Optional[Any]								=							get_size_dict(snake_case__		,					default_to_square=snake_case__						)
         lowerCAmelCase					:					Dict								=							crop_size if crop_size is not None else self.crop_size
         lowerCAmelCase					:					List[str]								=							get_size_dict(snake_case__		,					param_name="crop_size"						)

         if not valid_images(snake_case__						):
           raise ValueError(
               "Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, "
               "torch.Tensor, tf.Tensor or jax.ndarray."						)

         lowerCAmelCase					:					List[str]								=							make_batched(snake_case__						)

         lowerCAmelCase					:					Optional[Any]								=							[
             [
                 self._preprocess_image(
                     image=snake_case__		,					do_resize=snake_case__		,					size=snake_case__		,					resample=snake_case__		,					do_center_crop=snake_case__		,					crop_size=snake_case__		,					do_rescale=snake_case__		,					rescale_factor=snake_case__		,					offset=snake_case__		,					do_normalize=snake_case__		,					image_mean=snake_case__		,					image_std=snake_case__		,					data_format=snake_case__		,					)
                 for img in video
             ]
             for video in videos
         ]

         lowerCAmelCase					:					Optional[Any]								=							{"pixel_values": videos}
         return BatchFeature(data=snake_case__		,					tensor_type=snake_case__						)









"""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}},
             ]		,					)





