





'''simple docstring'''




import copy
from typing import Any, Dict, List, Optional, Union

import numpy as np

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


_A:					List[Any]												=				logging.get_logger(__name__)






class UpperCAmelCase							(		UpperCAmelCase_							):
    _A :			Union[str, Any]						   =       ["""input_features"""]



    def __init__(  self     ,			__A=80     ,			__A=16_000     ,			__A=160     ,			__A=30     ,			__A=400     ,			__A=0.0     ,			__A=False     ,			**__A     ,			):
     super().__init__(
         feature_size=__A     ,			sampling_rate=__A     ,			padding_value=__A     ,			return_attention_mask=__A     ,			**__A     ,			)
     __UpperCAmelCase					=   n_fft
     __UpperCAmelCase					=   hop_length
     __UpperCAmelCase					=   chunk_length
     __UpperCAmelCase					=   chunk_length * sampling_rate
     __UpperCAmelCase					=   self.n_samples // hop_length
     __UpperCAmelCase					=   sampling_rate
     __UpperCAmelCase					=   mel_filter_bank(
         num_frequency_bins=1 + n_fft // 2     ,			num_mel_filters=__A     ,			min_frequency=0.0     ,			max_frequency=8_000.0     ,			sampling_rate=__A     ,			norm='slaney'     ,			mel_scale='slaney'     ,			)



    def 					__lowerCamelCase						(  self     ,			__A					):
     __UpperCAmelCase					=   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     ,			log_mel='log10'     ,			)
     __UpperCAmelCase					=   log_spec[:, :-1]
     __UpperCAmelCase					=   np.maximum(__A     ,			log_spec.max() - 8.0					)
     __UpperCAmelCase					=   (log_spec + 4.0) / 4.0
     return log_spec



    @staticmethod
    # Copied from transformers.models.wav2vec2.feature_extraction_wav2vec2.Wav2Vec2FeatureExtractor.zero_mean_unit_var_norm
    def 					__lowerCamelCase						(  __A     ,			__A     ,			__A = 0.0					):
     if attention_mask is not None:
      __UpperCAmelCase					=   np.array(__A     ,			np.intaa					)
      __UpperCAmelCase					=   []

      for vector, length in zip(__A     ,			attention_mask.sum(-1					)					):
       __UpperCAmelCase					=   (vector - vector[:length].mean()) / np.sqrt(vector[:length].var() + 1E-7					)
       if length < normed_slice.shape[0]:
        __UpperCAmelCase					=   padding_value

       normed_input_values.append(__A					)
     else:
      __UpperCAmelCase					=   [(x - x.mean()) / np.sqrt(x.var() + 1E-7					) for x in input_values]

     return normed_input_values



    def __call__(  self     ,			__A     ,			__A = True     ,			__A = None     ,			__A = None     ,			__A = None     ,			__A = "max_length"     ,			__A = None     ,			__A = None     ,			__A = None     ,			**__A     ,			):

     if sampling_rate is not None:
      if sampling_rate != self.sampling_rate:
       raise ValueError(
           f'The model corresponding to this feature extractor: {self.__class__.__name__} was trained using a'
           f' sampling rate of {self.sampling_rate}. Please make sure that the provided `raw_speech` input'
           f' was sampled 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.'					)

     __UpperCAmelCase					=   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}'					)
     __UpperCAmelCase					=   is_batched_numpy or (
         isinstance(__A     ,			(list, tuple)					) and (isinstance(raw_speech[0]     ,			(np.ndarray, tuple, list)					))
     )

     if is_batched:
      __UpperCAmelCase					=   [np.asarray([speech]     ,			dtype=np.floataa					).T for speech in raw_speech]
     elif not is_batched and not isinstance(__A     ,			np.ndarray					):
      __UpperCAmelCase					=   np.asarray(__A     ,			dtype=np.floataa					)
     elif isinstance(__A     ,			np.ndarray					) and raw_speech.dtype is np.dtype(np.floataa					):
      __UpperCAmelCase					=   raw_speech.astype(np.floataa					)

     # always return batch
     if not is_batched:
      __UpperCAmelCase					=   [np.asarray([raw_speech]					).T]

     __UpperCAmelCase					=   BatchFeature({'input_features': raw_speech}					)

     # convert into correct format for padding

     __UpperCAmelCase					=   self.pad(
         __A     ,			padding=__A     ,			max_length=max_length if max_length else self.n_samples     ,			truncation=__A     ,			pad_to_multiple_of=__A     ,			return_attention_mask=return_attention_mask or do_normalize     ,			)

     # zero-mean and unit-variance normalization
     if do_normalize:
      __UpperCAmelCase					=   self.zero_mean_unit_var_norm(
          padded_inputs['input_features']     ,			attention_mask=padded_inputs['attention_mask']     ,			padding_value=self.padding_value     ,			)
      __UpperCAmelCase					=   np.stack(padded_inputs['input_features']     ,			axis=0					)

     # make sure list is in array format
     __UpperCAmelCase					=   padded_inputs.get('input_features'					).transpose(2     ,			0     ,			1					)

     __UpperCAmelCase					=   [self._np_extract_fbank_features(__A					) for waveform in input_features[0]]

     if isinstance(input_features[0]     ,			__A					):
      __UpperCAmelCase					=   [np.asarray(__A     ,			dtype=np.floataa					) for feature in input_features]
     else:
      __UpperCAmelCase					=   input_features

     if return_attention_mask:
      # rescale from sample (48000) to feature (3000)
      __UpperCAmelCase					=   padded_inputs['attention_mask'][:, :: self.hop_length]

     if return_tensors is not None:
      __UpperCAmelCase					=   padded_inputs.convert_to_tensors(__A					)

     return padded_inputs




    def 					__lowerCamelCase						(  self					):
     __UpperCAmelCase					=   copy.deepcopy(self.__dict__					)
     __UpperCAmelCase					=   self.__class__.__name__
     if "mel_filters" in output:
      del output["mel_filters"]
     return output












