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:
				__SCREAMING_SNAKE_CASE						:    Any     = False


if is_vision_available():
				from PIL import Image
else:



				class    lowercase_    :



											@staticmethod
											def        UpperCamelCase       (						*lowercase_      ,				**lowercase_				):
																	pass



@is_pipeline_test
@require_vision
class    lowercase_    (     unittest.TestCase		):
							_lowerCamelCase						=		MODEL_FOR_VISION_2_SEQ_MAPPING
							_lowerCamelCase						=		TF_MODEL_FOR_VISION_2_SEQ_MAPPING



							def        UpperCamelCase       (						self      ,				lowercase_      ,				lowercase_      ,				lowercase_				):
													_snake_case						:     str				=    pipeline("image-to-text"      ,				model=lowercase_      ,				tokenizer=lowercase_      ,				image_processor=lowercase_				)
													_snake_case						:     Any				=    [
													    Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"				),
													    "./tests/fixtures/tests_samples/COCO/000000039769.png",
													]
													return pipe, examples



							def        UpperCamelCase       (						self      ,				lowercase_      ,				lowercase_				):
													_snake_case						:     str				=    pipe(lowercase_				)
													self.assertEqual(
													    lowercase_      ,				[
													        [{"generated_text": ANY(lowercase_				)}],
													        [{"generated_text": ANY(lowercase_				)}],
													    ]      ,				)



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

													_snake_case						:     Tuple				=    pipe(lowercase_				)
													self.assertEqual(
													    lowercase_      ,				[
													        {
													            "generated_text": "growthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthGOGO"
													        },
													    ]      ,				)

													_snake_case						:     Dict				=    pipe([image, image]				)
													self.assertEqual(
													    lowercase_      ,				[
													        [
													            {
													                "generated_text": "growthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthGOGO"
													            }
													        ],
													        [
													            {
													                "generated_text": "growthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthGOGO"
													            }
													        ],
													    ]      ,				)

													_snake_case						:     Optional[int]				=    pipe(lowercase_      ,				max_new_tokens=1				)
													self.assertEqual(
													    lowercase_      ,				[{"generated_text": "growth"}]      ,				)



							@require_torch
							def        UpperCamelCase       (						self				):
													_snake_case						:     List[str]				=    pipeline("image-to-text"      ,				model="hf-internal-testing/tiny-random-vit-gpt2"				)
													_snake_case						:     Optional[int]				=    "./tests/fixtures/tests_samples/COCO/000000039769.png"

													_snake_case						:     Optional[Any]				=    pipe(lowercase_				)
													self.assertEqual(
													    lowercase_      ,				[
													        {
													            "generated_text": "growthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthGOGO"
													        },
													    ]      ,				)

													_snake_case						:     Optional[Any]				=    pipe([image, image]				)
													self.assertEqual(
													    lowercase_      ,				[
													        [
													            {
													                "generated_text": "growthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthGOGO"
													            }
													        ],
													        [
													            {
													                "generated_text": "growthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthGOGO"
													            }
													        ],
													    ]      ,				)



							@require_torch
							def        UpperCamelCase       (						self				):
													_snake_case						:     int				=    pipeline("image-to-text"      ,				model="hf-internal-testing/tiny-random-BlipForConditionalGeneration"				)
													_snake_case						:     Optional[int]				=    "./tests/fixtures/tests_samples/COCO/000000039769.png"
													_snake_case						:     Optional[int]				=    "a photo of"

													_snake_case						:     int				=    pipe(lowercase_      ,				prompt=lowercase_				)
													self.assertTrue(outputs[0]["generated_text"].startswith(lowercase_				)				)



							@slow
							@require_torch
							def        UpperCamelCase       (						self				):
													_snake_case						:     str				=    pipeline("image-to-text"      ,				model="ydshieh/vit-gpt2-coco-en"				)
													_snake_case						:     List[Any]				=    "./tests/fixtures/tests_samples/COCO/000000039769.png"

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

													_snake_case						:     Tuple				=    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        UpperCamelCase       (						self				):
													_snake_case						:     Dict				=    pipeline("image-to-text"      ,				model="Salesforce/blip-image-captioning-base"				)
													_snake_case						:     Optional[int]				=    "https://huggingface.co/datasets/sayakpaul/sample-datasets/resolve/main/pokemon.png"
													_snake_case						:     Union[str, Any]				=    Image.open(requests.get(lowercase_      ,				stream=lowercase_				).raw				)

													_snake_case						:     List[str]				=    pipe(lowercase_				)
													self.assertEqual(lowercase_      ,				[{"generated_text": "a pink pokemon pokemon with a blue shirt and a blue shirt"}]				)



							@slow
							@require_torch
							def        UpperCamelCase       (						self				):
													_snake_case						:     Optional[Any]				=    pipeline("image-to-text"      ,				model="microsoft/git-base-coco"				)
													_snake_case						:     Dict				=    "https://huggingface.co/datasets/sayakpaul/sample-datasets/resolve/main/pokemon.png"
													_snake_case						:     Optional[Any]				=    Image.open(requests.get(lowercase_      ,				stream=lowercase_				).raw				)

													_snake_case						:     Optional[int]				=    pipe(lowercase_				)
													self.assertEqual(lowercase_      ,				[{"generated_text": "a cartoon of a purple character."}]				)



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

													_snake_case						:     str				=    "a photography of"

													_snake_case						:     Union[str, Any]				=    pipe(lowercase_      ,				prompt=lowercase_				)
													self.assertEqual(lowercase_      ,				[{"generated_text": "a photography of a volcano"}]				)

													with self.assertRaises(lowercase_				):
																			_snake_case						:     List[Any]				=    pipe([image, image]      ,				prompt=[prompt, prompt]				)



							@slow
							@require_torch
							def        UpperCamelCase       (						self				):
													_snake_case						:     Tuple				=    pipeline("image-to-text"      ,				model="microsoft/git-base-coco"				)
													_snake_case						:     List[Any]				=    "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/ai2d-demo.jpg"
													_snake_case						:     Union[str, Any]				=    Image.open(requests.get(lowercase_      ,				stream=lowercase_				).raw				)

													_snake_case						:     Optional[int]				=    "a photo of a"

													_snake_case						:     Optional[int]				=    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_				):
																			_snake_case						:     Tuple				=    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        UpperCamelCase       (						self				):
													_snake_case						:     Optional[Any]				=    pipeline("image-to-text"      ,				model="google/pix2struct-ai2d-base"				)
													_snake_case						:     str				=    "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/ai2d-demo.jpg"
													_snake_case						:     Tuple				=    Image.open(requests.get(lowercase_      ,				stream=lowercase_				).raw				)

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

													_snake_case						:     int				=    pipe(lowercase_      ,				prompt=lowercase_				)
													self.assertEqual(lowercase_      ,				[{"generated_text": "ash cloud"}]				)

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



							@slow
							@require_tf
							def        UpperCamelCase       (						self				):
													_snake_case						:     str				=    pipeline("image-to-text"      ,				model="ydshieh/vit-gpt2-coco-en"      ,				framework="tf"				)
													_snake_case						:     List[str]				=    "./tests/fixtures/tests_samples/COCO/000000039769.png"

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

													_snake_case						:     List[Any]				=    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 "}],
													    ]      ,				)
def 					snake_case						(__lowercase						)       ->       int:

						'''simple docstring'''



						if not isinstance(__lowercase					,			__lowercase						) or number < 0:
												raise ValueError("Input must be a non-negative integer"						)

						_snake_case						:     List[Any]				=    number & ~(number - 1)
						_snake_case						:     Union[str, Any]				=    0
						while intermediate:
												intermediate >>= 1
												index += 1
						return index - 1


if __name__ == "__main__":
				import doctest

				doctest.testmod(verbose=True)