

'''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 					snake_case_			(					*UpperCamelCase__		,				**UpperCamelCase__       )						->      Dict:





                 '''simple docstring'''
                 pass


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



    def 					snake_case_			(					self		,				UpperCamelCase__		,				UpperCamelCase__		,				UpperCamelCase__       )						->      List[Any]:





           '''simple docstring'''
           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 					snake_case_			(					self		,				UpperCamelCase__		,				UpperCamelCase__       )						->      Union[str, Any]:





           '''simple docstring'''
           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 					snake_case_			(					self       )						->      str:





           '''simple docstring'''
           pass



    @require_torch
    def 					snake_case_			(					self       )						->      Any:





           '''simple docstring'''
           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.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}},
               ]		,				)

           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.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 					snake_case_			(					self       )						->      List[str]:





           '''simple docstring'''
           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.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}},
               ]		,				)

           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.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 					snake_case_			(					self       )						->      Optional[int]:





           '''simple docstring'''
           pass



    @require_torch
    @slow
    def 					snake_case_			(					self       )						->      str:





           '''simple docstring'''
           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.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 					snake_case_			(					self       )						->      int:





           '''simple docstring'''
           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.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       UpperCAmelCase__    (      UpperCAmelCase__,       UpperCAmelCase__				)			->			float:
       _validate_point(UpperCAmelCase__				)
       _validate_point(UpperCAmelCase__				)
       if len(UpperCAmelCase__				) != len(UpperCAmelCase__				):
              raise ValueError("""Both points must be in the same n-dimensional space"""				)

       return float(sum(abs(a - b				) for a, b in zip(UpperCAmelCase__,       UpperCAmelCase__				)				)				)
def       UpperCAmelCase__    (      UpperCAmelCase__				)			->			None:
       if point:
              if isinstance(UpperCAmelCase__,       UpperCAmelCase__				):
                     for item in point:
                            if not isinstance(UpperCAmelCase__,       (int, float)				):
                                   A_						=      (
                                       """Expected a list of numbers as input, found """
                                       F'''{type(UpperCAmelCase__				).__name__}'''
                                   )
                                   raise TypeError(UpperCAmelCase__				)
              else:
                     A_						=      F'''Expected a list of numbers as input, found {type(UpperCAmelCase__				).__name__}'''
                     raise TypeError(UpperCAmelCase__				)
       else:
              raise ValueError("""Missing an input"""				)
def       UpperCAmelCase__    (      UpperCAmelCase__,       UpperCAmelCase__				)			->			float:
       _validate_point(UpperCAmelCase__				)
       _validate_point(UpperCAmelCase__				)
       if len(UpperCAmelCase__				) != len(UpperCAmelCase__				):
              raise ValueError("""Both points must be in the same n-dimensional space"""				)

       return float(sum(abs(x - y				) for x, y in zip(UpperCAmelCase__,       UpperCAmelCase__				)				)				)


if __name__ == "__main__":
      import doctest

      doctest.testmod()
