




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







             """simple docstring"""





             @staticmethod
             def    __UpperCAmelCase (    *__A	:	Any						,**__A	:	Optional[Any]  )						->					Union[str, Any]:
               pass





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







       """simple docstring"""





       SCREAMING_SNAKE_CASE_      : Any      =  MODEL_FOR_OBJECT_DETECTION_MAPPING







       def    __UpperCAmelCase (    self	:	List[Any]						,__A	:	Dict						,__A	:	List[Any]						,__A	:	str  )						->					List[Any]:
         _lowercase							= ObjectDetectionPipeline(model=__A						,image_processor=__A  )
         return object_detector, ["./tests/fixtures/tests_samples/COCO/000000039769.png"]







       def    __UpperCAmelCase (    self	:	List[Any]						,__A	:	Union[str, Any]						,__A	:	Tuple  )						->					List[str]:
         _lowercase							= 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

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

         _lowercase							= [
             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'],
         ]
         _lowercase							= 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    __UpperCAmelCase (    self	:	Tuple  )						->					Any:
         pass







       @require_torch
       def    __UpperCAmelCase (    self	:	str  )						->					Tuple:
         _lowercase							= 'hf-internal-testing/tiny-detr-mobilenetsv3'

         _lowercase							= AutoModelForObjectDetection.from_pretrained(__A  )
         _lowercase							= AutoFeatureExtractor.from_pretrained(__A  )
         _lowercase							= ObjectDetectionPipeline(model=__A						,feature_extractor=__A  )

         _lowercase							= 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}},
             ]						,)

         _lowercase							= 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    __UpperCAmelCase (    self	:	List[Any]  )						->					List[Any]:
         _lowercase							= 'facebook/detr-resnet-50'

         _lowercase							= AutoModelForObjectDetection.from_pretrained(__A  )
         _lowercase							= AutoFeatureExtractor.from_pretrained(__A  )
         _lowercase							= ObjectDetectionPipeline(model=__A						,feature_extractor=__A  )

         _lowercase							= 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}},
             ]						,)

         _lowercase							= 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    __UpperCAmelCase (    self	:	int  )						->					Dict:
         _lowercase							= 'facebook/detr-resnet-50'

         _lowercase							= pipeline('object-detection'						,model=__A  )

         _lowercase							= 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}},
             ]						,)

         _lowercase							= 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    __UpperCAmelCase (    self	:	int  )						->					Dict:
         _lowercase							= 0.9985
         _lowercase							= 'facebook/detr-resnet-50'

         _lowercase							= pipeline('object-detection'						,model=__A  )

         _lowercase							= 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    __UpperCAmelCase (    self	:	Dict  )						->					List[Any]:
         _lowercase							= 'Narsil/layoutlmv3-finetuned-funsd'
         _lowercase							= 0.9993

         _lowercase							= pipeline('object-detection'						,model=__A						,threshold=__A  )

         _lowercase							= 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}},
             ]						,)






from ....utils import logging


snake_case 				=       logging.get_logger(__name__)





class 				A_				(      UpperCAmelCase	):







       """simple docstring"""





       def __init__(    self	:	Union[str, Any]						,__A	:	int						,__A	:	List[Any]=None						,__A	:	List[str]=2048  )						->					List[Any]:
         _lowercase							= config.__dict__
         _lowercase							= modal_hidden_size
         if num_labels:
           _lowercase							= num_labels