


from typing import List, Optional, Union

import numpy as np

from ...feature_extraction_sequence_utils import SequenceFeatureExtractor
from ...feature_extraction_utils import BatchFeature
from ...utils import PaddingStrategy, TensorType, logging


_snake_case             =     logging.get_logger(__name__)
class 	UpperCAmelCase_					(					UpperCamelCase    ):

   '''simple docstring'''




   __A :      Tuple     		=		["input_values", "padding_mask"]






   def __init__(		self						,				__A = 1						,				__A = 2_4000						,				__A = 0.0						,				__A = None						,				__A = None						,				**__A						,				):






     """simple docstring"""





     super().__init__(feature_size=__A						,				sampling_rate=__A						,				padding_value=__A						,				**__A )
     lowerCamelCase :					List[Any]    =				chunk_length_s
     lowerCamelCase :					str    =				overlap






   @property
   def _snake_case    (		self ):






     """simple docstring"""





     if self.chunk_length_s is None:
       return None
     else:
       return int(self.chunk_length_s * self.sampling_rate )






   @property
   def _snake_case    (		self ):






     """simple docstring"""





     if self.chunk_length_s is None or self.overlap is None:
       return None
     else:
       return max(1						,				int((1.0 - self.overlap) * self.chunk_length ) )






   def __call__(		self						,				__A						,				__A = None						,				__A = False						,				__A = None						,				__A = None						,				__A = None						,				):






     """simple docstring"""





     if sampling_rate is not None:
       if sampling_rate != self.sampling_rate:
         raise ValueError(
             F"""The model corresponding to this feature extractor: {self} was trained using a sampling rate of"""
             F""" {self.sampling_rate}. Please make sure that the provided audio input was sampled with"""
             F""" {self.sampling_rate} and not {sampling_rate}.""" )
     else:
       logger.warning(
           "It is strongly recommended to pass the `sampling_rate` argument to this function. "
           "Failing to do so can result in silent errors that might be hard to debug." )

     if padding and truncation:
       raise ValueError("Both padding and truncation were set. Make sure you only set one." )
     elif padding is None:
       # by default let's pad the inputs
       lowerCamelCase :					int    =				True

     lowerCamelCase :					int    =				bool(
         isinstance(__A						,				(list, tuple) ) and (isinstance(raw_audio[0]						,				(np.ndarray, tuple, list) )) )

     if is_batched:
       lowerCamelCase :					List[Any]    =				[np.asarray(__A						,				dtype=np.floataa ).T for audio in raw_audio]
     elif not is_batched and not isinstance(__A						,				np.ndarray ):
       lowerCamelCase :					Optional[Any]    =				np.asarray(__A						,				dtype=np.floataa )
     elif isinstance(__A						,				np.ndarray ) and raw_audio.dtype is np.dtype(np.floataa ):
       lowerCamelCase :					Union[str, Any]    =				raw_audio.astype(np.floataa )

     # always return batch
     if not is_batched:
       lowerCamelCase :					List[str]    =				[np.asarray(__A ).T]

     # verify inputs are valid
     for idx, example in enumerate(__A ):
       if example.ndim > 2:
         raise ValueError(F"""Expected input shape (channels, length) but got shape {example.shape}""" )
       if self.feature_size == 1 and example.ndim != 1:
         raise ValueError(F"""Expected mono audio but example has {example.shape[-1]} channels""" )
       if self.feature_size == 2 and example.shape[-1] != 2:
         raise ValueError(F"""Expected stereo audio but example has {example.shape[-1]} channels""" )

     lowerCamelCase :					List[Any]    =				None
     lowerCamelCase :					Tuple    =				BatchFeature({"input_values": raw_audio} )
     if self.chunk_stride is not None and self.chunk_length is not None and max_length is None:
       if truncation:
         lowerCamelCase :					Optional[Any]    =				min(array.shape[0] for array in raw_audio )
         lowerCamelCase :					str    =				int(np.floor(max_length / self.chunk_stride ) )
         lowerCamelCase :					str    =				(nb_step - 1) * self.chunk_stride + self.chunk_length
       elif padding:
         lowerCamelCase :					str    =				max(array.shape[0] for array in raw_audio )
         lowerCamelCase :					Dict    =				int(np.ceil(max_length / self.chunk_stride ) )
         lowerCamelCase :					Optional[Any]    =				(nb_step - 1) * self.chunk_stride + self.chunk_length
         lowerCamelCase :					Dict    =				"max_length"
       else:
         lowerCamelCase :					Union[str, Any]    =				input_values

        # normal padding on batch
     if padded_inputs is None:
       lowerCamelCase :					str    =				self.pad(
           __A						,				max_length=__A						,				truncation=__A						,				padding=__A						,				return_attention_mask=__A						,				)
       if padding:
         lowerCamelCase :					Dict    =				padded_inputs.pop("attention_mask" )

     lowerCamelCase :					Dict    =				[]
     for example in padded_inputs.pop("input_values" ):
       if self.feature_size == 1:
         lowerCamelCase :					Any    =				example[..., None]
       input_values.append(example.T )

     lowerCamelCase :					int    =				input_values
     if return_tensors is not None:
       lowerCamelCase :					List[Any]    =				padded_inputs.convert_to_tensors(__A )

     return padded_inputs







# 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]



