



'''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 		_lowercase	(					*_a :      Optional[int]     ,      **_a :      List[Any]  )   ->   List[str]:
       pass






@is_pipeline_test
@require_vision
@require_torch
class    lowerCamelCase_       (							unittest.TestCase	):
  """simple docstring"""




  a_				   =MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING




  def 		_lowercase	(					self :      Dict     ,      _a :      Optional[Any]     ,      _a :      Optional[int]     ,      _a :      Optional[int]  )   ->   List[Any]:
    __lowerCamelCase			:			Optional[int]       			=					pipeline(
        'zero-shot-object-detection'     ,      model='hf-internal-testing/tiny-random-owlvit-object-detection'  )

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




  def 		_lowercase	(					self :      Tuple     ,      _a :      int     ,      _a :      str  )   ->   List[Any]:
    __lowerCamelCase			:			Tuple       			=					object_detector(examples[0]     ,      threshold=0.0  )

    __lowerCamelCase			:			Optional[int]       			=					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 		_lowercase	(					self :      Optional[int]  )   ->   Union[str, Any]:
    pass




  @require_torch
  def 		_lowercase	(					self :      Optional[int]  )   ->   Dict:
    __lowerCamelCase			:			int       			=					pipeline(
        'zero-shot-object-detection'     ,      model='hf-internal-testing/tiny-random-owlvit-object-detection'  )

    __lowerCamelCase			:			int       			=					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.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}},
        ]     ,      )

    __lowerCamelCase			:			Union[str, Any]       			=					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.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 		_lowercase	(					self :      Tuple  )   ->   Optional[Any]:
    __lowerCamelCase			:			List[Any]       			=					pipeline('zero-shot-object-detection'  )

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

    __lowerCamelCase			:			Any       			=					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.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 		_lowercase	(					self :      Any  )   ->   Union[str, Any]:
    pass




  @require_torch
  @slow
  def 		_lowercase	(					self :      Optional[int]  )   ->   Dict:
    __lowerCamelCase			:			Union[str, Any]       			=					0.2
    __lowerCamelCase			:			Optional[int]       			=					pipeline('zero-shot-object-detection'  )

    __lowerCamelCase			:			str       			=					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.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 		_lowercase	(					self :      Union[str, Any]  )   ->   Optional[Any]:
    __lowerCamelCase			:			List[str]       			=					2
    __lowerCamelCase			:			List[Any]       			=					pipeline('zero-shot-object-detection'  )

    __lowerCamelCase			:			List[Any]       			=					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.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}},
        ]     ,      )











'''simple docstring'''





def 			a_	(				_lowerCAmelCase			) -> int:

  if not isinstance(_lowerCAmelCase			,_lowerCAmelCase			):
    raise TypeError('only integers accepted as input'			)
  else:
    __lowerCamelCase			:			Any       			=					str(abs(_lowerCAmelCase			)			)
    __lowerCamelCase			:			Tuple       			=					[list(_lowerCAmelCase			) for char in range(len(_lowerCAmelCase			)			)]
    for index in range(len(_lowerCAmelCase			)			):
      num_transpositions[index].pop(_lowerCAmelCase			)
    return max(
        int(''.join(list(_lowerCAmelCase			)			)			) for transposition in num_transpositions			)


if __name__ == "__main__":
   __import__('doctest').testmod()






