




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 						lowercase							:

       @staticmethod
       def 					a__	(  *_a		,     **_a				)						->							int:
             pass







@is_pipeline_test
@require_vision
@require_timm
@require_torch
class 						lowercase							(   unittest.TestCase		):
     _a							 =						MODEL_FOR_OBJECT_DETECTION_MAPPING

     def 					a__	(  self		,     _a		,     _a		,     _a				)						->							Tuple:
           _A							:     Dict			=						ObjectDetectionPipeline(model=__SCREAMING_SNAKE_CASE		,     image_processor=__SCREAMING_SNAKE_CASE				)
           return object_detector, ["./tests/fixtures/tests_samples/COCO/000000039769.png"]

     def 					a__	(  self		,     _a		,     _a				)						->							Optional[int]:
           _A							:     Dict			=						object_detector("""./tests/fixtures/tests_samples/COCO/000000039769.png"""		,     threshold=0.0				)

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

           import datasets

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

           _A							:     str			=						[
               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'''],
           ]
           _A							:     Optional[int]			=						object_detector(__SCREAMING_SNAKE_CASE		,     threshold=0.0				)

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

     @require_tf
     @unittest.skip("""Object detection not implemented in TF"""				)
     def 					a__	(  self				)						->							List[Any]:
           pass

     @require_torch
     def 					a__	(  self				)						->							Optional[Any]:
           _A							:     int			=						'''hf-internal-testing/tiny-detr-mobilenetsv3'''

           _A							:     Any			=						AutoModelForObjectDetection.from_pretrained(__SCREAMING_SNAKE_CASE				)
           _A							:     Optional[int]			=						AutoFeatureExtractor.from_pretrained(__SCREAMING_SNAKE_CASE				)
           _A							:     Dict			=						ObjectDetectionPipeline(model=__SCREAMING_SNAKE_CASE		,     feature_extractor=__SCREAMING_SNAKE_CASE				)

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

           self.assertEqual(
               nested_simplify(__SCREAMING_SNAKE_CASE		,     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}},
               ]		,     )

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

           self.assertEqual(
               nested_simplify(__SCREAMING_SNAKE_CASE		,     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 					a__	(  self				)						->							int:
           _A							:     List[str]			=						'''facebook/detr-resnet-50'''

           _A							:     Tuple			=						AutoModelForObjectDetection.from_pretrained(__SCREAMING_SNAKE_CASE				)
           _A							:     List[str]			=						AutoFeatureExtractor.from_pretrained(__SCREAMING_SNAKE_CASE				)
           _A							:     List[Any]			=						ObjectDetectionPipeline(model=__SCREAMING_SNAKE_CASE		,     feature_extractor=__SCREAMING_SNAKE_CASE				)

           _A							:     Tuple			=						object_detector("""http://images.cocodataset.org/val2017/000000039769.jpg"""				)
           self.assertEqual(
               nested_simplify(__SCREAMING_SNAKE_CASE		,     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}},
               ]		,     )

           _A							:     List[str]			=						object_detector(
               [
                   """http://images.cocodataset.org/val2017/000000039769.jpg""",
                   """http://images.cocodataset.org/val2017/000000039769.jpg""",
               ]				)
           self.assertEqual(
               nested_simplify(__SCREAMING_SNAKE_CASE		,     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 					a__	(  self				)						->							Optional[int]:
           _A							:     List[Any]			=						'''facebook/detr-resnet-50'''

           _A							:     List[str]			=						pipeline("""object-detection"""		,     model=__SCREAMING_SNAKE_CASE				)

           _A							:     Dict			=						object_detector("""http://images.cocodataset.org/val2017/000000039769.jpg"""				)
           self.assertEqual(
               nested_simplify(__SCREAMING_SNAKE_CASE		,     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}},
               ]		,     )

           _A							:     List[Any]			=						object_detector(
               [
                   """http://images.cocodataset.org/val2017/000000039769.jpg""",
                   """http://images.cocodataset.org/val2017/000000039769.jpg""",
               ]				)
           self.assertEqual(
               nested_simplify(__SCREAMING_SNAKE_CASE		,     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 					a__	(  self				)						->							Optional[int]:
           _A							:     Optional[int]			=						0.9985
           _A							:     Optional[int]			=						'''facebook/detr-resnet-50'''

           _A							:     Dict			=						pipeline("""object-detection"""		,     model=__SCREAMING_SNAKE_CASE				)

           _A							:     Optional[Any]			=						object_detector("""http://images.cocodataset.org/val2017/000000039769.jpg"""		,     threshold=__SCREAMING_SNAKE_CASE				)
           self.assertEqual(
               nested_simplify(__SCREAMING_SNAKE_CASE		,     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 					a__	(  self				)						->							int:
           _A							:     int			=						'''Narsil/layoutlmv3-finetuned-funsd'''
           _A							:     Union[str, Any]			=						0.9993

           _A							:     str			=						pipeline("""object-detection"""		,     model=__SCREAMING_SNAKE_CASE		,     threshold=__SCREAMING_SNAKE_CASE				)

           _A							:     Tuple			=						object_detector(
               """https://huggingface.co/spaces/impira/docquery/resolve/2359223c1837a7587402bda0f2643382a6eefeab/invoice.png"""				)
           self.assertEqual(
               nested_simplify(__SCREAMING_SNAKE_CASE		,     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'''







_lowercase :  int    							=       [sum(int(c, 1_0) ** 2 for c in i.__str__()) for i in range(1_0_0_0_0_0)]
def 					snake_case_		(				__SCREAMING_SNAKE_CASE					: int							):



						"""simple docstring"""





						lowercase_	:     Optional[int]													=       0
						while number:
												# Increased Speed Slightly by checking every 5 digits together.
												sum_of_digits_squared += DIGITS_SQUARED[number % 100000]
												number //= 100000

						return sum_of_digits_squared


# There are 2 Chains made,
# One ends with 89 with the chain member 58 being the one which when declared first,
# there will be the least number of iterations for all the members to be checked.

# The other one ends with 1 and has only one element 1.

# So 58 and 1 are chosen to be declared at the starting.

# Changed dictionary to an array to quicken the solution
_lowercase :  list[bool | None]    							=       [None] * 1_0_0_0_0_0_0_0
_lowercase :  List[str]    							=       True
_lowercase :  Optional[int]    							=       False
def 					snake_case_		(				__SCREAMING_SNAKE_CASE					: int							):



						"""simple docstring"""





						if CHAINS[number - 1] is not None:
												return CHAINS[number - 1]  # type: ignore

						lowercase_	:     Tuple													=       chain(next_number(__SCREAMING_SNAKE_CASE							)							)
						lowercase_	:     Union[str, Any]													=       number_chain

						while number < 10000000:
												lowercase_	:     int													=       number_chain
												number *= 10

						return number_chain
def 					snake_case_		(				__SCREAMING_SNAKE_CASE					: int = 10000000							):



						"""simple docstring"""





						for i in range(1      ,      __SCREAMING_SNAKE_CASE							):
												if CHAINS[i] is None:
																		chain(i + 1							)

						return CHAINS[:number].count(__SCREAMING_SNAKE_CASE							)


if __name__ == "__main__":
							import doctest

							doctest.testmod()
							print(f"""{solution() = }""")



