


# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from typing import TYPE_CHECKING

from ..models.auto import AutoModelForVisionaSeq
from ..utils import requires_backends
from .base import PipelineTool


if TYPE_CHECKING:
    from PIL import Image



class      __lowerCamelCase       (a_		):
       _lowercase											=			"""Salesforce/blip-image-captioning-base"""
       _lowercase											=			(
           """This is a tool that generates a description of an image. It takes an input named `image` which should be the """
           """image to caption, and returns a text that contains the description in English."""
       )
       _lowercase											=			"""image_captioner"""
       _lowercase											=			AutoModelForVisionaSeq

       _lowercase											=			["""image"""]
       _lowercase											=			["""text"""]







       def __init__(       self:      Any,*A_:      Tuple,**A_:      Optional[int] ):






            '''simple docstring'''




            requires_backends(self,['vision'] )
            super().__init__(*_A,**_A )







       def 						snake_case_     (       self:      Union[str, Any],A_:      Dict ):






            '''simple docstring'''




            return self.pre_processor(images=_A,return_tensors='pt' )







       def 						snake_case_     (       self:      List[str],A_:      Optional[Any] ):






            '''simple docstring'''




            return self.model.generate(**_A )







       def 						snake_case_     (       self:      Dict,A_:      List[str] ):






            '''simple docstring'''




            return self.pre_processor.batch_decode(_A,skip_special_tokens=_A )[0].strip()









from __future__ import annotations

from collections.abc import Callable





def 						__SCREAMING_SNAKE_CASE  (				UpperCamelCase__			,			UpperCamelCase__			,			UpperCamelCase__			,			UpperCamelCase__ = 100			,			)  ->				float:







			'''simple docstring'''

			UpperCAmelCase   		=				x_start
			UpperCAmelCase   		=				fnc(UpperCamelCase__ )
			UpperCAmelCase   		=				0.0
			for _ in range(UpperCamelCase__ ):
						# Approximates small segments of curve as linear and solve
						# for trapezoidal area
						UpperCAmelCase   		=				(x_end - x_start) / steps + xa
						UpperCAmelCase   		=				fnc(UpperCamelCase__ )
						area += abs(fxa + fxa ) * (xa - xa) / 2
						# Increment step
						UpperCAmelCase   		=				xa
						UpperCAmelCase   		=				fxa
			return area


if __name__ == "__main__":





				def 						__SCREAMING_SNAKE_CASE  (				UpperCamelCase__ )  ->				str:







							'''simple docstring'''

							return x**3 + x**2

				print("f(x) = x^3 + x^2")
				print("The area between the curve, x = -5, x = 5 and the x axis is:")
				__A				:    List[Any]       =   10
				while i <= 100_000:
								print(F'with {i} steps: {trapezoidal_area(f, -5, 5, i)}')
								i *= 10



