





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


								@staticmethod
								def        _snake_case					(							*__A      :Tuple							,			**__A      :Dict						)				->				Optional[Any]:



										"""simple docstring"""



										pass




@is_pipeline_test
@require_vision
class 					UpperCamelCase_    (       unittest.TestCase      ):
							lowerCamelCase_          =   MODEL_FOR_VISION_2_SEQ_MAPPING
							lowerCamelCase_          =   TF_MODEL_FOR_VISION_2_SEQ_MAPPING


							def        _snake_case					(							self      :int							,			__A      :List[Any]							,			__A      :Union[str, Any]							,			__A      :str						)				->				List[Any]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								= pipeline("""image-to-text"""							,			model=__A							,			tokenizer=__A							,			image_processor=__A						)
									SCREAMING_SNAKE_CASE__								= [
									    Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""						),
									    './tests/fixtures/tests_samples/COCO/000000039769.png',
									]
									return pipe, examples


							def        _snake_case					(							self      :str							,			__A      :List[Any]							,			__A      :Tuple						)				->				List[Any]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								= pipe(__A						)
									self.assertEqual(
									    __A							,			[
									        [{"""generated_text""": ANY(__A						)}],
									        [{"""generated_text""": ANY(__A						)}],
									    ]							,			)


							@require_tf
							def        _snake_case					(							self      :Optional[Any]						)				->				List[str]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								= pipeline("""image-to-text"""							,			model="""hf-internal-testing/tiny-random-vit-gpt2"""							,			framework="""tf"""						)
									SCREAMING_SNAKE_CASE__								= './tests/fixtures/tests_samples/COCO/000000039769.png'

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

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

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


							@require_torch
							def        _snake_case					(							self      :List[Any]						)				->				str:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								= pipeline("""image-to-text"""							,			model="""hf-internal-testing/tiny-random-vit-gpt2"""						)
									SCREAMING_SNAKE_CASE__								= './tests/fixtures/tests_samples/COCO/000000039769.png'

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

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


							@require_torch
							def        _snake_case					(							self      :Union[str, Any]						)				->				Tuple:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								= pipeline("""image-to-text"""							,			model="""hf-internal-testing/tiny-random-BlipForConditionalGeneration"""						)
									SCREAMING_SNAKE_CASE__								= './tests/fixtures/tests_samples/COCO/000000039769.png'
									SCREAMING_SNAKE_CASE__								= 'a photo of'

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


							@slow
							@require_torch
							def        _snake_case					(							self      :Tuple						)				->				List[Any]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								= pipeline("""image-to-text"""							,			model="""ydshieh/vit-gpt2-coco-en"""						)
									SCREAMING_SNAKE_CASE__								= './tests/fixtures/tests_samples/COCO/000000039769.png'

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

									SCREAMING_SNAKE_CASE__								= pipe([image, image]						)
									self.assertEqual(
									    __A							,			[
									        [{"""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        _snake_case					(							self      :Any						)				->				List[str]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								= pipeline("""image-to-text"""							,			model="""Salesforce/blip-image-captioning-base"""						)
									SCREAMING_SNAKE_CASE__								= 'https://huggingface.co/datasets/sayakpaul/sample-datasets/resolve/main/pokemon.png'
									SCREAMING_SNAKE_CASE__								= Image.open(requests.get(__A							,			stream=__A						).raw						)

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


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



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								= pipeline("""image-to-text"""							,			model="""microsoft/git-base-coco"""						)
									SCREAMING_SNAKE_CASE__								= 'https://huggingface.co/datasets/sayakpaul/sample-datasets/resolve/main/pokemon.png'
									SCREAMING_SNAKE_CASE__								= Image.open(requests.get(__A							,			stream=__A						).raw						)

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


							@slow
							@require_torch
							def        _snake_case					(							self      :Union[str, Any]						)				->				int:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								= pipeline("""image-to-text"""							,			model="""Salesforce/blip-image-captioning-base"""						)
									SCREAMING_SNAKE_CASE__								= 'https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/ai2d-demo.jpg'
									SCREAMING_SNAKE_CASE__								= Image.open(requests.get(__A							,			stream=__A						).raw						)

									SCREAMING_SNAKE_CASE__								= 'a photography of'

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

									with self.assertRaises(__A						):
											SCREAMING_SNAKE_CASE__								= pipe([image, image]							,			prompt=[prompt, prompt]						)


							@slow
							@require_torch
							def        _snake_case					(							self      :Union[str, Any]						)				->				Optional[int]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								= pipeline("""image-to-text"""							,			model="""microsoft/git-base-coco"""						)
									SCREAMING_SNAKE_CASE__								= 'https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/ai2d-demo.jpg'
									SCREAMING_SNAKE_CASE__								= Image.open(requests.get(__A							,			stream=__A						).raw						)

									SCREAMING_SNAKE_CASE__								= 'a photo of a'

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

									with self.assertRaises(__A						):
											SCREAMING_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        _snake_case					(							self      :List[Any]						)				->				List[str]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								= pipeline("""image-to-text"""							,			model="""google/pix2struct-ai2d-base"""						)
									SCREAMING_SNAKE_CASE__								= 'https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/ai2d-demo.jpg'
									SCREAMING_SNAKE_CASE__								= Image.open(requests.get(__A							,			stream=__A						).raw						)

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

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

									with self.assertRaises(__A						):
											SCREAMING_SNAKE_CASE__								= pipe([image, image]							,			prompt=[prompt, prompt]						)


							@slow
							@require_tf
							def        _snake_case					(							self      :int						)				->				Tuple:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								= pipeline("""image-to-text"""							,			model="""ydshieh/vit-gpt2-coco-en"""							,			framework="""tf"""						)
									SCREAMING_SNAKE_CASE__								= './tests/fixtures/tests_samples/COCO/000000039769.png'

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

									SCREAMING_SNAKE_CASE__								= pipe([image, image]						)
									self.assertEqual(
									    __A							,			[
									        [{"""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 """}],
									    ]							,			)






from typing import Callable






def 			SCREAMING_SNAKE_CASE__							(    UpperCamelCase__:							Callable      ):

		def wrapper(UpperCamelCase__:							List[Any]      ):
				SCREAMING_SNAKE_CASE__								= function_with_docstring.__doc__
				return target_function

		return wrapper