
"""simple docstring"""


from collections.abc import Callable
from math import pi, sqrt
from random import uniform
from statistics import mean






def 					_snake_case (						snake_case__      :   Optional[Any]   ):

	def is_in_circle(snake_case__      :   Tuple		,					snake_case__      :   Optional[int]   ) -> bool:
		A        =      sqrt((x**2) + (y**2)   )
		# Our circle has a radius of 1, so a distance
		# greater than 1 would land outside the circle.
		return distance_from_centre <= 1

	# The proportion of guesses that landed in the circle
	A        =      mean(
	    int(is_in_circle(uniform(-1.0		,					1.0   )		,					uniform(-1.0		,					1.0   )   )   )
	    for _ in range(SCREAMING_SNAKE_CASE_   )   )
	# The ratio of the area for circle to square is pi/4.
	A        =      proportion * 4
	print(F'The estimated value of pi is {pi_estimate}'   )
	print(F'The numpy value of pi is {pi}'   )
	print(F'The total error is {abs(pi - pi_estimate   )}'   )






def 					_snake_case (						snake_case__      :   Dict		,					snake_case__      :   Dict		,					snake_case__      :   Any = 0.0		,					snake_case__      :   str = 1.0		,					):
	return mean(
	    function_to_integrate(uniform(SCREAMING_SNAKE_CASE_		,					SCREAMING_SNAKE_CASE_   )   ) for _ in range(SCREAMING_SNAKE_CASE_   )   ) * (max_value - min_value)






def 					_snake_case (						snake_case__      :   Optional[Any]		,					snake_case__      :   str = 0.0		,					snake_case__      :   Optional[Any] = 1.0   ):

	def identity_function(snake_case__      :   List[Any]   ) -> float:
		return x

	A        =      area_under_curve_estimator(
	    SCREAMING_SNAKE_CASE_		,					SCREAMING_SNAKE_CASE_		,					SCREAMING_SNAKE_CASE_		,					SCREAMING_SNAKE_CASE_   )
	A        =      (max_value * max_value - min_value * min_value) / 2

	print('******************'   )
	print(F'Estimating area under y=x where x varies from {min_value} to {max_value}'   )
	print(F'Estimated value is {estimated_value}'   )
	print(F'Expected value is {expected_value}'   )
	print(F'Total error is {abs(estimated_value - expected_value   )}'   )
	print('******************'   )






def 					_snake_case (						snake_case__      :   List[str]   ):

	def function_to_integrate(snake_case__      :   int   ) -> float:
		return sqrt(4.0 - x * x   )

	A        =      area_under_curve_estimator(
	    SCREAMING_SNAKE_CASE_		,					SCREAMING_SNAKE_CASE_		,					0.0		,					2.0   )

	print('******************'   )
	print('Estimating pi using area_under_curve_estimator'   )
	print(F'Estimated value is {estimated_value}'   )
	print(F'Expected value is {pi}'   )
	print(F'Total error is {abs(estimated_value - pi   )}'   )
	print('******************'   )


if __name__ == "__main__":
		import doctest

		doctest.testmod()



# 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 ..models.whisper import WhisperForConditionalGeneration, WhisperProcessor
from .base import PipelineTool
class 	UpperCAmelCase_					(					UpperCamelCase    ):

   '''simple docstring'''




   __A :      Dict     		=		"openai/whisper-base"
   __A :      str     		=		(
       "This is a tool that transcribes an audio into text. It takes an input named `audio` and returns the "
       "transcribed text."
   )
   __A :      Any     		=		"transcriber"
   __A :      Any     		=		WhisperProcessor
   __A :      int     		=		WhisperForConditionalGeneration

   __A :      Any     		=		["audio"]
   __A :      List[str]     		=		["text"]






   def _snake_case    (		self						,				__A ):






     """simple docstring"""





     return self.pre_processor(__A						,				return_tensors="pt" ).input_features






   def _snake_case    (		self						,				__A ):






     """simple docstring"""





     return self.model.generate(inputs=__A )






   def _snake_case    (		self						,				__A ):






     """simple docstring"""





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



