



"""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     lowerCAmelCase__						:


								'''simple docstring'''







								@staticmethod
								def 			_lowerCAmelCase     (      *_SCREAMING_SNAKE_CASE				:       List[Any]     ,       **_SCREAMING_SNAKE_CASE				:       Tuple    )						->	List[Any]:





												"""simple docstring"""


												pass
@is_pipeline_test
@require_vision
@require_torch
class     lowerCAmelCase__						(	unittest.TestCase ):


	'''simple docstring'''







	_SCREAMING_SNAKE_CASE	:		Dict  						= MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING





	def 			_lowerCAmelCase     (      self				:       str     ,       _SCREAMING_SNAKE_CASE				:       str     ,       _SCREAMING_SNAKE_CASE				:       Dict     ,       _SCREAMING_SNAKE_CASE				:       Tuple    )						->	List[Any]:





					"""simple docstring"""


					SCREAMING_SNAKE_CASE						:							List[str]							=     pipeline(
					    'zero-shot-object-detection'     ,       model='hf-internal-testing/tiny-random-owlvit-object-detection'    )

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





	def 			_lowerCAmelCase     (      self				:       List[Any]     ,       _SCREAMING_SNAKE_CASE				:       List[Any]     ,       _SCREAMING_SNAKE_CASE				:       Union[str, Any]    )						->	Optional[Any]:





					"""simple docstring"""


					SCREAMING_SNAKE_CASE						:							Tuple							=     object_detector(examples[0]     ,       threshold=0.0    )

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





	@require_tf
	@unittest.skip('Zero Shot Object Detection not implemented in TF'    )
	def 			_lowerCAmelCase     (      self				:       List[Any]    )						->	Union[str, Any]:





					"""simple docstring"""


					pass





	@require_torch
	def 			_lowerCAmelCase     (      self				:       List[str]    )						->	int:





					"""simple docstring"""


					SCREAMING_SNAKE_CASE						:							List[str]							=     pipeline(
					    'zero-shot-object-detection'     ,       model='hf-internal-testing/tiny-random-owlvit-object-detection'    )

					SCREAMING_SNAKE_CASE						:							List[str]							=     object_detector(
					    './tests/fixtures/tests_samples/COCO/000000039769.png'     ,       candidate_labels=['cat', 'remote', 'couch']     ,       threshold=0.6_4     ,       )

					self.assertEqual(
					    nested_simplify(_SCREAMING_SNAKE_CASE     ,       decimals=4    )     ,       [
					        {'score': 0.7_2_3_5, 'label': 'cat', 'box': {'xmin': 204, 'ymin': 167, 'xmax': 232, 'ymax': 190}},
					        {'score': 0.7_2_1_8, 'label': 'remote', 'box': {'xmin': 204, 'ymin': 167, 'xmax': 232, 'ymax': 190}},
					        {'score': 0.7_1_8_4, 'label': 'couch', 'box': {'xmin': 204, 'ymin': 167, 'xmax': 232, 'ymax': 190}},
					        {'score': 0.6_7_4_8, 'label': 'remote', 'box': {'xmin': 571, 'ymin': 83, 'xmax': 598, 'ymax': 103}},
					        {'score': 0.6_6_5_6, 'label': 'cat', 'box': {'xmin': 571, 'ymin': 83, 'xmax': 598, 'ymax': 103}},
					        {'score': 0.6_6_1_4, 'label': 'couch', 'box': {'xmin': 571, 'ymin': 83, 'xmax': 598, 'ymax': 103}},
					        {'score': 0.6_4_5_6, 'label': 'remote', 'box': {'xmin': 494, 'ymin': 105, 'xmax': 521, 'ymax': 127}},
					        {'score': 0.6_4_2, 'label': 'remote', 'box': {'xmin': 67, 'ymin': 274, 'xmax': 93, 'ymax': 297}},
					        {'score': 0.6_4_1_9, 'label': 'cat', 'box': {'xmin': 494, 'ymin': 105, 'xmax': 521, 'ymax': 127}},
					    ]     ,       )

					SCREAMING_SNAKE_CASE						:							Optional[Any]							=     object_detector(
					    [
					        {
					            'image': './tests/fixtures/tests_samples/COCO/000000039769.png',
					            'candidate_labels': ['cat', 'remote', 'couch'],
					        }
					    ]     ,       threshold=0.6_4     ,       )

					self.assertEqual(
					    nested_simplify(_SCREAMING_SNAKE_CASE     ,       decimals=4    )     ,       [
					        [
					            {'score': 0.7_2_3_5, 'label': 'cat', 'box': {'xmin': 204, 'ymin': 167, 'xmax': 232, 'ymax': 190}},
					            {'score': 0.7_2_1_8, 'label': 'remote', 'box': {'xmin': 204, 'ymin': 167, 'xmax': 232, 'ymax': 190}},
					            {'score': 0.7_1_8_4, 'label': 'couch', 'box': {'xmin': 204, 'ymin': 167, 'xmax': 232, 'ymax': 190}},
					            {'score': 0.6_7_4_8, 'label': 'remote', 'box': {'xmin': 571, 'ymin': 83, 'xmax': 598, 'ymax': 103}},
					            {'score': 0.6_6_5_6, 'label': 'cat', 'box': {'xmin': 571, 'ymin': 83, 'xmax': 598, 'ymax': 103}},
					            {'score': 0.6_6_1_4, 'label': 'couch', 'box': {'xmin': 571, 'ymin': 83, 'xmax': 598, 'ymax': 103}},
					            {'score': 0.6_4_5_6, 'label': 'remote', 'box': {'xmin': 494, 'ymin': 105, 'xmax': 521, 'ymax': 127}},
					            {'score': 0.6_4_2, 'label': 'remote', 'box': {'xmin': 67, 'ymin': 274, 'xmax': 93, 'ymax': 297}},
					            {'score': 0.6_4_1_9, 'label': 'cat', 'box': {'xmin': 494, 'ymin': 105, 'xmax': 521, 'ymax': 127}},
					        ]
					    ]     ,       )





	@require_torch
	@slow
	def 			_lowerCAmelCase     (      self				:       Tuple    )						->	List[str]:





					"""simple docstring"""


					SCREAMING_SNAKE_CASE						:							List[str]							=     pipeline('zero-shot-object-detection'    )

					SCREAMING_SNAKE_CASE						:							List[str]							=     object_detector(
					    'http://images.cocodataset.org/val2017/000000039769.jpg'     ,       candidate_labels=['cat', 'remote', 'couch']     ,       )
					self.assertEqual(
					    nested_simplify(_SCREAMING_SNAKE_CASE     ,       decimals=4    )     ,       [
					        {'score': 0.2_8_6_8, 'label': 'cat', 'box': {'xmin': 324, 'ymin': 20, 'xmax': 640, 'ymax': 373}},
					        {'score': 0.2_7_7, 'label': 'remote', 'box': {'xmin': 40, 'ymin': 72, 'xmax': 177, 'ymax': 115}},
					        {'score': 0.2_5_3_7, 'label': 'cat', 'box': {'xmin': 1, 'ymin': 55, 'xmax': 315, 'ymax': 472}},
					        {'score': 0.1_4_7_4, 'label': 'remote', 'box': {'xmin': 335, 'ymin': 74, 'xmax': 371, 'ymax': 187}},
					        {'score': 0.1_2_0_8, 'label': 'couch', 'box': {'xmin': 4, 'ymin': 0, 'xmax': 642, 'ymax': 476}},
					    ]     ,       )

					SCREAMING_SNAKE_CASE						:							str							=     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(_SCREAMING_SNAKE_CASE     ,       decimals=4    )     ,       [
					        [
					            {'score': 0.2_8_6_8, 'label': 'cat', 'box': {'xmin': 324, 'ymin': 20, 'xmax': 640, 'ymax': 373}},
					            {'score': 0.2_7_7, 'label': 'remote', 'box': {'xmin': 40, 'ymin': 72, 'xmax': 177, 'ymax': 115}},
					            {'score': 0.2_5_3_7, 'label': 'cat', 'box': {'xmin': 1, 'ymin': 55, 'xmax': 315, 'ymax': 472}},
					            {'score': 0.1_4_7_4, 'label': 'remote', 'box': {'xmin': 335, 'ymin': 74, 'xmax': 371, 'ymax': 187}},
					            {'score': 0.1_2_0_8, 'label': 'couch', 'box': {'xmin': 4, 'ymin': 0, 'xmax': 642, 'ymax': 476}},
					        ],
					        [
					            {'score': 0.2_8_6_8, 'label': 'cat', 'box': {'xmin': 324, 'ymin': 20, 'xmax': 640, 'ymax': 373}},
					            {'score': 0.2_7_7, 'label': 'remote', 'box': {'xmin': 40, 'ymin': 72, 'xmax': 177, 'ymax': 115}},
					            {'score': 0.2_5_3_7, 'label': 'cat', 'box': {'xmin': 1, 'ymin': 55, 'xmax': 315, 'ymax': 472}},
					            {'score': 0.1_4_7_4, 'label': 'remote', 'box': {'xmin': 335, 'ymin': 74, 'xmax': 371, 'ymax': 187}},
					            {'score': 0.1_2_0_8, 'label': 'couch', 'box': {'xmin': 4, 'ymin': 0, 'xmax': 642, 'ymax': 476}},
					        ],
					    ]     ,       )





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





					"""simple docstring"""


					pass





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





					"""simple docstring"""


					SCREAMING_SNAKE_CASE						:							Tuple							=     0.2
					SCREAMING_SNAKE_CASE						:							List[Any]							=     pipeline('zero-shot-object-detection'    )

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







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





					"""simple docstring"""


					SCREAMING_SNAKE_CASE						:							int							=     2
					SCREAMING_SNAKE_CASE						:							List[Any]							=     pipeline('zero-shot-object-detection'    )

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










"""simple docstring"""

from typing import TYPE_CHECKING

from ..utils import _LazyModule


A_						:    str				=      {
    '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

							A_						:    Optional[Any]				=      _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)





