






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       :





		@staticmethod
		def 						_A (		*__lowerCamelCase				:					Tuple ,  **__lowerCamelCase				:					str	):
			pass

@is_pipeline_test
@require_vision
@require_torch
class     _SCREAMING_SNAKE_CASE       (			unittest.TestCase      ):
	snake_case__							:     Any     	=  MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING





	def 						_A (		self				:					List[Any] ,  __lowerCamelCase				:					Tuple ,  __lowerCamelCase				:					Union[str, Any] ,  __lowerCamelCase				:					Tuple	):
		UpperCamelCase     :Any          =	pipeline(
		    """zero-shot-object-detection""" ,  model="""hf-internal-testing/tiny-random-owlvit-object-detection"""	)

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





	def 						_A (		self				:					int ,  __lowerCamelCase				:					Tuple ,  __lowerCamelCase				:					Tuple	):
		UpperCamelCase     :Tuple          =	object_detector(examples[0] ,  threshold=0.0	)

		UpperCamelCase     :Optional[Any]          =	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 						_A (		self				:					Dict	):
		pass





	@require_torch
	def 						_A (		self				:					List[str]	):
		UpperCamelCase     :Tuple          =	pipeline(
		    """zero-shot-object-detection""" ,  model="""hf-internal-testing/tiny-random-owlvit-object-detection"""	)

		UpperCamelCase     :Tuple          =	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.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}},
		    ] ,  )

		UpperCamelCase     :Any          =	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.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 						_A (		self				:					Optional[Any]	):
		UpperCamelCase     :Optional[int]          =	pipeline("""zero-shot-object-detection"""	)

		UpperCamelCase     :Union[str, Any]          =	object_detector(
		    """http://images.cocodataset.org/val2017/000000039769.jpg""" ,  candidate_labels=["""cat""", """remote""", """couch"""] ,  )
		self.assertEqual(
		    nested_simplify(__lowerCamelCase ,  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}},
		    ] ,  )

		UpperCamelCase     :List[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(__lowerCamelCase ,  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 						_A (		self				:					List[Any]	):
		pass





	@require_torch
	@slow
	def 						_A (		self				:					str	):
		UpperCamelCase     :Dict          =	0.2
		UpperCamelCase     :Optional[Any]          =	pipeline("""zero-shot-object-detection"""	)

		UpperCamelCase     :Optional[Any]          =	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.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 						_A (		self				:					Optional[int]	):
		UpperCamelCase     :int          =	2
		UpperCamelCase     :List[str]          =	pipeline("""zero-shot-object-detection"""	)

		UpperCamelCase     :Union[str, Any]          =	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.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}},
		    ] ,  )


from typing import List, Optional, TypeVar

from .arrow_dataset import Dataset, _concatenate_map_style_datasets, _interleave_map_style_datasets
from .dataset_dict import DatasetDict, IterableDatasetDict
from .info import DatasetInfo
from .iterable_dataset import IterableDataset, _concatenate_iterable_datasets, _interleave_iterable_datasets
from .splits import NamedSplit
from .utils import logging
from .utils.py_utils import Literal


__snake_case								=  logging.get_logger(__name__)


__snake_case								=  TypeVar("""DatasetType""", Dataset, IterableDataset)






