


from ...processing_utils import ProcessorMixin


class     __UpperCAmelCase							(       __A							):


     """simple docstring"""
     _lowerCamelCase   =      """WhisperFeatureExtractor"""
     _lowerCamelCase   =      """WhisperTokenizer"""


     def __init__(	self  ,       __A  ,       __A    ):
        super().__init__(__A  ,       __A    )
        __a					=  self.feature_extractor
        __a					=  False


     def 	snake_case_  (	self  ,       __A=None  ,       __A=None  ,       __A=True    ):
        return self.tokenizer.get_decoder_prompt_ids(task=__A  ,       language=__A  ,       no_timestamps=__A    )


     def __call__(	self  ,       *__A  ,       **__A    ):
        # For backward compatibility
        if self._in_target_context_manager:
           return self.current_processor(*__A  ,       **__A    )

        __a					=  kwargs.pop("""audio"""  ,       __A    )
        __a					=  kwargs.pop("""sampling_rate"""  ,       __A    )
        __a					=  kwargs.pop("""text"""  ,       __A    )
        if len(__A    ) > 0:
           __a					=  args[0]
           __a					=  args[1:]

        if audio is None and text is None:
           raise ValueError("""You need to specify either an `audio` or `text` input to process."""    )

        if audio is not None:
           __a					=  self.feature_extractor(__A  ,       *__A  ,       sampling_rate=__A  ,       **__A    )
        if text is not None:
           __a					=  self.tokenizer(__A  ,       **__A    )

        if text is None:
           return inputs

        elif audio is None:
           return encodings
        else:
           __a					=  encodings["""input_ids"""]
           return inputs


     def 	snake_case_  (	self  ,       *__A  ,       **__A    ):
        return self.tokenizer.batch_decode(*__A  ,       **__A    )


     def 	snake_case_  (	self  ,       *__A  ,       **__A    ):
        return self.tokenizer.decode(*__A  ,       **__A    )


     def 	snake_case_  (	self  ,       __A  ,       __A="np"    ):
        return self.tokenizer.get_prompt_ids(__A  ,       return_tensors=__A    )







from collections.abc import Callable




def  a   (lowerCAmelCase__		,				lowerCAmelCase__		,				lowerCAmelCase__   ):
   __a					=  a
   __a					=  b
   if function(lowerCAmelCase__   ) == 0:  # one of the a or b is a root for the function
      return a
   elif function(lowerCAmelCase__   ) == 0:
      return b
   elif (
       function(lowerCAmelCase__   ) * function(lowerCAmelCase__   ) > 0
   ):  # if none of these are root and they are both positive or negative,
      # then this algorithm can't find the root
      raise ValueError("""could not find root in given interval."""   )
   else:
      __a					=  start + (end - start) / 2.0
      while abs(start - mid   ) > 10**-7:  # until precisely equals to 10^-7
         if function(lowerCAmelCase__   ) == 0:
            return mid
         elif function(lowerCAmelCase__   ) * function(lowerCAmelCase__   ) < 0:
            __a					=  mid
         else:
            __a					=  mid
         __a					=  start + (end - start) / 2.0
      return mid




def  a   (lowerCAmelCase__   ):
   return x**3 - 2 * x - 5


if __name__ == "__main__":
  print(bisection(f, 1, 1_0_0_0))

  import doctest

  doctest.testmod()