'''simple docstring'''




import multiprocessing
from typing import TYPE_CHECKING, Optional, Union

from .. import Dataset, Features, config
from ..formatting import query_table
from ..packaged_modules.sql.sql import Sql
from ..utils import logging
from .abc import AbstractDatasetInputStream


if TYPE_CHECKING:
    import sqlitea

    import sqlalchemy






class UpperCAmelCase							(		UpperCAmelCase_							):



    def __init__(  self     ,			__A     ,			__A     ,			__A = None     ,			__A = None     ,			__A = False     ,			**__A     ,			):
     super().__init__(features=__A     ,			cache_dir=__A     ,			keep_in_memory=__A     ,			**__A					)
     __UpperCAmelCase					=   Sql(
         cache_dir=__A     ,			features=__A     ,			sql=__A     ,			con=__A     ,			**__A     ,			)




    def 					__lowerCamelCase						(  self					):
     __UpperCAmelCase					=   None
     __UpperCAmelCase					=   None
     __UpperCAmelCase					=   None
     __UpperCAmelCase					=   None

     self.builder.download_and_prepare(
         download_config=__A     ,			download_mode=__A     ,			verification_mode=__A     ,			base_path=__A     ,			)

     # Build dataset for splits
     __UpperCAmelCase					=   self.builder.as_dataset(
         split='train'     ,			verification_mode=__A     ,			in_memory=self.keep_in_memory					)
     return dataset






class UpperCAmelCase							:



    def __init__(  self     ,			__A     ,			__A     ,			__A     ,			__A = None     ,			__A = None     ,			**__A     ,			):
     if num_proc is not None and num_proc <= 0:
      raise ValueError(f'num_proc {num_proc} must be an integer > 0.'					)

     __UpperCAmelCase					=   dataset
     __UpperCAmelCase					=   name
     __UpperCAmelCase					=   con
     __UpperCAmelCase					=   batch_size if batch_size else config.DEFAULT_MAX_BATCH_SIZE
     __UpperCAmelCase					=   num_proc
     __UpperCAmelCase					=   to_sql_kwargs



    def 					__lowerCamelCase						(  self					):
     __UpperCAmelCase					=   self.to_sql_kwargs.pop('sql'     ,			__A					)
     __UpperCAmelCase					=   self.to_sql_kwargs.pop('con'     ,			__A					)
     __UpperCAmelCase					=   self.to_sql_kwargs.pop('index'     ,			__A					)

     __UpperCAmelCase					=   self._write(index=__A     ,			**self.to_sql_kwargs					)
     return written



    def 					__lowerCamelCase						(  self     ,			__A					):
     __UpperCAmelCase					,    __UpperCAmelCase					,    __UpperCAmelCase					=   args
     __UpperCAmelCase					=   {**to_sql_kwargs, 'if_exists': 'append'} if offset > 0 else to_sql_kwargs
     __UpperCAmelCase					=   query_table(
         table=self.dataset.data     ,			key=slice(__A     ,			offset + self.batch_size					)     ,			indices=self.dataset._indices     ,			)
     __UpperCAmelCase					=   batch.to_pandas()
     __UpperCAmelCase					=   df.to_sql(self.name     ,			self.con     ,			index=__A     ,			**__A					)
     return num_rows or len(__A					)




    def 					__lowerCamelCase						(  self     ,			__A     ,			**__A					):
     __UpperCAmelCase					=   0

     if self.num_proc is None or self.num_proc == 1:
      for offset in logging.tqdm(
          range(0     ,			len(self.dataset					)     ,			self.batch_size					)     ,			unit='ba'     ,			disable=not logging.is_progress_bar_enabled()     ,			desc='Creating SQL from Arrow format'     ,			):
       written += self._batch_sql((offset, index, to_sql_kwargs)					)
     else:
      __UpperCAmelCase					,    __UpperCAmelCase					=   len(self.dataset					), self.batch_size
      with multiprocessing.Pool(self.num_proc					) as pool:
       for num_rows in logging.tqdm(
           pool.imap(
               self._batch_sql     ,			[(offset, index, to_sql_kwargs) for offset in range(0     ,			__A     ,			__A					)]     ,			)     ,			total=(num_rows // batch_size) + 1 if num_rows % batch_size else num_rows // batch_size     ,			unit='ba'     ,			disable=not logging.is_progress_bar_enabled()     ,			desc='Creating SQL from Arrow format'     ,			):
        written += num_rows

     return written





