




'''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  __lowercase    :







     @staticmethod
     def 		UpperCamelCase__      (						*UpperCamelCase   ,				**UpperCamelCase   )					->     Optional[int]:
       pass





@is_pipeline_test
@require_vision
@require_torch
class  __lowercase    (	unittest.TestCase			):
   _a    						=   MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING







   def 		UpperCamelCase__      (						self   ,				UpperCamelCase   ,				UpperCamelCase   ,				UpperCamelCase   )					->     Optional[int]:
     __a								=       pipeline(
         'zero-shot-object-detection'   ,				model='hf-internal-testing/tiny-random-owlvit-object-detection'   )

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







   def 		UpperCamelCase__      (						self   ,				UpperCamelCase   ,				UpperCamelCase   )					->     int:
     __a								=       object_detector(examples[0]   ,				threshold=0.0   )

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







   @require_tf
   @unittest.skip('Zero Shot Object Detection not implemented in TF'   )
   def 		UpperCamelCase__      (						self   )					->     Tuple:
     pass







   @require_torch
   def 		UpperCamelCase__      (						self   )					->     List[Any]:
     __a								=       pipeline(
         'zero-shot-object-detection'   ,				model='hf-internal-testing/tiny-random-owlvit-object-detection'   )

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

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

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

     self.assertEqual(
         nested_simplify(lowerCAmelCase__   ,				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   )					->     Optional[Any]:
     __a								=       pipeline('zero-shot-object-detection'   )

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

     __a								=       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(lowerCAmelCase__   ,				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   )					->     Union[str, Any]:
     pass







   @require_torch
   @slow
   def 		UpperCamelCase__      (						self   )					->     Dict:
     __a								=       0.2
     __a								=       pipeline('zero-shot-object-detection'   )

     __a								=       object_detector(
         'http://images.cocodataset.org/val2017/000000039769.jpg'   ,				candidate_labels=['cat', 'remote', 'couch']   ,				threshold=lowerCAmelCase__   ,				)
     self.assertEqual(
         nested_simplify(lowerCAmelCase__   ,				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   )					->     Any:
     __a								=       2
     __a								=       pipeline('zero-shot-object-detection'   )

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







from __future__ import annotations






def 						a__			(				A__,      A__ = None,      A__ = None				):
			if start is None:
						SCREAMING_SNAKE_CASE_		:     List[str]					=					0

			if end is None:
						SCREAMING_SNAKE_CASE_		:     Optional[Any]					=					len(A__				) - 1

			if start >= end:
						return

			SCREAMING_SNAKE_CASE_		:     Tuple					=					(start + end) // 2

			slowsort(A__,      A__,      A__				)
			slowsort(A__,      mid + 1,      A__				)

			if sequence[end] < sequence[mid]:
						SCREAMING_SNAKE_CASE_		,      SCREAMING_SNAKE_CASE_		:     Optional[Any]					=					sequence[mid], sequence[end]

			slowsort(A__,      A__,      end - 1				)


if __name__ == "__main__":
				from doctest import testmod

				testmod()