def 							_lowercase							(     UpperCamelCase_	,	UpperCamelCase_ = None	,	UpperCamelCase_ = None	,	UpperCamelCase_ = None	,	UpperCamelCase_ = None	,	UpperCamelCase_ = "first_exhausted"	,	)		->		DatasetType:
					'''simple docstring'''


					from .arrow_dataset import Dataset
					from .iterable_dataset import IterableDataset

					if not datasets:
										raise ValueError('Unable to interleave an empty list of datasets.'		)
					for i, dataset in enumerate(UpperCamelCase_		):
										if not isinstance(UpperCamelCase_	,	(Dataset, IterableDataset)		):
															if isinstance(UpperCamelCase_	,	(DatasetDict, IterableDatasetDict)		):
																				if not dataset:
																									raise ValueError(
																									    F'Expected a list of Dataset objects or a list of IterableDataset objects, but element at position {i} '
																									    'is an empty dataset dictionary.'		)
																				raise ValueError(
																				    F'Dataset at position {i} has at least one split: {list(UpperCamelCase_		)}\n'
																				    F'Please pick one to interleave with the other datasets, for example: dataset[\'{next(iter(UpperCamelCase_		)		)}\']'		)
															raise ValueError(
															    F'Expected a list of Dataset objects or a list of IterableDataset objects, but element at position {i} is a {type(UpperCamelCase_		).__name__}.'		)
										if i == 0:
															SCREAMING_SNAKE_CASE__						, SCREAMING_SNAKE_CASE__													= (
															    (Dataset, IterableDataset) if isinstance(UpperCamelCase_	,	UpperCamelCase_		) else (IterableDataset, Dataset)
															)
										elif not isinstance(UpperCamelCase_	,	UpperCamelCase_		):
															raise ValueError(
															    F'Unable to interleave a {dataset_type.__name__} (at position 0) with a {other_type.__name__} (at position {i}). Expected a list of Dataset objects or a list of IterableDataset objects.'		)
					if stopping_strategy not in ["first_exhausted", "all_exhausted"]:
										raise ValueError(F'{stopping_strategy} is not supported. Please enter a valid stopping_strategy.'		)
					if dataset_type is Dataset:
										return _interleave_map_style_datasets(
										    UpperCamelCase_	,	UpperCamelCase_	,	UpperCamelCase_	,	info=UpperCamelCase_	,	split=UpperCamelCase_	,	stopping_strategy=UpperCamelCase_		)
					else:
										return _interleave_iterable_datasets(
										    UpperCamelCase_	,	UpperCamelCase_	,	UpperCamelCase_	,	info=UpperCamelCase_	,	split=UpperCamelCase_	,	stopping_strategy=UpperCamelCase_		)






def 							_lowercase							(     UpperCamelCase_	,	UpperCamelCase_ = None	,	UpperCamelCase_ = None	,	UpperCamelCase_ = 0	,	)		->		DatasetType:
					'''simple docstring'''


					if not dsets:
										raise ValueError('Unable to concatenate an empty list of datasets.'		)
					for i, dataset in enumerate(UpperCamelCase_		):
										if not isinstance(UpperCamelCase_	,	(Dataset, IterableDataset)		):
															if isinstance(UpperCamelCase_	,	(DatasetDict, IterableDatasetDict)		):
																				if not dataset:
																									raise ValueError(
																									    F'Expected a list of Dataset objects or a list of IterableDataset objects, but element at position {i} '
																									    'is an empty dataset dictionary.'		)
																				raise ValueError(
																				    F'Dataset at position {i} has at least one split: {list(UpperCamelCase_		)}\n'
																				    F'Please pick one to interleave with the other datasets, for example: dataset[\'{next(iter(UpperCamelCase_		)		)}\']'		)
															raise ValueError(
															    F'Expected a list of Dataset objects or a list of IterableDataset objects, but element at position {i} is a {type(UpperCamelCase_		).__name__}.'		)
										if i == 0:
															SCREAMING_SNAKE_CASE__						, SCREAMING_SNAKE_CASE__													= (
															    (Dataset, IterableDataset) if isinstance(UpperCamelCase_	,	UpperCamelCase_		) else (IterableDataset, Dataset)
															)
										elif not isinstance(UpperCamelCase_	,	UpperCamelCase_		):
															raise ValueError(
															    F'Unable to interleave a {dataset_type.__name__} (at position 0) with a {other_type.__name__} (at position {i}). Expected a list of Dataset objects or a list of IterableDataset objects.'		)
					if dataset_type is Dataset:
										return _concatenate_map_style_datasets(UpperCamelCase_	,	info=UpperCamelCase_	,	split=UpperCamelCase_	,	axis=UpperCamelCase_		)
					else:
										return _concatenate_iterable_datasets(UpperCamelCase_	,	info=UpperCamelCase_	,	split=UpperCamelCase_	,	axis=UpperCamelCase_		)





