"""simple docstring"""



from math import ceil
from typing import List, Optional, Union

import numpy as np

from ...audio_utils import mel_filter_bank, spectrogram, window_function
from ...feature_extraction_sequence_utils import BatchFeature, SequenceFeatureExtractor
from ...utils import TensorType, logging


__lowercase		:		str														=							logging.get_logger(__name__)



class      _A	(						_UpperCAmelCase					):




    """simple docstring"""




    UpperCamelCase_	:					Any							=					['''audio_values''', '''audio_mask''']
    def __init__(		self							:     str	,      A_							:     Optional[int]=2_048	,      A_							:     Optional[Any]=1	,      A_							:     Dict=[16, 16]	,      A_							:     List[Any]=128	,      A_							:     Tuple=44_100	,      A_							:     Tuple=86	,      A_							:     Dict=2_048	,      A_							:     List[str]=0.0	,      **A_							:     List[str]	,      )    ->       Dict:
         super().__init__(
             feature_size=A_	,      sampling_rate=A_	,      padding_value=A_	,      **A_	,      )

         __snake_case				=							spectrogram_length
         __snake_case				=							num_channels
         __snake_case				=							patch_size
         __snake_case				=							feature_size // self.patch_size[1]
         __snake_case				=							n_fft
         __snake_case				=							sampling_rate // hop_length_to_sampling_rate
         __snake_case				=							sampling_rate
         __snake_case				=							padding_value
         __snake_case				=							mel_filter_bank(
             num_frequency_bins=1 + n_fft // 2	,      num_mel_filters=A_	,      min_frequency=0.0	,      max_frequency=22_050.0	,      sampling_rate=A_	,      norm='''slaney'''	,      mel_scale='''slaney'''	,      ).T
    def  lowercase					(		self							:     Optional[int]	,      A_							:     np.array    )    ->       np.ndarray:
         __snake_case				=							spectrogram(
             A_	,      window_function(self.n_fft	,      '''hann'''    )	,      frame_length=self.n_fft	,      hop_length=self.hop_length	,      power=2.0	,      mel_filters=self.mel_filters.T	,      log_mel='''dB'''	,      db_range=80.0	,      )
         __snake_case				=							log_spec[:, :-1]
         __snake_case				=							log_spec - 20.0
         __snake_case				=							np.clip(log_spec / 40.0	,      -2.0	,      0.0    ) + 1.0
         return log_spec







    def __call__(		self							:     List[str]	,      A_							:     Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]]	,      A_							:     Optional[Union[str, TensorType]] = None	,      A_							:     Optional[bool] = True	,      A_							:     Optional[int] = None	,      A_							:     bool = False	,      A_							:     bool = False	,      **A_							:     Union[str, Any]	,      )    ->       BatchFeature:

         if sampling_rate is not None:
              if sampling_rate != self.sampling_rate:
                   raise ValueError(
                       '''This feature extractor is set to support sampling rate'''
                       f" of {self.sampling_rate}. Please make sure that the provided `raw_speech` input was sampled"
                       f" with {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.'''    )

         __snake_case				=							isinstance(A_	,      np.ndarray    ) and len(raw_speech.shape    ) > 1
         if is_batched_numpy and len(raw_speech.shape    ) > 2:
              raise ValueError(f"Only mono-channel audio is supported for input to {self}"    )
         __snake_case				=							is_batched_numpy or (
             isinstance(A_	,      (list, tuple)    ) and (isinstance(raw_speech[0]	,      (np.ndarray, tuple, list)    ))
         )
         if is_batched:
              __snake_case				=							[np.asarray([speech]	,      dtype=np.floataa    ).T for speech in raw_speech]
         elif not is_batched and not isinstance(A_	,      np.ndarray    ):
              __snake_case				=							np.asarray(A_	,      dtype=np.floataa    )
         elif isinstance(A_	,      np.ndarray    ) and raw_speech.dtype is np.dtype(np.floataa    ):
              __snake_case				=							raw_speech.astype(np.floataa    )
         # always return batch
         if not is_batched:
              __snake_case				=							[np.asarray([raw_speech]    ).T]

         # Convert audio signals to log mel spectrograms, truncate by time axis
         __snake_case				=							[
             self._np_extract_fbank_features(waveform.squeeze()    ).T[: self.spectrogram_length] for waveform in raw_speech
         ]
         if isinstance(audio_features[0]	,      A_    ):
              __snake_case				=							[np.asarray(A_	,      dtype=np.floataa    ) for feature in audio_features]

         # Create audio attention mask
         __snake_case				=							max(
             [ceil(feature.shape[0] / self.patch_size[0]    ) * self.freq_len for feature in audio_features]    )  # The maximum number of audio patches in a batch
         if return_attention_mask:
              __snake_case				=							[
                  (ceil(feature.shape[0] / self.patch_size[0]    ) * self.freq_len) * [1]
                  + (max_patch_len - ceil(feature.shape[0] / self.patch_size[0]    ) * self.freq_len) * [0]
                  for feature in audio_features
              ]
              __snake_case				=							np.array(A_    ).astype(np.floataa    )

         # convert into correct format for padding
         __snake_case				=							max_patch_len // self.freq_len * self.patch_size[0]  # The maximum audio size in a batch
         __snake_case				=							np.ones([len(A_    ), 1, max_time_len, self.feature_size]    ).astype(np.floataa    )
         __snake_case				=							padded_audio_features * self.padding_value
         for i in range(len(A_    )    ):
              __snake_case				=							audio_features[i]
              __snake_case				=							feature

         # return as BatchFeature
         if return_attention_mask:
              __snake_case				=							{'''audio_values''': padded_audio_features, '''audio_mask''': audio_mask}
         else:
              __snake_case				=							{'''audio_values''': padded_audio_features}

         __snake_case				=							BatchFeature(data=A_	,      tensor_type=A_    )
         return encoded_inputs
"""simple docstring"""



from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_torch_available,
)


__lowercase		:		Optional[Any]														=							{
    "configuration_falcon": ["FALCON_PRETRAINED_CONFIG_ARCHIVE_MAP", "FalconConfig"],
}

try:
       if not is_torch_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       __lowercase		:		str														=							[
           "FALCON_PRETRAINED_MODEL_ARCHIVE_LIST",
           "FalconForCausalLM",
           "FalconModel",
           "FalconPreTrainedModel",
           "FalconForSequenceClassification",
           "FalconForTokenClassification",
           "FalconForQuestionAnswering",
       ]


if TYPE_CHECKING:
       from .configuration_falcon import FALCON_PRETRAINED_CONFIG_ARCHIVE_MAP, FalconConfig

       try:
              if not is_torch_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_falcon import (
                  FALCON_PRETRAINED_MODEL_ARCHIVE_LIST,
                  FalconForCausalLM,
                  FalconForQuestionAnswering,
                  FalconForSequenceClassification,
                  FalconForTokenClassification,
                  FalconModel,
                  FalconPreTrainedModel,
              )


else:
       import sys

       __lowercase		:		List[Any]														=							_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)