




'''simple docstring'''

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__         =     False


if is_vision_available():
		from PIL import Image
else:





		class __magic_name__:






								@staticmethod
								def       __lowerCAmelCase(   *__UpperCamelCase						:						List[Any]					,   **__UpperCamelCase						:						List[Any]       ):



											'''simple docstring'''






											pass





@is_pipeline_test
@require_vision
class __magic_name__(						unittest.TestCase      ):
						UpperCAmelCase_		:					int    =  MODEL_FOR_VISION_2_SEQ_MAPPING
						UpperCAmelCase_		:					Tuple    =  TF_MODEL_FOR_VISION_2_SEQ_MAPPING






						def       __lowerCAmelCase(   self						:						Union[str, Any]					,   __UpperCamelCase						:						Tuple					,   __UpperCamelCase						:						List[Any]					,   __UpperCamelCase						:						List[Any]       ):



									'''simple docstring'''






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






						def       __lowerCAmelCase(   self						:						List[Any]					,   __UpperCamelCase						:						List[str]					,   __UpperCamelCase						:						int       ):



									'''simple docstring'''






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






						@require_tf
						def       __lowerCAmelCase(   self						:						Union[str, Any]       ):



									'''simple docstring'''






									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(__UpperCamelCase       )
									self.assertEqual(
									    __UpperCamelCase					,   [
									        {
									            """generated_text""": """growthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthGOGO"""
									        },
									    ]					,   )

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

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






						@require_torch
						def       __lowerCAmelCase(   self						:						str       ):



									'''simple docstring'''






									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(__UpperCamelCase       )
									self.assertEqual(
									    __UpperCamelCase					,   [
									        {
									            """generated_text""": """growthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthGOGO"""
									        },
									    ]					,   )

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






						@require_torch
						def       __lowerCAmelCase(   self						:						Any       ):



									'''simple docstring'''






									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(__UpperCamelCase					,   prompt=__UpperCamelCase       )
									self.assertTrue(outputs[0]["""generated_text"""].startswith(__UpperCamelCase       )       )






						@slow
						@require_torch
						def       __lowerCAmelCase(   self						:						List[str]       ):



									'''simple docstring'''






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

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

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



									'''simple docstring'''






									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(__UpperCamelCase					,   stream=__UpperCamelCase       ).raw       )

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






						@slow
						@require_torch
						def       __lowerCAmelCase(   self						:						int       ):



									'''simple docstring'''






									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(__UpperCamelCase					,   stream=__UpperCamelCase       ).raw       )

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






						@slow
						@require_torch
						def       __lowerCAmelCase(   self						:						Optional[Any]       ):



									'''simple docstring'''






									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(__UpperCamelCase					,   stream=__UpperCamelCase       ).raw       )

									snake_case__          =						"""a photography of"""

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

									with self.assertRaises(__UpperCamelCase       ):
												snake_case__          =						pipe([image, image]					,   prompt=[prompt, prompt]       )






						@slow
						@require_torch
						def       __lowerCAmelCase(   self						:						Any       ):



									'''simple docstring'''






									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(__UpperCamelCase					,   stream=__UpperCamelCase       ).raw       )

									snake_case__          =						"""a photo of a"""

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

									with self.assertRaises(__UpperCamelCase       ):
												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						:						str       ):



									'''simple docstring'''






									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(__UpperCamelCase					,   stream=__UpperCamelCase       ).raw       )

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

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

									with self.assertRaises(__UpperCamelCase       ):
												snake_case__          =						pipe([image, image]					,   prompt=[prompt, prompt]       )







						@slow
						@require_tf
						def       __lowerCAmelCase(   self						:						int       ):



									'''simple docstring'''






									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(__UpperCamelCase       )
									self.assertEqual(__UpperCamelCase					,   [{"""generated_text""": """a cat laying on a blanket next to a cat laying on a bed """}]       )

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





'''simple docstring'''

from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_torch_available,
)


a__         =     {'''configuration_gptj''': ['''GPTJ_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''GPTJConfig''', '''GPTJOnnxConfig''']}

try:
		if not is_torch_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		a__         =     [
		    '''GPTJ_PRETRAINED_MODEL_ARCHIVE_LIST''',
		    '''GPTJForCausalLM''',
		    '''GPTJForQuestionAnswering''',
		    '''GPTJForSequenceClassification''',
		    '''GPTJModel''',
		    '''GPTJPreTrainedModel''',
		]

try:
		if not is_tf_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		a__         =     [
		    '''TFGPTJForCausalLM''',
		    '''TFGPTJForQuestionAnswering''',
		    '''TFGPTJForSequenceClassification''',
		    '''TFGPTJModel''',
		    '''TFGPTJPreTrainedModel''',
		]

try:
		if not is_flax_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		a__         =     [
		    '''FlaxGPTJForCausalLM''',
		    '''FlaxGPTJModel''',
		    '''FlaxGPTJPreTrainedModel''',
		]


if TYPE_CHECKING:
		from .configuration_gptj import GPTJ_PRETRAINED_CONFIG_ARCHIVE_MAP, GPTJConfig, GPTJOnnxConfig

		try:
				if not is_torch_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_gptj import (
				    GPTJ_PRETRAINED_MODEL_ARCHIVE_LIST,
				    GPTJForCausalLM,
				    GPTJForQuestionAnswering,
				    GPTJForSequenceClassification,
				    GPTJModel,
				    GPTJPreTrainedModel,
				)

		try:
				if not is_tf_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_tf_gptj import (
				    TFGPTJForCausalLM,
				    TFGPTJForQuestionAnswering,
				    TFGPTJForSequenceClassification,
				    TFGPTJModel,
				    TFGPTJPreTrainedModel,
				)

		try:
				if not is_flax_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_flax_gptj import FlaxGPTJForCausalLM, FlaxGPTJModel, FlaxGPTJPreTrainedModel

else:
		import sys

		a__         =     _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)