




# 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     snake_case__							(_UpperCamelCase   ):
				"""simple docstring"""



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

				SCREAMING_SNAKE_CASE_       :							List[Any]							 =					["""audio"""]
				SCREAMING_SNAKE_CASE_       :							List[Any]							 =					["""text"""]





				def 							__UpperCAmelCase							(      self				:     Optional[int]					,      __lowerCamelCase				:     int							)					->     Optional[int]:
							return self.pre_processor(__lowerCamelCase					,      return_tensors="pt"							).input_features





				def 							__UpperCAmelCase							(      self				:     List[Any]					,      __lowerCamelCase				:     List[str]							)					->     Union[str, Any]:
							return self.model.generate(inputs=__lowerCamelCase							)





				def 							__UpperCAmelCase							(      self				:     str					,      __lowerCamelCase				:     Union[str, Any]							)					->     Any:
							return self.pre_processor.batch_decode(__lowerCamelCase					,      skip_special_tokens=__lowerCamelCase							)[0]













from sympy import diff, lambdify, symbols
from sympy.functions import *  # noqa: F403




def 		lowerCAmelCase_    (  __UpperCAmelCase:			str		,   __UpperCAmelCase:			complex		,   __UpperCAmelCase:			str = "x"		,   __UpperCAmelCase:			float = 10**-10		,   __UpperCAmelCase:			int = 1		,   )      ->	complex:
    UpperCamelCase__							:				Optional[int]          =      symbols(__UpperCAmelCase      )
    UpperCamelCase__							:				Dict          =      lambdify(__UpperCAmelCase		,   __UpperCAmelCase      )
    UpperCamelCase__							:				List[str]          =      lambdify(__UpperCAmelCase		,   diff(__UpperCAmelCase		,   __UpperCAmelCase      )      )

    UpperCamelCase__							:				int          =      starting_point

    while True:
        if diff_function(__UpperCAmelCase      ) != 0:
            UpperCamelCase__							:				Optional[int]          =      prev_guess - multiplicity * func(__UpperCAmelCase      ) / diff_function(
                __UpperCAmelCase      )
        else:
            raise ZeroDivisionError('''Could not find root'''      ) from None

        # Precision is checked by comparing the difference of consecutive guesses
        if abs(next_guess - prev_guess      ) < precision:
            return next_guess

        UpperCamelCase__							:				Tuple          =      next_guess


# Let's Execute
if __name__ == "__main__":
  # Find root of trigonometric function
  # Find value of pi
  print(F'''The root of sin(x) = 0 is {newton_raphson("sin(x)", 2)}''')

  # Find root of polynomial
  # Find fourth Root of 5
  print(F'''The root of x**4 - 5 = 0 is {newton_raphson("x**4 -5", 0.4 +5J)}''')

  # Find value of e
  print(
      'The root of log(y) - 1 = 0 is ',
      F'''{newton_raphson("log(y) - 1", 2, variable="y")}''',
  )

  # Exponential Roots
  print(
      'The root of exp(x) - 1 = 0 is',
      F'''{newton_raphson("exp(x) - 1", 10, precision=0.005)}''',
  )

  # Find root of cos(x)
  print(F'''The root of cos(x) = 0 is {newton_raphson("cos(x)", 0)}''')

