

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





       @staticmethod
       def 						A  (		*_a      :	Optional[Any]							,					**_a      :	int )	->    Union[str, Any]:





            '''simple docstring'''






            pass







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





  def 						A  (		self      :	Tuple							,					_a      :	Union[str, Any]							,					_a      :	Optional[int]							,					_a      :	int )	->    str:





       '''simple docstring'''






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

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





  def 						A  (		self      :	List[str]							,					_a      :	Any							,					_a      :	Tuple )	->    Tuple:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =object_detector(examples[0]							,					threshold=0.0 )

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





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





       '''simple docstring'''






       pass





  @require_torch
  def 						A  (		self      :	str )	->    List[Any]:





       '''simple docstring'''






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

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

       self.assertEqual(
           nested_simplify(_a							,					decimals=4 )							,					[
               {'score': 0.72_35, 'label': 'cat', 'box': {'xmin': 204, 'ymin': 167, 'xmax': 232, 'ymax': 190}},
               {'score': 0.72_18, 'label': 'remote', 'box': {'xmin': 204, 'ymin': 167, 'xmax': 232, 'ymax': 190}},
               {'score': 0.71_84, 'label': 'couch', 'box': {'xmin': 204, 'ymin': 167, 'xmax': 232, 'ymax': 190}},
               {'score': 0.67_48, 'label': 'remote', 'box': {'xmin': 571, 'ymin': 83, 'xmax': 598, 'ymax': 103}},
               {'score': 0.66_56, 'label': 'cat', 'box': {'xmin': 571, 'ymin': 83, 'xmax': 598, 'ymax': 103}},
               {'score': 0.66_14, 'label': 'couch', 'box': {'xmin': 571, 'ymin': 83, 'xmax': 598, 'ymax': 103}},
               {'score': 0.64_56, 'label': 'remote', 'box': {'xmin': 494, 'ymin': 105, 'xmax': 521, 'ymax': 127}},
               {'score': 0.6_42, 'label': 'remote', 'box': {'xmin': 67, 'ymin': 274, 'xmax': 93, 'ymax': 297}},
               {'score': 0.64_19, 'label': 'cat', 'box': {'xmin': 494, 'ymin': 105, 'xmax': 521, 'ymax': 127}},
           ]							,					)

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

       self.assertEqual(
           nested_simplify(_a							,					decimals=4 )							,					[
               [
                   {'score': 0.72_35, 'label': 'cat', 'box': {'xmin': 204, 'ymin': 167, 'xmax': 232, 'ymax': 190}},
                   {'score': 0.72_18, 'label': 'remote', 'box': {'xmin': 204, 'ymin': 167, 'xmax': 232, 'ymax': 190}},
                   {'score': 0.71_84, 'label': 'couch', 'box': {'xmin': 204, 'ymin': 167, 'xmax': 232, 'ymax': 190}},
                   {'score': 0.67_48, 'label': 'remote', 'box': {'xmin': 571, 'ymin': 83, 'xmax': 598, 'ymax': 103}},
                   {'score': 0.66_56, 'label': 'cat', 'box': {'xmin': 571, 'ymin': 83, 'xmax': 598, 'ymax': 103}},
                   {'score': 0.66_14, 'label': 'couch', 'box': {'xmin': 571, 'ymin': 83, 'xmax': 598, 'ymax': 103}},
                   {'score': 0.64_56, 'label': 'remote', 'box': {'xmin': 494, 'ymin': 105, 'xmax': 521, 'ymax': 127}},
                   {'score': 0.6_42, 'label': 'remote', 'box': {'xmin': 67, 'ymin': 274, 'xmax': 93, 'ymax': 297}},
                   {'score': 0.64_19, 'label': 'cat', 'box': {'xmin': 494, 'ymin': 105, 'xmax': 521, 'ymax': 127}},
               ]
           ]							,					)





  @require_torch
  @slow
  def 						A  (		self      :	Optional[Any] )	->    Optional[Any]:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =pipeline('zero-shot-object-detection' )

       _SCREAMING_SNAKE_CASE							    =object_detector(
           'http://images.cocodataset.org/val2017/000000039769.jpg'							,					candidate_labels=['cat', 'remote', 'couch']							,					)
       self.assertEqual(
           nested_simplify(_a							,					decimals=4 )							,					[
               {'score': 0.28_68, 'label': 'cat', 'box': {'xmin': 324, 'ymin': 20, 'xmax': 640, 'ymax': 373}},
               {'score': 0.2_77, 'label': 'remote', 'box': {'xmin': 40, 'ymin': 72, 'xmax': 177, 'ymax': 115}},
               {'score': 0.25_37, 'label': 'cat', 'box': {'xmin': 1, 'ymin': 55, 'xmax': 315, 'ymax': 472}},
               {'score': 0.14_74, 'label': 'remote', 'box': {'xmin': 335, 'ymin': 74, 'xmax': 371, 'ymax': 187}},
               {'score': 0.12_08, 'label': 'couch', 'box': {'xmin': 4, 'ymin': 0, 'xmax': 642, 'ymax': 476}},
           ]							,					)

       _SCREAMING_SNAKE_CASE							    =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(_a							,					decimals=4 )							,					[
               [
                   {'score': 0.28_68, 'label': 'cat', 'box': {'xmin': 324, 'ymin': 20, 'xmax': 640, 'ymax': 373}},
                   {'score': 0.2_77, 'label': 'remote', 'box': {'xmin': 40, 'ymin': 72, 'xmax': 177, 'ymax': 115}},
                   {'score': 0.25_37, 'label': 'cat', 'box': {'xmin': 1, 'ymin': 55, 'xmax': 315, 'ymax': 472}},
                   {'score': 0.14_74, 'label': 'remote', 'box': {'xmin': 335, 'ymin': 74, 'xmax': 371, 'ymax': 187}},
                   {'score': 0.12_08, 'label': 'couch', 'box': {'xmin': 4, 'ymin': 0, 'xmax': 642, 'ymax': 476}},
               ],
               [
                   {'score': 0.28_68, 'label': 'cat', 'box': {'xmin': 324, 'ymin': 20, 'xmax': 640, 'ymax': 373}},
                   {'score': 0.2_77, 'label': 'remote', 'box': {'xmin': 40, 'ymin': 72, 'xmax': 177, 'ymax': 115}},
                   {'score': 0.25_37, 'label': 'cat', 'box': {'xmin': 1, 'ymin': 55, 'xmax': 315, 'ymax': 472}},
                   {'score': 0.14_74, 'label': 'remote', 'box': {'xmin': 335, 'ymin': 74, 'xmax': 371, 'ymax': 187}},
                   {'score': 0.12_08, 'label': 'couch', 'box': {'xmin': 4, 'ymin': 0, 'xmax': 642, 'ymax': 476}},
               ],
           ]							,					)





  @require_tf
  @unittest.skip('Zero Shot Object Detection not implemented in TF' )
  def 						A  (		self      :	Optional[int] )	->    Optional[Any]:





       '''simple docstring'''






       pass





  @require_torch
  @slow
  def 						A  (		self      :	Union[str, Any] )	->    int:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =0.2
       _SCREAMING_SNAKE_CASE							    =pipeline('zero-shot-object-detection' )

       _SCREAMING_SNAKE_CASE							    =object_detector(
           'http://images.cocodataset.org/val2017/000000039769.jpg'							,					candidate_labels=['cat', 'remote', 'couch']							,					threshold=_a							,					)
       self.assertEqual(
           nested_simplify(_a							,					decimals=4 )							,					[
               {'score': 0.28_68, 'label': 'cat', 'box': {'xmin': 324, 'ymin': 20, 'xmax': 640, 'ymax': 373}},
               {'score': 0.2_77, 'label': 'remote', 'box': {'xmin': 40, 'ymin': 72, 'xmax': 177, 'ymax': 115}},
               {'score': 0.25_37, 'label': 'cat', 'box': {'xmin': 1, 'ymin': 55, 'xmax': 315, 'ymax': 472}},
           ]							,					)





  @require_torch
  @slow
  def 						A  (		self      :	Optional[int] )	->    List[str]:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =2
       _SCREAMING_SNAKE_CASE							    =pipeline('zero-shot-object-detection' )

       _SCREAMING_SNAKE_CASE							    =object_detector(
           'http://images.cocodataset.org/val2017/000000039769.jpg'							,					candidate_labels=['cat', 'remote', 'couch']							,					top_k=_a							,					)
       self.assertEqual(
           nested_simplify(_a							,					decimals=4 )							,					[
               {'score': 0.28_68, 'label': 'cat', 'box': {'xmin': 324, 'ymin': 20, 'xmax': 640, 'ymax': 373}},
               {'score': 0.2_77, 'label': 'remote', 'box': {'xmin': 40, 'ymin': 72, 'xmax': 177, 'ymax': 115}},
           ]							,					)




from typing import TYPE_CHECKING

from ..utils import _LazyModule


UpperCAmelCase__   	=							{
    '''config''': [
        '''EXTERNAL_DATA_FORMAT_SIZE_LIMIT''',
        '''OnnxConfig''',
        '''OnnxConfigWithPast''',
        '''OnnxSeq2SeqConfigWithPast''',
        '''PatchingSpec''',
    ],
    '''convert''': ['''export''', '''validate_model_outputs'''],
    '''features''': ['''FeaturesManager'''],
    '''utils''': ['''ParameterFormat''', '''compute_serialized_parameters_size'''],
}


if TYPE_CHECKING:
  from .config import (
      EXTERNAL_DATA_FORMAT_SIZE_LIMIT,
      OnnxConfig,
      OnnxConfigWithPast,
      OnnxSeqaSeqConfigWithPast,
      PatchingSpec,
  )
  from .convert import export, validate_model_outputs
  from .features import FeaturesManager
  from .utils import ParameterFormat, compute_serialized_parameters_size

else:
  import sys

  UpperCAmelCase__   	=							_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)

