






"""simple docstring"""
import itertools
import random
import unittest

import numpy as np

from transformers import ASTFeatureExtractor
from transformers.testing_utils import require_torch, require_torchaudio
from transformers.utils.import_utils import is_torch_available

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


snake_case : Tuple     		=		random.Random()

if is_torch_available():
 import torch


def 							A						(				__snake_case: List[Any] ,     __snake_case: Optional[Any]=1.0 ,     __snake_case: List[str]=None ,     __snake_case: int=None  )    ->		Optional[int]:

       """simple docstring"""





       if rng is None:
              __magic_name__      				=    global_rng

       __magic_name__      				=    []
       for batch_idx in range(shape[0]  ):
              values.append([]  )
              for _ in range(shape[1]  ):
                     values[-1].append(rng.random() * scale  )

       return values



class        UpperCamelCase__ (				unittest.TestCase):







    """simple docstring"""







    def __init__(		self :	List[Any]				,    UpperCamelCase_ :	Optional[Any]				,    UpperCamelCase_ :	List[str]=7				,    UpperCamelCase_ :	List[str]=4_0_0				,    UpperCamelCase_ :	str=2_0_0_0				,    UpperCamelCase_ :	List[Any]=1				,    UpperCamelCase_ :	Optional[int]=0.0				,    UpperCamelCase_ :	Dict=1_6_0_0_0				,    UpperCamelCase_ :	Union[str, Any]=True				,    UpperCamelCase_ :	Dict=True				,    ):





           '''simple docstring'''

           __magic_name__      				=    parent
           __magic_name__      				=    batch_size
           __magic_name__      				=    min_seq_length
           __magic_name__      				=    max_seq_length
           __magic_name__      				=    (self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
           __magic_name__      				=    feature_size
           __magic_name__      				=    padding_value
           __magic_name__      				=    sampling_rate
           __magic_name__      				=    return_attention_mask
           __magic_name__      				=    do_normalize







    def 				a__			(		self :	int ):





           '''simple docstring'''

           return {
               "feature_size": self.feature_size,
               "padding_value": self.padding_value,
               "sampling_rate": self.sampling_rate,
               "return_attention_mask": self.return_attention_mask,
               "do_normalize": self.do_normalize,
           }







    def 				a__			(		self :	Any				,    UpperCamelCase_ :	Any=False				,    UpperCamelCase_ :	List[Any]=False ):





           '''simple docstring'''

           def _flatten(UpperCamelCase_ :	int ):
                  return list(itertools.chain(*UpperCamelCase_ ) )

           if equal_length:
                  __magic_name__      				=    floats_list((self.batch_size, self.max_seq_length) )
           else:
                  # make sure that inputs increase in size
                  __magic_name__      				=    [
                      _flatten(floats_list((x, self.feature_size) ) )
                      for x in range(self.min_seq_length				,    self.max_seq_length				,    self.seq_length_diff )
                  ]

           if numpify:
                  __magic_name__      				=    [np.asarray(UpperCamelCase_ ) for x in speech_inputs]

           return speech_inputs



@require_torch
@require_torchaudio
class        UpperCamelCase__ (				a_							,	unittest.TestCase):







    """simple docstring"""
    __UpperCAmelCase           = ASTFeatureExtractor







    def 				a__			(		self :	Union[str, Any] ):





           '''simple docstring'''

           __magic_name__      				=    ASTFeatureExtractionTester(self )







    def 				a__			(		self :	int ):





           '''simple docstring'''

           __magic_name__      				=    self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict() )
           # create three inputs of length 800, 1000, and 1200
           __magic_name__      				=    [floats_list((1, x) )[0] for x in range(8_0_0				,    1_4_0_0				,    2_0_0 )]
           __magic_name__      				=    [np.asarray(UpperCamelCase_ ) for speech_input in speech_inputs]

           # Test not batched input
           __magic_name__      				=    feat_extract(speech_inputs[0]				,    return_tensors='np' ).input_values
           __magic_name__      				=    feat_extract(np_speech_inputs[0]				,    return_tensors='np' ).input_values
           self.assertTrue(np.allclose(UpperCamelCase_				,    UpperCamelCase_				,    atol=1e-3 ) )

           # Test batched
           __magic_name__      				=    feat_extract(UpperCamelCase_				,    padding=UpperCamelCase_				,    return_tensors='np' ).input_values
           __magic_name__      				=    feat_extract(UpperCamelCase_				,    padding=UpperCamelCase_				,    return_tensors='np' ).input_values
           for enc_seq_a, enc_seq_a in zip(UpperCamelCase_				,    UpperCamelCase_ ):
                  self.assertTrue(np.allclose(UpperCamelCase_				,    UpperCamelCase_				,    atol=1e-3 ) )

           # Test 2-D numpy arrays are batched.
           __magic_name__      				=    [floats_list((1, x) )[0] for x in (8_0_0, 8_0_0, 8_0_0)]
           __magic_name__      				=    np.asarray(UpperCamelCase_ )
           __magic_name__      				=    feat_extract(UpperCamelCase_				,    return_tensors='np' ).input_values
           __magic_name__      				=    feat_extract(UpperCamelCase_				,    return_tensors='np' ).input_values
           for enc_seq_a, enc_seq_a in zip(UpperCamelCase_				,    UpperCamelCase_ ):
                  self.assertTrue(np.allclose(UpperCamelCase_				,    UpperCamelCase_				,    atol=1e-3 ) )







    @require_torch
    def 				a__			(		self :	Tuple ):





           '''simple docstring'''

           import torch

           __magic_name__      				=    self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict() )
           __magic_name__      				=    np.random.rand(1_0_0 ).astype(np.floataa )
           __magic_name__      				=    np_speech_inputs.tolist()

           for inputs in [py_speech_inputs, np_speech_inputs]:
                  __magic_name__      				=    feature_extractor.pad([{'input_values': inputs}]				,    return_tensors='np' )
                  self.assertTrue(np_processed.input_values.dtype == np.floataa )
                  __magic_name__      				=    feature_extractor.pad([{'input_values': inputs}]				,    return_tensors='pt' )
                  self.assertTrue(pt_processed.input_values.dtype == torch.floataa )







    def 				a__			(		self :	Any				,    UpperCamelCase_ :	List[Any] ):





           '''simple docstring'''

           from datasets import load_dataset

           __magic_name__      				=    load_dataset('hf-internal-testing/librispeech_asr_dummy'				,    'clean'				,    split='validation' )
           # automatic decoding with librispeech
           __magic_name__      				=    ds.sort('id' ).select(range(UpperCamelCase_ ) )[:num_samples]['audio']

           return [x["array"] for x in speech_samples]







    @require_torch
    def 				a__			(		self :	Dict ):





           '''simple docstring'''

           __magic_name__      				=    torch.tensor(
               [-0.9_894, -1.2_776, -0.9_066, -1.2_776, -0.9_349, -1.2_609, -1.0_386, -1.2_776,
                -1.1_561, -1.2_776, -1.2_052, -1.2_723, -1.2_190, -1.2_132, -1.2_776, -1.1_133,
                -1.1_953, -1.1_343, -1.1_584, -1.2_203, -1.1_770, -1.2_474, -1.2_381, -1.1_936,
                -0.9_270, -0.8_317, -0.8_049, -0.7_706, -0.7_565, -0.7_869] )
           # fmt: on

           __magic_name__      				=    self._load_datasamples(1 )
           __magic_name__      				=    ASTFeatureExtractor()
           __magic_name__      				=    feature_extractor(UpperCamelCase_				,    return_tensors='pt' ).input_values
           self.assertEquals(input_values.shape				,    (1, 1_0_2_4, 1_2_8) )
           self.assertTrue(torch.allclose(input_values[0, 0, :3_0]				,    UpperCamelCase_				,    atol=1e-4 ) )







