

import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
 import torch

if is_vision_available():
 from PIL import Image

 from transformers import LevitImageProcessor






class 						__magic_name__					(							unittest.TestCase				):






     def __init__(				self		,						_lowercase		,						_lowercase=7		,						_lowercase=3		,						_lowercase=18		,						_lowercase=30		,						_lowercase=400		,						_lowercase=True		,						_lowercase=None		,						_lowercase=True		,						_lowercase=None		,						_lowercase=True		,						_lowercase=[0.5, 0.5, 0.5]		,						_lowercase=[0.5, 0.5, 0.5]		,						)->     int:
         UpperCamelCase_			  =						size if size is not None else {"shortest_edge": 18}
         UpperCamelCase_			  =						crop_size if crop_size is not None else {"height": 18, "width": 18}
         UpperCamelCase_			  =						parent
         UpperCamelCase_			  =						batch_size
         UpperCamelCase_			  =						num_channels
         UpperCamelCase_			  =						image_size
         UpperCamelCase_			  =						min_resolution
         UpperCamelCase_			  =						max_resolution
         UpperCamelCase_			  =						do_resize
         UpperCamelCase_			  =						size
         UpperCamelCase_			  =						do_center_crop
         UpperCamelCase_			  =						crop_size
         UpperCamelCase_			  =						do_normalize
         UpperCamelCase_			  =						image_mean
         UpperCamelCase_			  =						image_std






     def 	UpperCAmelCase_				(				self	)->     Union[str, Any]:
         return {
             "image_mean": self.image_mean,
             "image_std": self.image_std,
             "do_normalize": self.do_normalize,
             "do_resize": self.do_resize,
             "do_center_crop": self.do_center_crop,
             "size": self.size,
             "crop_size": self.crop_size,
         }






