"""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 			UpperCamelCase						:
          @staticmethod
          def      _UpperCAmelCase  (     *__UpperCamelCase	,**__UpperCamelCase     )      -> Tuple:


               '''simple docstring'''


               pass







@is_pipeline_test
@require_vision
@require_timm
@require_torch
class 			UpperCamelCase						(     unittest.TestCase    ):
   lowercase				=    MODEL_FOR_OBJECT_DETECTION_MAPPING
   def      _UpperCAmelCase  (     self	,__UpperCamelCase	,__UpperCamelCase	,__UpperCamelCase     )      -> Optional[Any]:


        '''simple docstring'''


        lowercase_      :							Dict						=      ObjectDetectionPipeline(model=lowerCamelCase__	,image_processor=lowerCamelCase__     )
        return object_detector, ["./tests/fixtures/tests_samples/COCO/000000039769.png"]
   def      _UpperCAmelCase  (     self	,__UpperCamelCase	,__UpperCamelCase     )      -> Union[str, Any]:


        '''simple docstring'''


        lowercase_      :							Union[str, Any]						=      object_detector('./tests/fixtures/tests_samples/COCO/000000039769.png'	,threshold=0.0     )

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

        import datasets

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

        lowercase_      :							Dict						=      [
            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_      :							Any						=      object_detector(lowerCamelCase__	,threshold=0.0     )

        self.assertEqual(len(lowerCamelCase__     )	,len(lowerCamelCase__     )     )
        for outputs in batch_outputs:
             self.assertGreater(len(lowerCamelCase__     )	,0     )
             for detected_object in outputs:
                  self.assertEqual(
                      lowerCamelCase__	,{
                          'score': ANY(lowerCamelCase__     ),
                          'label': ANY(lowerCamelCase__     ),
                          'box': {'xmin': ANY(lowerCamelCase__     ), 'ymin': ANY(lowerCamelCase__     ), 'xmax': ANY(lowerCamelCase__     ), 'ymax': ANY(lowerCamelCase__     )},
                      }	,)
   @require_tf
   @unittest.skip('Object detection not implemented in TF'     )
   def      _UpperCAmelCase  (     self     )      -> Tuple:


        '''simple docstring'''


        pass
   @require_torch
   def      _UpperCAmelCase  (     self     )      -> int:


        '''simple docstring'''


        lowercase_      :							List[Any]						=      'hf-internal-testing/tiny-detr-mobilenetsv3'

        lowercase_      :							List[Any]						=      AutoModelForObjectDetection.from_pretrained(lowerCamelCase__     )
        lowercase_      :							Optional[int]						=      AutoFeatureExtractor.from_pretrained(lowerCamelCase__     )
        lowercase_      :							str						=      ObjectDetectionPipeline(model=lowerCamelCase__	,feature_extractor=lowerCamelCase__     )

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

        self.assertEqual(
            nested_simplify(lowerCamelCase__	,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_      :							List[str]						=      object_detector(
            [
                'http://images.cocodataset.org/val2017/000000039769.jpg',
                'http://images.cocodataset.org/val2017/000000039769.jpg',
            ]	,threshold=0.0	,)

        self.assertEqual(
            nested_simplify(lowerCamelCase__	,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[str]:


        '''simple docstring'''


        lowercase_      :							Optional[int]						=      'facebook/detr-resnet-50'

        lowercase_      :							Dict						=      AutoModelForObjectDetection.from_pretrained(lowerCamelCase__     )
        lowercase_      :							str						=      AutoFeatureExtractor.from_pretrained(lowerCamelCase__     )
        lowercase_      :							Optional[Any]						=      ObjectDetectionPipeline(model=lowerCamelCase__	,feature_extractor=lowerCamelCase__     )

        lowercase_      :							Tuple						=      object_detector('http://images.cocodataset.org/val2017/000000039769.jpg'     )
        self.assertEqual(
            nested_simplify(lowerCamelCase__	,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_      :							Any						=      object_detector(
            [
                'http://images.cocodataset.org/val2017/000000039769.jpg',
                'http://images.cocodataset.org/val2017/000000039769.jpg',
            ]     )
        self.assertEqual(
            nested_simplify(lowerCamelCase__	,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     )      -> List[Any]:


        '''simple docstring'''


        lowercase_      :							Tuple						=      'facebook/detr-resnet-50'

        lowercase_      :							Tuple						=      pipeline('object-detection'	,model=lowerCamelCase__     )

        lowercase_      :							str						=      object_detector('http://images.cocodataset.org/val2017/000000039769.jpg'     )
        self.assertEqual(
            nested_simplify(lowerCamelCase__	,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_      :							Any						=      object_detector(
            [
                'http://images.cocodataset.org/val2017/000000039769.jpg',
                'http://images.cocodataset.org/val2017/000000039769.jpg',
            ]     )
        self.assertEqual(
            nested_simplify(lowerCamelCase__	,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     )      -> Tuple:


        '''simple docstring'''


        lowercase_      :							int						=      0.9985
        lowercase_      :							str						=      'facebook/detr-resnet-50'

        lowercase_      :							List[str]						=      pipeline('object-detection'	,model=lowerCamelCase__     )

        lowercase_      :							Optional[int]						=      object_detector('http://images.cocodataset.org/val2017/000000039769.jpg'	,threshold=lowerCamelCase__     )
        self.assertEqual(
            nested_simplify(lowerCamelCase__	,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     )      -> Union[str, Any]:


        '''simple docstring'''


        lowercase_      :							str						=      'Narsil/layoutlmv3-finetuned-funsd'
        lowercase_      :							Union[str, Any]						=      0.9993

        lowercase_      :							Union[str, Any]						=      pipeline('object-detection'	,model=lowerCamelCase__	,threshold=lowerCamelCase__     )

        lowercase_      :							int						=      object_detector(
            'https://huggingface.co/spaces/impira/docquery/resolve/2359223c1837a7587402bda0f2643382a6eefeab/invoice.png'     )
        self.assertEqual(
            nested_simplify(lowerCamelCase__	,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'''
def A__       (	UpperCAmelCase_    ,    UpperCAmelCase_				):
						return base * power(UpperCAmelCase_    ,    (exponent - 1)				) if exponent else 1


if __name__ == "__main__":
					print('Raise base to the power of exponent using recursion...')
					snake_case_					:      int    			=    int(input('Enter the base: ').strip())
					snake_case_					:      Optional[int]    			=    int(input('Enter the exponent: ').strip())
					snake_case_					:      Optional[int]    			=    power(base, abs(exponent))
					if exponent < 0:  # power() does not properly deal w/ negative exponents
										snake_case_					:      List[Any]    			=    1 / result
					print(F"""{base} to the power of {exponent} is {result}""")


