



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:
							A__     :      Tuple             =			False


if is_vision_available():
							from PIL import Image
else:
							class 				_UpperCAmelCase :

											"""simple docstring"""




											@staticmethod
											def     lowercase__       (					*lowerCamelCase						:   Any,  **lowerCamelCase						:   List[Any]  ):

															'''simple docstring'''
															pass
@is_pipeline_test
@require_vision
class 				_UpperCAmelCase (	unittest.TestCase     ):

				"""simple docstring"""




				lowercase__    							=	MODEL_FOR_VISION_2_SEQ_MAPPING
				lowercase__    							=	TF_MODEL_FOR_VISION_2_SEQ_MAPPING




				def     lowercase__       (					self						:   Optional[Any],  lowerCamelCase						:   str,  lowerCamelCase						:   Optional[int],  lowerCamelCase						:   Any  ):

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




				def     lowercase__       (					self						:   Optional[Any],  lowerCamelCase						:   str,  lowerCamelCase						:   Tuple  ):

								'''simple docstring'''
								lowercase__       			=      pipe(lowercase_  )
								self.assertEqual(
								    lowercase_,  [
								        [{'''generated_text''': ANY(lowercase_  )}],
								        [{'''generated_text''': ANY(lowercase_  )}],
								    ],  )




				@require_tf
				def     lowercase__       (					self						:   List[Any]  ):

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

								lowercase__       			=      pipe(lowercase_  )
								self.assertEqual(
								    lowercase_,  [
								        {
								            '''generated_text''': '''growthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthGOGO'''
								        },
								    ],  )

								lowercase__       			=      pipe([image, image]  )
								self.assertEqual(
								    lowercase_,  [
								        [
								            {
								                '''generated_text''': '''growthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthGOGO'''
								            }
								        ],
								        [
								            {
								                '''generated_text''': '''growthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthGOGO'''
								            }
								        ],
								    ],  )

								lowercase__       			=      pipe(lowercase_,  max_new_tokens=1  )
								self.assertEqual(
								    lowercase_,  [{'''generated_text''': '''growth'''}],  )




				@require_torch
				def     lowercase__       (					self						:   Tuple  ):

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

								lowercase__       			=      pipe(lowercase_  )
								self.assertEqual(
								    lowercase_,  [
								        {
								            '''generated_text''': '''growthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthGOGO'''
								        },
								    ],  )

								lowercase__       			=      pipe([image, image]  )
								self.assertEqual(
								    lowercase_,  [
								        [
								            {
								                '''generated_text''': '''growthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthGOGO'''
								            }
								        ],
								        [
								            {
								                '''generated_text''': '''growthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthGOGO'''
								            }
								        ],
								    ],  )




				@require_torch
				def     lowercase__       (					self						:   int  ):

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

								lowercase__       			=      pipe(lowercase_,  prompt=lowercase_  )
								self.assertTrue(outputs[0]['''generated_text'''].startswith(lowercase_  )  )




				@slow
				@require_torch
				def     lowercase__       (					self						:   Tuple  ):

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

								lowercase__       			=      pipe(lowercase_  )
								self.assertEqual(lowercase_,  [{'''generated_text''': '''a cat laying on a blanket next to a cat laying on a bed '''}]  )

								lowercase__       			=      pipe([image, image]  )
								self.assertEqual(
								    lowercase_,  [
								        [{'''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     lowercase__       (					self						:   List[Any]  ):

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

								lowercase__       			=      pipe(lowercase_  )
								self.assertEqual(lowercase_,  [{'''generated_text''': '''a pink pokemon pokemon with a blue shirt and a blue shirt'''}]  )




				@slow
				@require_torch
				def     lowercase__       (					self						:   Dict  ):

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

								lowercase__       			=      pipe(lowercase_  )
								self.assertEqual(lowercase_,  [{'''generated_text''': '''a cartoon of a purple character.'''}]  )




				@slow
				@require_torch
				def     lowercase__       (					self						:   Tuple  ):

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

								lowercase__       			=      '''a photography of'''

								lowercase__       			=      pipe(lowercase_,  prompt=lowercase_  )
								self.assertEqual(lowercase_,  [{'''generated_text''': '''a photography of a volcano'''}]  )

								with self.assertRaises(lowercase_  ):
												lowercase__       			=      pipe([image, image],  prompt=[prompt, prompt]  )




				@slow
				@require_torch
				def     lowercase__       (					self						:   Union[str, Any]  ):

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

								lowercase__       			=      '''a photo of a'''

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

								with self.assertRaises(lowercase_  ):
												lowercase__       			=      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     lowercase__       (					self						:   List[Any]  ):

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

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

								lowercase__       			=      pipe(lowercase_,  prompt=lowercase_  )
								self.assertEqual(lowercase_,  [{'''generated_text''': '''ash cloud'''}]  )

								with self.assertRaises(lowercase_  ):
												lowercase__       			=      pipe([image, image],  prompt=[prompt, prompt]  )




				@slow
				@require_tf
				def     lowercase__       (					self						:   Optional[int]  ):

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

								lowercase__       			=      pipe(lowercase_  )
								self.assertEqual(lowercase_,  [{'''generated_text''': '''a cat laying on a blanket next to a cat laying on a bed '''}]  )

								lowercase__       			=      pipe([image, image]  )
								self.assertEqual(
								    lowercase_,  [
								        [{'''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 TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


A__     :      Dict             =			{'configuration_sew_d': ['SEW_D_PRETRAINED_CONFIG_ARCHIVE_MAP', 'SEWDConfig']}

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							A__     :      Union[str, Any]             =			[
							    'SEW_D_PRETRAINED_MODEL_ARCHIVE_LIST',
							    'SEWDForCTC',
							    'SEWDForSequenceClassification',
							    'SEWDModel',
							    'SEWDPreTrainedModel',
							]

if TYPE_CHECKING:
							from .configuration_sew_d import SEW_D_PRETRAINED_CONFIG_ARCHIVE_MAP, SEWDConfig

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_sew_d import (
														    SEW_D_PRETRAINED_MODEL_ARCHIVE_LIST,
														    SEWDForCTC,
														    SEWDForSequenceClassification,
														    SEWDModel,
														    SEWDPreTrainedModel,
														)


else:
							import sys

							A__     :      Tuple             =			_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)