@require_torch
@require_vision
class 						__magic_name__					(							snake_case			,      unittest.TestCase				):
     UpperCamelCase_	:List[Any]										=      LevitImageProcessor if is_vision_available() else None






     def 	UpperCAmelCase_				(				self	)->     int:
         UpperCamelCase_			  =						LevitImageProcessingTester(self	)






     @property
     def 	UpperCAmelCase_				(				self	)->     Optional[Any]:
         return self.image_processor_tester.prepare_image_processor_dict()






     def 	UpperCAmelCase_				(				self	)->     Optional[Any]:
         UpperCamelCase_			  =						self.image_processing_class(**self.image_processor_dict	)
         self.assertTrue(hasattr(_lowercase		,						"image_mean"	)	)
         self.assertTrue(hasattr(_lowercase		,						"image_std"	)	)
         self.assertTrue(hasattr(_lowercase		,						"do_normalize"	)	)
         self.assertTrue(hasattr(_lowercase		,						"do_resize"	)	)
         self.assertTrue(hasattr(_lowercase		,						"do_center_crop"	)	)
         self.assertTrue(hasattr(_lowercase		,						"size"	)	)






     def 	UpperCAmelCase_				(				self	)->     str:
         UpperCamelCase_			  =						self.image_processing_class.from_dict(self.image_processor_dict	)
         self.assertEqual(image_processor.size		,						{"shortest_edge": 18}	)
         self.assertEqual(image_processor.crop_size		,						{"height": 18, "width": 18}	)

         UpperCamelCase_			  =						self.image_processing_class.from_dict(self.image_processor_dict		,						size=42		,						crop_size=84	)
         self.assertEqual(image_processor.size		,						{"shortest_edge": 42}	)
         self.assertEqual(image_processor.crop_size		,						{"height": 84, "width": 84}	)






     def 	UpperCAmelCase_				(				self	)->     Union[str, Any]:
         pass






     def 	UpperCAmelCase_				(				self	)->     str:
         # Initialize image_processing
         UpperCamelCase_			  =						self.image_processing_class(**self.image_processor_dict	)
         # create random PIL images
         UpperCamelCase_			  =						prepare_image_inputs(self.image_processor_tester		,						equal_resolution=_lowercase	)
         for image in image_inputs:
             self.assertIsInstance(_lowercase		,						Image.Image	)

         # Test not batched input
         UpperCamelCase_			  =						image_processing(image_inputs[0]		,						return_tensors="pt"	).pixel_values
         self.assertEqual(
             encoded_images.shape		,						(
                 1,
                 self.image_processor_tester.num_channels,
                 self.image_processor_tester.crop_size["height"],
                 self.image_processor_tester.crop_size["width"],
             )		,						)

         # Test batched
         UpperCamelCase_			  =						image_processing(_lowercase		,						return_tensors="pt"	).pixel_values
         self.assertEqual(
             encoded_images.shape		,						(
                 self.image_processor_tester.batch_size,
                 self.image_processor_tester.num_channels,
                 self.image_processor_tester.crop_size["height"],
                 self.image_processor_tester.crop_size["width"],
             )		,						)






     def 	UpperCAmelCase_				(				self	)->     List[str]:
         # Initialize image_processing
         UpperCamelCase_			  =						self.image_processing_class(**self.image_processor_dict	)
         # create random numpy tensors
         UpperCamelCase_			  =						prepare_image_inputs(self.image_processor_tester		,						equal_resolution=_lowercase		,						numpify=_lowercase	)
         for image in image_inputs:
             self.assertIsInstance(_lowercase		,						np.ndarray	)

         # Test not batched input
         UpperCamelCase_			  =						image_processing(image_inputs[0]		,						return_tensors="pt"	).pixel_values
         self.assertEqual(
             encoded_images.shape		,						(
                 1,
                 self.image_processor_tester.num_channels,
                 self.image_processor_tester.crop_size["height"],
                 self.image_processor_tester.crop_size["width"],
             )		,						)

         # Test batched
         UpperCamelCase_			  =						image_processing(_lowercase		,						return_tensors="pt"	).pixel_values
         self.assertEqual(
             encoded_images.shape		,						(
                 self.image_processor_tester.batch_size,
                 self.image_processor_tester.num_channels,
                 self.image_processor_tester.crop_size["height"],
                 self.image_processor_tester.crop_size["width"],
             )		,						)






     def 	UpperCAmelCase_				(				self	)->     Optional[Any]:
         # Initialize image_processing
         UpperCamelCase_			  =						self.image_processing_class(**self.image_processor_dict	)
         # create random PyTorch tensors
         UpperCamelCase_			  =						prepare_image_inputs(self.image_processor_tester		,						equal_resolution=_lowercase		,						torchify=_lowercase	)
         for image in image_inputs:
             self.assertIsInstance(_lowercase		,						torch.Tensor	)

         # Test not batched input
         UpperCamelCase_			  =						image_processing(image_inputs[0]		,						return_tensors="pt"	).pixel_values
         self.assertEqual(
             encoded_images.shape		,						(
                 1,
                 self.image_processor_tester.num_channels,
                 self.image_processor_tester.crop_size["height"],
                 self.image_processor_tester.crop_size["width"],
             )		,						)

         # Test batched
         UpperCamelCase_			  =						image_processing(_lowercase		,						return_tensors="pt"	).pixel_values
         self.assertEqual(
             encoded_images.shape		,						(
                 self.image_processor_tester.batch_size,
                 self.image_processor_tester.num_channels,
                 self.image_processor_tester.crop_size["height"],
                 self.image_processor_tester.crop_size["width"],
             )		,						)



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 						__magic_name__					:






      @staticmethod
      def 	UpperCAmelCase_				(				*_lowercase		,						**_lowercase	)->     Optional[int]:
          pass