"""simple docstring"""
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 : Dict     		=		logging.get_logger(__name__)



class        UpperCamelCase__ (				a_):







    """simple docstring"""
    __UpperCAmelCase           = ["""input_values""", """padding_mask"""]







    def __init__(		self :	Optional[int]				,    UpperCamelCase_ :	int = 1				,    UpperCamelCase_ :	int = 2_4_0_0_0				,    UpperCamelCase_ :	float = 0.0				,    UpperCamelCase_ :	float = None				,    UpperCamelCase_ :	float = None				,    **UpperCamelCase_ :	str				,    ):





           '''simple docstring'''

           super().__init__(feature_size=UpperCamelCase_				,    sampling_rate=UpperCamelCase_				,    padding_value=UpperCamelCase_				,    **UpperCamelCase_ )
           __magic_name__      				=    chunk_length_s
           __magic_name__      				=    overlap







    @property
    def 				a__			(		self :	List[str] ):





           '''simple docstring'''

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







    @property
    def 				a__			(		self :	Optional[Any] ):





           '''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 :	List[Any]				,    UpperCamelCase_ :	Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]]				,    UpperCamelCase_ :	Optional[Union[bool, str, PaddingStrategy]] = None				,    UpperCamelCase_ :	Optional[bool] = False				,    UpperCamelCase_ :	Optional[int] = None				,    UpperCamelCase_ :	Optional[Union[str, TensorType]] = None				,    UpperCamelCase_ :	Optional[int] = 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
                  __magic_name__      				=    True

           __magic_name__      				=    bool(
               isinstance(UpperCamelCase_				,    (list, tuple) ) and (isinstance(raw_audio[0]				,    (np.ndarray, tuple, list) )) )

           if is_batched:
                  __magic_name__      				=    [np.asarray(UpperCamelCase_				,    dtype=np.floataa ).T for audio in raw_audio]
           elif not is_batched and not isinstance(UpperCamelCase_				,    np.ndarray ):
                  __magic_name__      				=    np.asarray(UpperCamelCase_				,    dtype=np.floataa )
           elif isinstance(UpperCamelCase_				,    np.ndarray ) and raw_audio.dtype is np.dtype(np.floataa ):
                  __magic_name__      				=    raw_audio.astype(np.floataa )

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

           # verify inputs are valid
           for idx, example in enumerate(UpperCamelCase_ ):
                  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""" )

           __magic_name__      				=    None
           __magic_name__      				=    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:
                         __magic_name__      				=    min(array.shape[0] for array in raw_audio )
                         __magic_name__      				=    int(np.floor(max_length / self.chunk_stride ) )
                         __magic_name__      				=    (nb_step - 1) * self.chunk_stride + self.chunk_length
                  elif padding:
                         __magic_name__      				=    max(array.shape[0] for array in raw_audio )
                         __magic_name__      				=    int(np.ceil(max_length / self.chunk_stride ) )
                         __magic_name__      				=    (nb_step - 1) * self.chunk_stride + self.chunk_length
                         __magic_name__      				=    'max_length'
                  else:
                         __magic_name__      				=    input_values

        # normal padding on batch
           if padded_inputs is None:
                  __magic_name__      				=    self.pad(
                      UpperCamelCase_				,    max_length=UpperCamelCase_				,    truncation=UpperCamelCase_				,    padding=UpperCamelCase_				,    return_attention_mask=UpperCamelCase_				,    )
                  if padding:
                         __magic_name__      				=    padded_inputs.pop('attention_mask' )

           __magic_name__      				=    []
           for example in padded_inputs.pop('input_values' ):
                  if self.feature_size == 1:
                         __magic_name__      				=    example[..., None]
                  input_values.append(example.T )

           __magic_name__      				=    input_values
           if return_tensors is not None:
                  __magic_name__      				=    padded_inputs.convert_to_tensors(UpperCamelCase_ )

           return padded_inputs