
"""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 	_SCREAMING_SNAKE_CASE       (  *UpperCAmelCase_ :							Tuple       ,      **UpperCAmelCase_ :							List[str]			)->  List[Any]:







                    """simple docstring"""
                    pass



@is_pipeline_test
@require_vision
@require_torch
class   __a  (      unittest.TestCase	):
       UpperCamelCase_		:					Dict   =			MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING






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







              """simple docstring"""
              UpperCamelCase					 =		pipeline(
                  "zero-shot-object-detection"       ,      model="hf-internal-testing/tiny-random-owlvit-object-detection"			)

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






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







              """simple docstring"""
              UpperCamelCase					 =		object_detector(examples[0]       ,      threshold=0.0			)

              UpperCamelCase					 =		len(UpperCAmelCase_			)
              self.assertGreater(UpperCAmelCase_       ,      0			)
              self.assertEqual(
                  UpperCAmelCase_       ,      [
                      {
                          "score": ANY(UpperCAmelCase_			),
                          "label": ANY(UpperCAmelCase_			),
                          "box": {"xmin": ANY(UpperCAmelCase_			), "ymin": ANY(UpperCAmelCase_			), "xmax": ANY(UpperCAmelCase_			), "ymax": ANY(UpperCAmelCase_			)},
                      }
                      for i in range(UpperCAmelCase_			)
                  ]       ,      )






       @require_tf
       @unittest.skip("Zero Shot Object Detection not implemented in TF"			)
       def 	_SCREAMING_SNAKE_CASE       (  self :							Optional[int]			)->  Optional[int]:







              """simple docstring"""
              pass






       @require_torch
       def 	_SCREAMING_SNAKE_CASE       (  self :							Any			)->  Any:







              """simple docstring"""
              UpperCamelCase					 =		pipeline(
                  "zero-shot-object-detection"       ,      model="hf-internal-testing/tiny-random-owlvit-object-detection"			)

              UpperCamelCase					 =		object_detector(
                  "./tests/fixtures/tests_samples/COCO/000000039769.png"       ,      candidate_labels=["cat", "remote", "couch"]       ,      threshold=0.64       ,      )

              self.assertEqual(
                  nested_simplify(UpperCAmelCase_       ,      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					 =		object_detector(
                  [
                      {
                          "image": "./tests/fixtures/tests_samples/COCO/000000039769.png",
                          "candidate_labels": ["cat", "remote", "couch"],
                      }
                  ]       ,      threshold=0.64       ,      )

              self.assertEqual(
                  nested_simplify(UpperCAmelCase_       ,      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 	_SCREAMING_SNAKE_CASE       (  self :							List[Any]			)->  int:







              """simple docstring"""
              UpperCamelCase					 =		pipeline("zero-shot-object-detection"			)

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







              """simple docstring"""
              pass






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







              """simple docstring"""
              UpperCamelCase					 =		0.2
              UpperCamelCase					 =		pipeline("zero-shot-object-detection"			)

              UpperCamelCase					 =		object_detector(
                  "http://images.cocodataset.org/val2017/000000039769.jpg"       ,      candidate_labels=["cat", "remote", "couch"]       ,      threshold=UpperCAmelCase_       ,      )
              self.assertEqual(
                  nested_simplify(UpperCAmelCase_       ,      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 	_SCREAMING_SNAKE_CASE       (  self :							Tuple			)->  Tuple:







              """simple docstring"""
              UpperCamelCase					 =		2
              UpperCamelCase					 =		pipeline("zero-shot-object-detection"			)

              UpperCamelCase					 =		object_detector(
                  "http://images.cocodataset.org/val2017/000000039769.jpg"       ,      candidate_labels=["cat", "remote", "couch"]       ,      top_k=UpperCAmelCase_       ,      )
              self.assertEqual(
                  nested_simplify(UpperCAmelCase_       ,      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 	lowerCamelCase__			(							UpperCAmelCase_		,      UpperCAmelCase_ = False				)->							bool:







       """simple docstring"""
       if n == 2:
              return True
       if not n % 2 or n < 2:
              return False
       if n > 5 and n % 10 not in (1, 3, 7, 9):  # can quickly check last digit
              return False
       if n > 3_31_70_44_06_46_79_88_73_85_96_19_81 and not allow_probable:
              raise ValueError(
                  "Warning: upper bound of deterministic test is exceeded. "
                  "Pass allow_probable=True to allow probabilistic test. "
                  "A return value of True indicates a probable prime."				)
       # array bounds provided by analysis
       UpperCamelCase					 =		[
           20_47,
           1_37_36_53,
           25_32_60_01,
           32_15_03_17_51,
           2_15_23_02_89_87_47,
           3_47_47_49_66_03_83,
           3_41_55_00_71_72_83_21,
           1,
           3_82_51_23_05_65_46_41_30_51,
           1,
           1,
           31_86_65_85_78_34_03_11_51_16_74_61,
           3_31_70_44_06_46_79_88_73_85_96_19_81,
       ]

       UpperCamelCase					 =		[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41]
       for idx, _p in enumerate(UpperCAmelCase_		,      1				):
              if n < _p:
                     # then we have our last prime to check
                     UpperCamelCase					 =		primes[:idx]
                     break
       UpperCamelCase ,       UpperCamelCase					 =		n - 1, 0
       # break up n -1 into a power of 2 (s) and
       # remaining odd component
       # essentially, solve for d * 2 ** s == n - 1
       while d % 2 == 0:
              d //= 2
              s += 1
       for prime in plist:
              UpperCamelCase					 =		False
              for r in range(UpperCAmelCase_				):
                     UpperCamelCase					 =		pow(UpperCAmelCase_		,      d * 2**r		,      UpperCAmelCase_				)
                     # see article for analysis explanation for m
                     if (r == 0 and m == 1) or ((m + 1) % n == 0):
                            UpperCamelCase					 =		True
                            # this loop will not determine compositeness
                            break
              if pr:
                     continue
              # if pr is False, then the above loop never evaluated to true,
              # and the n MUST be composite
              return False
       return True



def 	lowerCamelCase__			(							)->							None:







       """simple docstring"""
       assert not miller_rabin(5_61				)
       assert miller_rabin(5_63				)
       # 2047

       assert not miller_rabin(83_82_01				)
       assert miller_rabin(83_82_07				)
       # 1_373_653

       assert not miller_rabin(17_31_60_01				)
       assert miller_rabin(17_31_60_17				)
       # 25_326_001

       assert not miller_rabin(30_78_38_66_41				)
       assert miller_rabin(30_78_38_66_53				)
       # 3_215_031_751

       assert not miller_rabin(1_71_30_45_57_48_01				)
       assert miller_rabin(1_71_30_45_57_48_19				)
       # 2_152_302_898_747

       assert not miller_rabin(2_77_97_99_72_83_07				)
       assert miller_rabin(2_77_97_99_72_83_27				)
       # 3_474_749_660_383

       assert not miller_rabin(1_13_85_00_23_90_94_41				)
       assert miller_rabin(1_13_85_00_23_90_95_27				)
       # 341_550_071_728_321

       assert not miller_rabin(1_27_50_41_01_88_48_80_43_51				)
       assert miller_rabin(1_27_50_41_01_88_48_80_43_91				)
       # 3_825_123_056_546_413_051

       assert not miller_rabin(7_96_66_46_44_58_50_77_87_79_18_67				)
       assert miller_rabin(7_96_66_46_44_58_50_77_87_79_19_51				)
       # 318_665_857_834_031_151_167_461

       assert not miller_rabin(55_28_40_67_74_46_64_78_97_66_03_33				)
       assert miller_rabin(55_28_40_67_74_46_64_78_97_66_03_59				)
       # 3_317_044_064_679_887_385_961_981
       # upper limit for probabilistic test


if __name__ == "__main__":
      test_miller_rabin()