@is_pipeline_test
@require_vision
@require_torch
class 						__magic_name__					(							unittest.TestCase				):
     UpperCamelCase_	:Optional[Any]										=      MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING






     def 	UpperCAmelCase_				(				self		,						_lowercase		,						_lowercase		,						_lowercase	)->     Union[str, Any]:
         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		,						_lowercase		,						_lowercase	)->     Union[str, Any]:
         UpperCamelCase_			  =						object_detector(examples[0]		,						threshold=0.0	)

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






     @require_tf
     @unittest.skip("Zero Shot Object Detection not implemented in TF"	)
     def 	UpperCAmelCase_				(				self	)->     str:
         pass






     @require_torch
     def 	UpperCAmelCase_				(				self	)->     List[Any]:
         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(_lowercase		,						decimals=4	)		,						[
                 {"score": 0.7_235, "label": "cat", "box": {"xmin": 204, "ymin": 167, "xmax": 232, "ymax": 190}},
                 {"score": 0.7_218, "label": "remote", "box": {"xmin": 204, "ymin": 167, "xmax": 232, "ymax": 190}},
                 {"score": 0.7_184, "label": "couch", "box": {"xmin": 204, "ymin": 167, "xmax": 232, "ymax": 190}},
                 {"score": 0.6_748, "label": "remote", "box": {"xmin": 571, "ymin": 83, "xmax": 598, "ymax": 103}},
                 {"score": 0.6_656, "label": "cat", "box": {"xmin": 571, "ymin": 83, "xmax": 598, "ymax": 103}},
                 {"score": 0.6_614, "label": "couch", "box": {"xmin": 571, "ymin": 83, "xmax": 598, "ymax": 103}},
                 {"score": 0.6_456, "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.6_419, "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(_lowercase		,						decimals=4	)		,						[
                 [
                     {"score": 0.7_235, "label": "cat", "box": {"xmin": 204, "ymin": 167, "xmax": 232, "ymax": 190}},
                     {"score": 0.7_218, "label": "remote", "box": {"xmin": 204, "ymin": 167, "xmax": 232, "ymax": 190}},
                     {"score": 0.7_184, "label": "couch", "box": {"xmin": 204, "ymin": 167, "xmax": 232, "ymax": 190}},
                     {"score": 0.6_748, "label": "remote", "box": {"xmin": 571, "ymin": 83, "xmax": 598, "ymax": 103}},
                     {"score": 0.6_656, "label": "cat", "box": {"xmin": 571, "ymin": 83, "xmax": 598, "ymax": 103}},
                     {"score": 0.6_614, "label": "couch", "box": {"xmin": 571, "ymin": 83, "xmax": 598, "ymax": 103}},
                     {"score": 0.6_456, "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.6_419, "label": "cat", "box": {"xmin": 494, "ymin": 105, "xmax": 521, "ymax": 127}},
                 ]
             ]		,						)






     @require_torch
     @slow
     def 	UpperCAmelCase_				(				self	)->     Any:
         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(_lowercase		,						decimals=4	)		,						[
                 {"score": 0.2_868, "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.2_537, "label": "cat", "box": {"xmin": 1, "ymin": 55, "xmax": 315, "ymax": 472}},
                 {"score": 0.1_474, "label": "remote", "box": {"xmin": 335, "ymin": 74, "xmax": 371, "ymax": 187}},
                 {"score": 0.1_208, "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(_lowercase		,						decimals=4	)		,						[
                 [
                     {"score": 0.2_868, "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.2_537, "label": "cat", "box": {"xmin": 1, "ymin": 55, "xmax": 315, "ymax": 472}},
                     {"score": 0.1_474, "label": "remote", "box": {"xmin": 335, "ymin": 74, "xmax": 371, "ymax": 187}},
                     {"score": 0.1_208, "label": "couch", "box": {"xmin": 4, "ymin": 0, "xmax": 642, "ymax": 476}},
                 ],
                 [
                     {"score": 0.2_868, "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.2_537, "label": "cat", "box": {"xmin": 1, "ymin": 55, "xmax": 315, "ymax": 472}},
                     {"score": 0.1_474, "label": "remote", "box": {"xmin": 335, "ymin": 74, "xmax": 371, "ymax": 187}},
                     {"score": 0.1_208, "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	)->     Optional[int]:
         pass






     @require_torch
     @slow
     def 	UpperCAmelCase_				(				self	)->     Optional[Any]:
         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=_lowercase		,						)
         self.assertEqual(
             nested_simplify(_lowercase		,						decimals=4	)		,						[
                 {"score": 0.2_868, "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.2_537, "label": "cat", "box": {"xmin": 1, "ymin": 55, "xmax": 315, "ymax": 472}},
             ]		,						)






     @require_torch
     @slow
     def 	UpperCAmelCase_				(				self	)->     Optional[int]:
         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=_lowercase		,						)
         self.assertEqual(
             nested_simplify(_lowercase		,						decimals=4	)		,						[
                 {"score": 0.2_868, "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}},
             ]		,						)
