



"""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:
		_lowercase					:					int 		=		False


if is_vision_available():
		from PIL import Image
else:

		class 			__SCREAMING_SNAKE_CASE      :


							'''simple docstring'''





							@staticmethod
							def 						snake_case			(			*lowerCamelCase				:    Optional[int],    **lowerCamelCase				:    int	)->   Dict:
										pass

@is_pipeline_test
@require_vision
class 			__SCREAMING_SNAKE_CASE      ( unittest.TestCase  ):


					'''simple docstring'''





					_a       =				MODEL_FOR_VISION_2_SEQ_MAPPING
					_a       =				TF_MODEL_FOR_VISION_2_SEQ_MAPPING



					def 						snake_case			(			self				:    Union[str, Any],    lowerCamelCase				:    Any,    lowerCamelCase				:    Tuple,    lowerCamelCase				:    int	)->   Union[str, Any]:
								lowerCamelCase__						:						Dict						      =pipeline('''image-to-text''',    model=lowerCamelCase,    tokenizer=lowerCamelCase,    image_processor=lowerCamelCase	)
								lowerCamelCase__						:						Union[str, Any]						      =[
								    Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''	),
								    '''./tests/fixtures/tests_samples/COCO/000000039769.png''',
								]
								return pipe, examples



					def 						snake_case			(			self				:    Tuple,    lowerCamelCase				:    Tuple,    lowerCamelCase				:    Optional[Any]	)->   List[str]:
								lowerCamelCase__						:						Any						      =pipe(lowerCamelCase	)
								self.assertEqual(
								    lowerCamelCase,    [
								        [{'''generated_text''': ANY(lowerCamelCase	)}],
								        [{'''generated_text''': ANY(lowerCamelCase	)}],
								    ],    )



					@require_tf
					def 						snake_case			(			self				:    Dict	)->   Optional[Any]:
								lowerCamelCase__						:						List[str]						      =pipeline('''image-to-text''',    model='''hf-internal-testing/tiny-random-vit-gpt2''',    framework='''tf'''	)
								lowerCamelCase__						:						Dict						      ='''./tests/fixtures/tests_samples/COCO/000000039769.png'''

								lowerCamelCase__						:						Optional[Any]						      =pipe(lowerCamelCase	)
								self.assertEqual(
								    lowerCamelCase,    [
								        {
								            '''generated_text''': '''growthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthGOGO'''
								        },
								    ],    )

								lowerCamelCase__						:						Tuple						      =pipe([image, image]	)
								self.assertEqual(
								    lowerCamelCase,    [
								        [
								            {
								                '''generated_text''': '''growthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthGOGO'''
								            }
								        ],
								        [
								            {
								                '''generated_text''': '''growthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthGOGO'''
								            }
								        ],
								    ],    )

								lowerCamelCase__						:						List[str]						      =pipe(lowerCamelCase,    max_new_tokens=1	)
								self.assertEqual(
								    lowerCamelCase,    [{'''generated_text''': '''growth'''}],    )



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

								lowerCamelCase__						:						List[Any]						      =pipe(lowerCamelCase	)
								self.assertEqual(
								    lowerCamelCase,    [
								        {
								            '''generated_text''': '''growthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthGOGO'''
								        },
								    ],    )

								lowerCamelCase__						:						Any						      =pipe([image, image]	)
								self.assertEqual(
								    lowerCamelCase,    [
								        [
								            {
								                '''generated_text''': '''growthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthGOGO'''
								            }
								        ],
								        [
								            {
								                '''generated_text''': '''growthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthGOGO'''
								            }
								        ],
								    ],    )



					@require_torch
					def 						snake_case			(			self				:    Any	)->   int:
								lowerCamelCase__						:						Tuple						      =pipeline('''image-to-text''',    model='''hf-internal-testing/tiny-random-BlipForConditionalGeneration'''	)
								lowerCamelCase__						:						Dict						      ='''./tests/fixtures/tests_samples/COCO/000000039769.png'''
								lowerCamelCase__						:						List[str]						      ='''a photo of'''

								lowerCamelCase__						:						Optional[Any]						      =pipe(lowerCamelCase,    prompt=lowerCamelCase	)
								self.assertTrue(outputs[0]['''generated_text'''].startswith(lowerCamelCase	)	)



					@slow
					@require_torch
					def 						snake_case			(			self				:    Optional[int]	)->   Union[str, Any]:
								lowerCamelCase__						:						Union[str, Any]						      =pipeline('''image-to-text''',    model='''ydshieh/vit-gpt2-coco-en'''	)
								lowerCamelCase__						:						str						      ='''./tests/fixtures/tests_samples/COCO/000000039769.png'''

								lowerCamelCase__						:						Optional[int]						      =pipe(lowerCamelCase	)
								self.assertEqual(lowerCamelCase,    [{'''generated_text''': '''a cat laying on a blanket next to a cat laying on a bed '''}]	)

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

								lowerCamelCase__						:						List[Any]						      =pipe(lowerCamelCase	)
								self.assertEqual(lowerCamelCase,    [{'''generated_text''': '''a pink pokemon pokemon with a blue shirt and a blue shirt'''}]	)



					@slow
					@require_torch
					def 						snake_case			(			self				:    List[Any]	)->   Tuple:
								lowerCamelCase__						:						int						      =pipeline('''image-to-text''',    model='''microsoft/git-base-coco'''	)
								lowerCamelCase__						:						Any						      ='''https://huggingface.co/datasets/sayakpaul/sample-datasets/resolve/main/pokemon.png'''
								lowerCamelCase__						:						Any						      =Image.open(requests.get(lowerCamelCase,    stream=lowerCamelCase	).raw	)

								lowerCamelCase__						:						List[str]						      =pipe(lowerCamelCase	)
								self.assertEqual(lowerCamelCase,    [{'''generated_text''': '''a cartoon of a purple character.'''}]	)



					@slow
					@require_torch
					def 						snake_case			(			self				:    Union[str, Any]	)->   Optional[int]:
								lowerCamelCase__						:						int						      =pipeline('''image-to-text''',    model='''Salesforce/blip-image-captioning-base'''	)
								lowerCamelCase__						:						Union[str, Any]						      ='''https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/ai2d-demo.jpg'''
								lowerCamelCase__						:						Dict						      =Image.open(requests.get(lowerCamelCase,    stream=lowerCamelCase	).raw	)

								lowerCamelCase__						:						List[Any]						      ='''a photography of'''

								lowerCamelCase__						:						Union[str, Any]						      =pipe(lowerCamelCase,    prompt=lowerCamelCase	)
								self.assertEqual(lowerCamelCase,    [{'''generated_text''': '''a photography of a volcano'''}]	)

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



					@slow
					@require_torch
					def 						snake_case			(			self				:    str	)->   Dict:
								lowerCamelCase__						:						List[Any]						      =pipeline('''image-to-text''',    model='''microsoft/git-base-coco'''	)
								lowerCamelCase__						:						Optional[int]						      ='''https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/ai2d-demo.jpg'''
								lowerCamelCase__						:						Any						      =Image.open(requests.get(lowerCamelCase,    stream=lowerCamelCase	).raw	)

								lowerCamelCase__						:						Union[str, Any]						      ='''a photo of a'''

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

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

								lowerCamelCase__						:						str						      =pipe(lowerCamelCase,    prompt=lowerCamelCase	)
								self.assertEqual(lowerCamelCase,    [{'''generated_text''': '''ash cloud'''}]	)

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




					@slow
					@require_tf
					def 						snake_case			(			self				:    Dict	)->   List[str]:
								lowerCamelCase__						:						List[Any]						      =pipeline('''image-to-text''',    model='''ydshieh/vit-gpt2-coco-en''',    framework='''tf'''	)
								lowerCamelCase__						:						Optional[Any]						      ='''./tests/fixtures/tests_samples/COCO/000000039769.png'''

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

								lowerCamelCase__						:						Union[str, Any]						      =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 '''}],
								    ],    )











'''simple docstring'''


from __future__ import annotations

from collections.abc import Callable




def       A							(      _UpperCAmelCase   :				Callable[[int | float], int | float]						,_UpperCAmelCase   :				int | float						,_UpperCAmelCase   :				int | float						,_UpperCAmelCase   :				int = 1_0_0						,)  ->				float:


  '''simple docstring'''




  __lowerCAmelCase		:    Dict			     =  x_start
  __lowerCAmelCase		:    Tuple			     =  fnc(_UpperCAmelCase					)
  __lowerCAmelCase		:    Optional[int]			     =  0.0

  for _ in range(_UpperCAmelCase					):
    # Approximates small segments of curve as linear and solve
    # for trapezoidal area
    __lowerCAmelCase		:    Optional[int]			     =  (x_end - x_start) / steps + xa
    __lowerCAmelCase		:    Optional[Any]			     =  fnc(_UpperCAmelCase					)
    area += abs(fxa + fxa					) * (xa - xa) / 2

    # Increment step
    __lowerCAmelCase		:    Optional[Any]			     =  xa
    __lowerCAmelCase		:    List[Any]			     =  fxa
  return area


if __name__ == "__main__":




    def       A							(      _UpperCAmelCase   :				List[Any]					)  ->				List[Any]:


      '''simple docstring'''




      return x**3

    print("f(x) = x^3")
    print("The area between the curve, x = -10, x = 10 and the x axis is:")
    A_				     =							10
    while i <= 10_00_00:
        A_				     =							trapezoidal_area(f, -5, 5, i)
        print(F'''with {i} steps: {area}''')
        i *= 10





