

import unittest

import requests

from transformers import MODEL_FOR_VISION_2_SEQ_MAPPING, TF_MODEL_FOR_VISION_2_SEQ_MAPPING, is_vision_available
from transformers.pipelines import pipeline
from transformers.testing_utils import (
    is_pipeline_test,
    is_torch_available,
    require_tf,
    require_torch,
    require_vision,
    slow,
)

from .test_pipelines_common import ANY


if is_torch_available():
    from transformers.pytorch_utils import is_torch_greater_or_equal_than_1_11
else:
    lowerCamelCase_					  =   False


if is_vision_available():
    from PIL import Image
else:







    class 					__lowerCamelCase							:







          @staticmethod
          def       lowerCAmelCase_       (	*lowerCamelCase				,    **lowerCamelCase  )		->			Dict:
            pass







@is_pipeline_test
@require_vision
class 					__lowerCamelCase							(      unittest.TestCase      ):
      lowerCamelCase_      : Tuple  			=   MODEL_FOR_VISION_2_SEQ_MAPPING
      lowerCamelCase_      : List[str]  			=   TF_MODEL_FOR_VISION_2_SEQ_MAPPING







      def       lowerCAmelCase_       (	self				,    lowerCamelCase				,    lowerCamelCase				,    lowerCamelCase  )		->			List[str]:
        snake_case_					= pipeline("""image-to-text"""				,    model=lowerCamelCase				,    tokenizer=lowerCamelCase				,    image_processor=lowerCamelCase  )
        snake_case_					= [
            Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""  ),
            """./tests/fixtures/tests_samples/COCO/000000039769.png""",
        ]
        return pipe, examples







      def       lowerCAmelCase_       (	self				,    lowerCamelCase				,    lowerCamelCase  )		->			str:
        snake_case_					= pipe(lowerCamelCase  )
        self.assertEqual(
            lowerCamelCase				,    [
                [{"""generated_text""": ANY(lowerCamelCase  )}],
                [{"""generated_text""": ANY(lowerCamelCase  )}],
            ]				,    )







      @require_tf
      def       lowerCAmelCase_       (	self  )		->			Tuple:
        snake_case_					= pipeline("""image-to-text"""				,    model="""hf-internal-testing/tiny-random-vit-gpt2"""				,    framework="""tf"""  )
        snake_case_					= """./tests/fixtures/tests_samples/COCO/000000039769.png"""

        snake_case_					= pipe(lowerCamelCase  )
        self.assertEqual(
            lowerCamelCase				,    [
                {
                    """generated_text""": """growthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthGOGO"""
                },
            ]				,    )

        snake_case_					= pipe([image, image]  )
        self.assertEqual(
            lowerCamelCase				,    [
                [
                    {
                        """generated_text""": """growthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthGOGO"""
                    }
                ],
                [
                    {
                        """generated_text""": """growthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthGOGO"""
                    }
                ],
            ]				,    )

        snake_case_					= pipe(lowerCamelCase				,    max_new_tokens=1  )
        self.assertEqual(
            lowerCamelCase				,    [{"""generated_text""": """growth"""}]				,    )







      @require_torch
      def       lowerCAmelCase_       (	self  )		->			Union[str, Any]:
        snake_case_					= pipeline("""image-to-text"""				,    model="""hf-internal-testing/tiny-random-vit-gpt2"""  )
        snake_case_					= """./tests/fixtures/tests_samples/COCO/000000039769.png"""

        snake_case_					= pipe(lowerCamelCase  )
        self.assertEqual(
            lowerCamelCase				,    [
                {
                    """generated_text""": """growthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthGOGO"""
                },
            ]				,    )

        snake_case_					= pipe([image, image]  )
        self.assertEqual(
            lowerCamelCase				,    [
                [
                    {
                        """generated_text""": """growthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthGOGO"""
                    }
                ],
                [
                    {
                        """generated_text""": """growthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthGOGO"""
                    }
                ],
            ]				,    )







      @require_torch
      def       lowerCAmelCase_       (	self  )		->			List[str]:
        snake_case_					= pipeline("""image-to-text"""				,    model="""hf-internal-testing/tiny-random-BlipForConditionalGeneration"""  )
        snake_case_					= """./tests/fixtures/tests_samples/COCO/000000039769.png"""
        snake_case_					= """a photo of"""

        snake_case_					= pipe(lowerCamelCase				,    prompt=lowerCamelCase  )
        self.assertTrue(outputs[0]["""generated_text"""].startswith(lowerCamelCase  )  )







      @slow
      @require_torch
      def       lowerCAmelCase_       (	self  )		->			Tuple:
        snake_case_					= pipeline("""image-to-text"""				,    model="""ydshieh/vit-gpt2-coco-en"""  )
        snake_case_					= """./tests/fixtures/tests_samples/COCO/000000039769.png"""

        snake_case_					= pipe(lowerCamelCase  )
        self.assertEqual(lowerCamelCase				,    [{"""generated_text""": """a cat laying on a blanket next to a cat laying on a bed """}]  )

        snake_case_					= pipe([image, image]  )
        self.assertEqual(
            lowerCamelCase				,    [
                [{"""generated_text""": """a cat laying on a blanket next to a cat laying on a bed """}],
                [{"""generated_text""": """a cat laying on a blanket next to a cat laying on a bed """}],
            ]				,    )







      @slow
      @require_torch
      def       lowerCAmelCase_       (	self  )		->			Tuple:
        snake_case_					= pipeline("""image-to-text"""				,    model="""Salesforce/blip-image-captioning-base"""  )
        snake_case_					= """https://huggingface.co/datasets/sayakpaul/sample-datasets/resolve/main/pokemon.png"""
        snake_case_					= Image.open(requests.get(lowerCamelCase				,    stream=lowerCamelCase  ).raw  )

        snake_case_					= pipe(lowerCamelCase  )
        self.assertEqual(lowerCamelCase				,    [{"""generated_text""": """a pink pokemon pokemon with a blue shirt and a blue shirt"""}]  )







      @slow
      @require_torch
      def       lowerCAmelCase_       (	self  )		->			str:
        snake_case_					= pipeline("""image-to-text"""				,    model="""microsoft/git-base-coco"""  )
        snake_case_					= """https://huggingface.co/datasets/sayakpaul/sample-datasets/resolve/main/pokemon.png"""
        snake_case_					= Image.open(requests.get(lowerCamelCase				,    stream=lowerCamelCase  ).raw  )

        snake_case_					= pipe(lowerCamelCase  )
        self.assertEqual(lowerCamelCase				,    [{"""generated_text""": """a cartoon of a purple character."""}]  )







      @slow
      @require_torch
      def       lowerCAmelCase_       (	self  )		->			int:
        snake_case_					= pipeline("""image-to-text"""				,    model="""Salesforce/blip-image-captioning-base"""  )
        snake_case_					= """https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/ai2d-demo.jpg"""
        snake_case_					= Image.open(requests.get(lowerCamelCase				,    stream=lowerCamelCase  ).raw  )

        snake_case_					= """a photography of"""

        snake_case_					= pipe(lowerCamelCase				,    prompt=lowerCamelCase  )
        self.assertEqual(lowerCamelCase				,    [{"""generated_text""": """a photography of a volcano"""}]  )

        with self.assertRaises(lowerCamelCase  ):
          snake_case_					= pipe([image, image]				,    prompt=[prompt, prompt]  )







      @slow
      @require_torch
      def       lowerCAmelCase_       (	self  )		->			Tuple:
        snake_case_					= pipeline("""image-to-text"""				,    model="""microsoft/git-base-coco"""  )
        snake_case_					= """https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/ai2d-demo.jpg"""
        snake_case_					= Image.open(requests.get(lowerCamelCase				,    stream=lowerCamelCase  ).raw  )

        snake_case_					= """a photo of a"""

        snake_case_					= pipe(lowerCamelCase				,    prompt=lowerCamelCase  )
        self.assertEqual(lowerCamelCase				,    [{"""generated_text""": """a photo of a tent with a tent and a tent in the background."""}]  )

        with self.assertRaises(lowerCamelCase  ):
          snake_case_					= pipe([image, image]				,    prompt=[prompt, prompt]  )







      @unittest.skipIf(
          not is_torch_greater_or_equal_than_1_11				,    reason="""`Pix2StructImageProcessor` requires `torch>=1.11.0`."""  )
      @slow
      @require_torch
      def       lowerCAmelCase_       (	self  )		->			Union[str, Any]:
        snake_case_					= pipeline("""image-to-text"""				,    model="""google/pix2struct-ai2d-base"""  )
        snake_case_					= """https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/ai2d-demo.jpg"""
        snake_case_					= Image.open(requests.get(lowerCamelCase				,    stream=lowerCamelCase  ).raw  )

        snake_case_					= """What does the label 15 represent? (1) lava (2) core (3) tunnel (4) ash cloud"""

        snake_case_					= pipe(lowerCamelCase				,    prompt=lowerCamelCase  )
        self.assertEqual(lowerCamelCase				,    [{"""generated_text""": """ash cloud"""}]  )

        with self.assertRaises(lowerCamelCase  ):
          snake_case_					= pipe([image, image]				,    prompt=[prompt, prompt]  )







      @slow
      @require_tf
      def       lowerCAmelCase_       (	self  )		->			Tuple:
        snake_case_					= pipeline("""image-to-text"""				,    model="""ydshieh/vit-gpt2-coco-en"""				,    framework="""tf"""  )
        snake_case_					= """./tests/fixtures/tests_samples/COCO/000000039769.png"""

        snake_case_					= pipe(lowerCamelCase  )
        self.assertEqual(lowerCamelCase				,    [{"""generated_text""": """a cat laying on a blanket next to a cat laying on a bed """}]  )

        snake_case_					= pipe([image, image]  )
        self.assertEqual(
            lowerCamelCase				,    [
                [{"""generated_text""": """a cat laying on a blanket next to a cat laying on a bed """}],
                [{"""generated_text""": """a cat laying on a blanket next to a cat laying on a bed """}],
            ]				,    )


def   UpperCamelCase(   lowercase_ = 100     ,   lowercase_ = 100				)      ->							int:





  '''simple docstring'''





  return max(
      sum(int(lowercase_				) for x in str(base**power				)				)
      for base in range(lowercase_				)
      for power in range(lowercase_				)				)


# Tests
if __name__ == "__main__":
    import doctest

    doctest.testmod()