
'''simple docstring'''
import unittest

from transformers import (
    MODEL_FOR_OBJECT_DETECTION_MAPPING,
    AutoFeatureExtractor,
    AutoModelForObjectDetection,
    ObjectDetectionPipeline,
    is_vision_available,
    pipeline,
)
from transformers.testing_utils import (
    is_pipeline_test,
    nested_simplify,
    require_pytesseract,
    require_tf,
    require_timm,
    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							(*UpperCAmelCase  ,  **UpperCAmelCase  )					->       int:
                  pass


@is_pipeline_test
@require_vision
@require_timm
@require_torch
class       _lowerCAmelCase   (   unittest.TestCase				):







       '''simple docstring'''

       lowerCAmelCase_ 						=						MODEL_FOR_OBJECT_DETECTION_MAPPING

       def 	lowercase							(self  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  )					->       Optional[Any]:
              _snake_case       =  ObjectDetectionPipeline(model=_a  ,  image_processor=_a  )
              return object_detector, ["./tests/fixtures/tests_samples/COCO/000000039769.png"]

       def 	lowercase							(self  ,  UpperCAmelCase  ,  UpperCAmelCase  )					->       Tuple:
              _snake_case       =  object_detector("""./tests/fixtures/tests_samples/COCO/000000039769.png"""  ,  threshold=0.0  )

              self.assertGreater(len(_a  )  ,  0  )
              for detected_object in outputs:
                     self.assertEqual(
                         _a  ,  {
                             """score""": ANY(_a  ),
                             """label""": ANY(_a  ),
                             """box""": {"""xmin""": ANY(_a  ), """ymin""": ANY(_a  ), """xmax""": ANY(_a  ), """ymax""": ANY(_a  )},
                         }  ,  )

              import datasets

              _snake_case       =  datasets.load_dataset("""hf-internal-testing/fixtures_image_utils"""  ,  """image"""  ,  split="""test"""  )

              _snake_case       =  [
                  Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""  ),
                  """http://images.cocodataset.org/val2017/000000039769.jpg""",
                  # RGBA
                  dataset[0]["""file"""],
                  # LA
                  dataset[1]["""file"""],
                  # L
                  dataset[2]["""file"""],
              ]
              _snake_case       =  object_detector(_a  ,  threshold=0.0  )

              self.assertEqual(len(_a  )  ,  len(_a  )  )
              for outputs in batch_outputs:
                     self.assertGreater(len(_a  )  ,  0  )
                     for detected_object in outputs:
                            self.assertEqual(
                                _a  ,  {
                                    """score""": ANY(_a  ),
                                    """label""": ANY(_a  ),
                                    """box""": {"""xmin""": ANY(_a  ), """ymin""": ANY(_a  ), """xmax""": ANY(_a  ), """ymax""": ANY(_a  )},
                                }  ,  )

       @require_tf
       @unittest.skip("""Object detection not implemented in TF"""  )
       def 	lowercase							(self  )					->       Union[str, Any]:
              pass

       @require_torch
       def 	lowercase							(self  )					->       int:
              _snake_case       =  """hf-internal-testing/tiny-detr-mobilenetsv3"""

              _snake_case       =  AutoModelForObjectDetection.from_pretrained(_a  )
              _snake_case       =  AutoFeatureExtractor.from_pretrained(_a  )
              _snake_case       =  ObjectDetectionPipeline(model=_a  ,  feature_extractor=_a  )

              _snake_case       =  object_detector("""http://images.cocodataset.org/val2017/000000039769.jpg"""  ,  threshold=0.0  )

              self.assertEqual(
                  nested_simplify(_a  ,  decimals=4  )  ,  [
                      {"""score""": 0.3376, """label""": """LABEL_0""", """box""": {"""xmin""": 159, """ymin""": 120, """xmax""": 480, """ymax""": 359}},
                      {"""score""": 0.3376, """label""": """LABEL_0""", """box""": {"""xmin""": 159, """ymin""": 120, """xmax""": 480, """ymax""": 359}},
                  ]  ,  )

              _snake_case       =  object_detector(
                  [
                      """http://images.cocodataset.org/val2017/000000039769.jpg""",
                      """http://images.cocodataset.org/val2017/000000039769.jpg""",
                  ]  ,  threshold=0.0  ,  )

              self.assertEqual(
                  nested_simplify(_a  ,  decimals=4  )  ,  [
                      [
                          {"""score""": 0.3376, """label""": """LABEL_0""", """box""": {"""xmin""": 159, """ymin""": 120, """xmax""": 480, """ymax""": 359}},
                          {"""score""": 0.3376, """label""": """LABEL_0""", """box""": {"""xmin""": 159, """ymin""": 120, """xmax""": 480, """ymax""": 359}},
                      ],
                      [
                          {"""score""": 0.3376, """label""": """LABEL_0""", """box""": {"""xmin""": 159, """ymin""": 120, """xmax""": 480, """ymax""": 359}},
                          {"""score""": 0.3376, """label""": """LABEL_0""", """box""": {"""xmin""": 159, """ymin""": 120, """xmax""": 480, """ymax""": 359}},
                      ],
                  ]  ,  )

       @require_torch
       @slow
       def 	lowercase							(self  )					->       Tuple:
              _snake_case       =  """facebook/detr-resnet-50"""

              _snake_case       =  AutoModelForObjectDetection.from_pretrained(_a  )
              _snake_case       =  AutoFeatureExtractor.from_pretrained(_a  )
              _snake_case       =  ObjectDetectionPipeline(model=_a  ,  feature_extractor=_a  )

              _snake_case       =  object_detector("""http://images.cocodataset.org/val2017/000000039769.jpg"""  )
              self.assertEqual(
                  nested_simplify(_a  ,  decimals=4  )  ,  [
                      {"""score""": 0.9982, """label""": """remote""", """box""": {"""xmin""": 40, """ymin""": 70, """xmax""": 175, """ymax""": 117}},
                      {"""score""": 0.9960, """label""": """remote""", """box""": {"""xmin""": 333, """ymin""": 72, """xmax""": 368, """ymax""": 187}},
                      {"""score""": 0.9955, """label""": """couch""", """box""": {"""xmin""": 0, """ymin""": 1, """xmax""": 639, """ymax""": 473}},
                      {"""score""": 0.9988, """label""": """cat""", """box""": {"""xmin""": 13, """ymin""": 52, """xmax""": 314, """ymax""": 470}},
                      {"""score""": 0.9987, """label""": """cat""", """box""": {"""xmin""": 345, """ymin""": 23, """xmax""": 640, """ymax""": 368}},
                  ]  ,  )

              _snake_case       =  object_detector(
                  [
                      """http://images.cocodataset.org/val2017/000000039769.jpg""",
                      """http://images.cocodataset.org/val2017/000000039769.jpg""",
                  ]  )
              self.assertEqual(
                  nested_simplify(_a  ,  decimals=4  )  ,  [
                      [
                          {"""score""": 0.9982, """label""": """remote""", """box""": {"""xmin""": 40, """ymin""": 70, """xmax""": 175, """ymax""": 117}},
                          {"""score""": 0.9960, """label""": """remote""", """box""": {"""xmin""": 333, """ymin""": 72, """xmax""": 368, """ymax""": 187}},
                          {"""score""": 0.9955, """label""": """couch""", """box""": {"""xmin""": 0, """ymin""": 1, """xmax""": 639, """ymax""": 473}},
                          {"""score""": 0.9988, """label""": """cat""", """box""": {"""xmin""": 13, """ymin""": 52, """xmax""": 314, """ymax""": 470}},
                          {"""score""": 0.9987, """label""": """cat""", """box""": {"""xmin""": 345, """ymin""": 23, """xmax""": 640, """ymax""": 368}},
                      ],
                      [
                          {"""score""": 0.9982, """label""": """remote""", """box""": {"""xmin""": 40, """ymin""": 70, """xmax""": 175, """ymax""": 117}},
                          {"""score""": 0.9960, """label""": """remote""", """box""": {"""xmin""": 333, """ymin""": 72, """xmax""": 368, """ymax""": 187}},
                          {"""score""": 0.9955, """label""": """couch""", """box""": {"""xmin""": 0, """ymin""": 1, """xmax""": 639, """ymax""": 473}},
                          {"""score""": 0.9988, """label""": """cat""", """box""": {"""xmin""": 13, """ymin""": 52, """xmax""": 314, """ymax""": 470}},
                          {"""score""": 0.9987, """label""": """cat""", """box""": {"""xmin""": 345, """ymin""": 23, """xmax""": 640, """ymax""": 368}},
                      ],
                  ]  ,  )

       @require_torch
       @slow
       def 	lowercase							(self  )					->       List[str]:
              _snake_case       =  """facebook/detr-resnet-50"""

              _snake_case       =  pipeline("""object-detection"""  ,  model=_a  )

              _snake_case       =  object_detector("""http://images.cocodataset.org/val2017/000000039769.jpg"""  )
              self.assertEqual(
                  nested_simplify(_a  ,  decimals=4  )  ,  [
                      {"""score""": 0.9982, """label""": """remote""", """box""": {"""xmin""": 40, """ymin""": 70, """xmax""": 175, """ymax""": 117}},
                      {"""score""": 0.9960, """label""": """remote""", """box""": {"""xmin""": 333, """ymin""": 72, """xmax""": 368, """ymax""": 187}},
                      {"""score""": 0.9955, """label""": """couch""", """box""": {"""xmin""": 0, """ymin""": 1, """xmax""": 639, """ymax""": 473}},
                      {"""score""": 0.9988, """label""": """cat""", """box""": {"""xmin""": 13, """ymin""": 52, """xmax""": 314, """ymax""": 470}},
                      {"""score""": 0.9987, """label""": """cat""", """box""": {"""xmin""": 345, """ymin""": 23, """xmax""": 640, """ymax""": 368}},
                  ]  ,  )

              _snake_case       =  object_detector(
                  [
                      """http://images.cocodataset.org/val2017/000000039769.jpg""",
                      """http://images.cocodataset.org/val2017/000000039769.jpg""",
                  ]  )
              self.assertEqual(
                  nested_simplify(_a  ,  decimals=4  )  ,  [
                      [
                          {"""score""": 0.9982, """label""": """remote""", """box""": {"""xmin""": 40, """ymin""": 70, """xmax""": 175, """ymax""": 117}},
                          {"""score""": 0.9960, """label""": """remote""", """box""": {"""xmin""": 333, """ymin""": 72, """xmax""": 368, """ymax""": 187}},
                          {"""score""": 0.9955, """label""": """couch""", """box""": {"""xmin""": 0, """ymin""": 1, """xmax""": 639, """ymax""": 473}},
                          {"""score""": 0.9988, """label""": """cat""", """box""": {"""xmin""": 13, """ymin""": 52, """xmax""": 314, """ymax""": 470}},
                          {"""score""": 0.9987, """label""": """cat""", """box""": {"""xmin""": 345, """ymin""": 23, """xmax""": 640, """ymax""": 368}},
                      ],
                      [
                          {"""score""": 0.9982, """label""": """remote""", """box""": {"""xmin""": 40, """ymin""": 70, """xmax""": 175, """ymax""": 117}},
                          {"""score""": 0.9960, """label""": """remote""", """box""": {"""xmin""": 333, """ymin""": 72, """xmax""": 368, """ymax""": 187}},
                          {"""score""": 0.9955, """label""": """couch""", """box""": {"""xmin""": 0, """ymin""": 1, """xmax""": 639, """ymax""": 473}},
                          {"""score""": 0.9988, """label""": """cat""", """box""": {"""xmin""": 13, """ymin""": 52, """xmax""": 314, """ymax""": 470}},
                          {"""score""": 0.9987, """label""": """cat""", """box""": {"""xmin""": 345, """ymin""": 23, """xmax""": 640, """ymax""": 368}},
                      ],
                  ]  ,  )

       @require_torch
       @slow
       def 	lowercase							(self  )					->       Dict:
              _snake_case       =  0.9985
              _snake_case       =  """facebook/detr-resnet-50"""

              _snake_case       =  pipeline("""object-detection"""  ,  model=_a  )

              _snake_case       =  object_detector("""http://images.cocodataset.org/val2017/000000039769.jpg"""  ,  threshold=_a  )
              self.assertEqual(
                  nested_simplify(_a  ,  decimals=4  )  ,  [
                      {"""score""": 0.9988, """label""": """cat""", """box""": {"""xmin""": 13, """ymin""": 52, """xmax""": 314, """ymax""": 470}},
                      {"""score""": 0.9987, """label""": """cat""", """box""": {"""xmin""": 345, """ymin""": 23, """xmax""": 640, """ymax""": 368}},
                  ]  ,  )





       @require_torch
       @require_pytesseract
       @slow
       def 	lowercase							(self  )					->       Any:
              _snake_case       =  """Narsil/layoutlmv3-finetuned-funsd"""
              _snake_case       =  0.9993

              _snake_case       =  pipeline("""object-detection"""  ,  model=_a  ,  threshold=_a  )

              _snake_case       =  object_detector(
                  """https://huggingface.co/spaces/impira/docquery/resolve/2359223c1837a7587402bda0f2643382a6eefeab/invoice.png"""  )
              self.assertEqual(
                  nested_simplify(_a  ,  decimals=4  )  ,  [
                      {"""score""": 0.9993, """label""": """I-ANSWER""", """box""": {"""xmin""": 294, """ymin""": 254, """xmax""": 343, """ymax""": 264}},
                      {"""score""": 0.9993, """label""": """I-ANSWER""", """box""": {"""xmin""": 294, """ymin""": 254, """xmax""": 343, """ymax""": 264}},
                  ]  ,  )

'''simple docstring'''
from __future__ import annotations

import typing
from collections import Counter






def  __SCREAMING_SNAKE_CASE				(  _SCREAMING_SNAKE_CASE				):
							_snake_case       =  Counter()
							for base in range(1							, max_perimeter + 1				):
														for perpendicular in range(_SCREAMING_SNAKE_CASE							, max_perimeter + 1				):
																					_snake_case       =  (base * base + perpendicular * perpendicular) ** 0.5
																					if hypotenuse == int(_SCREAMING_SNAKE_CASE				):
																												_snake_case       =  int(base + perpendicular + hypotenuse				)
																												if perimeter > max_perimeter:
																																			continue
																												triplets[perimeter] += 1
							return triplets






def  __SCREAMING_SNAKE_CASE				(  _SCREAMING_SNAKE_CASE = 1000				):
							_snake_case       =  pythagorean_triple(_SCREAMING_SNAKE_CASE				)
							return triplets.most_common(1				)[0][0]


if __name__ == "__main__":
				print(f'''Perimeter {solution()} has maximum solutions''')