



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

import numpy as np

from transformers import BatchFeature, SpeechTaFeatureExtractor
from transformers.testing_utils import require_torch
from transformers.utils.import_utils import is_torch_available

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


if is_torch_available():
       import torch


UpperCAmelCase						:		int			= random.Random()


def 			_SCREAMING_SNAKE_CASE						(__lowerCAmelCase ,  __lowerCAmelCase=1.0 ,  __lowerCAmelCase=None ,  __lowerCAmelCase=None							) ->						int:







  '''simple docstring'''


  if rng is None:
    lowercase_								= global_rng

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

  return values


@require_torch
class    SCREAMING_SNAKE_CASE__ (							unittest.TestCase   ):

    def __init__(				self			:				Dict ,  lowerCAmelCase_			:				List[Any] ,  lowerCAmelCase_			:				List[str]=7 ,  lowerCAmelCase_			:				Any=4_0_0 ,  lowerCAmelCase_			:				Tuple=2_0_0_0 ,  lowerCAmelCase_			:				List[str]=1 ,  lowerCAmelCase_			:				List[Any]=0.0 ,  lowerCAmelCase_			:				Tuple=1_6_0_0_0 ,  lowerCAmelCase_			:				Union[str, Any]=True ,  lowerCAmelCase_			:				str=8_0 ,  lowerCAmelCase_			:				List[str]=1_6 ,  lowerCAmelCase_			:				List[str]=6_4 ,  lowerCAmelCase_			:				Optional[Any]="hann_window" ,  lowerCAmelCase_			:				Tuple=8_0 ,  lowerCAmelCase_			:				str=7_6_0_0 ,  lowerCAmelCase_			:				Any=1E-10 ,  lowerCAmelCase_			:				int=True ,  ):







      """simple docstring"""







      lowercase_								= parent
      lowercase_								= batch_size
      lowercase_								= min_seq_length
      lowercase_								= max_seq_length
      lowercase_								= (self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
      lowercase_								= feature_size
      lowercase_								= padding_value
      lowercase_								= sampling_rate
      lowercase_								= do_normalize
      lowercase_								= num_mel_bins
      lowercase_								= hop_length
      lowercase_								= win_length
      lowercase_								= win_function
      lowercase_								= fmin
      lowercase_								= fmax
      lowercase_								= mel_floor
      lowercase_								= return_attention_mask

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







      """simple docstring"""







      return {
          "feature_size": self.feature_size,
          "padding_value": self.padding_value,
          "sampling_rate": self.sampling_rate,
          "do_normalize": self.do_normalize,
          "num_mel_bins": self.num_mel_bins,
          "hop_length": self.hop_length,
          "win_length": self.win_length,
          "win_function": self.win_function,
          "fmin": self.fmin,
          "fmax": self.fmax,
          "mel_floor": self.mel_floor,
          "return_attention_mask": self.return_attention_mask,
      }

    def 					_UpperCAmelCase	(				self			:				Dict ,  lowerCAmelCase_			:				List[Any]=False ,  lowerCAmelCase_			:				Union[str, Any]=False):







      """simple docstring"""







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

      if equal_length:
        lowercase_								= floats_list((self.batch_size, self.max_seq_length))
      else:
        # make sure that inputs increase in size
        lowercase_								= [
            _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:
        lowercase_								= [np.asarray(lowerCAmelCase_) for x in speech_inputs]

      return speech_inputs




    def 					_UpperCAmelCase	(				self			:				Dict ,  lowerCAmelCase_			:				str=False ,  lowerCAmelCase_			:				str=False):







      """simple docstring"""







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

      if numpify:
        lowercase_								= [np.asarray(lowerCAmelCase_) for x in speech_inputs]

      return speech_inputs







@require_torch
class    SCREAMING_SNAKE_CASE__ (							__UpperCAmelCase      ,  unittest.TestCase   ):
    lowercase__      =   SpeechTaFeatureExtractor

    def 					_UpperCAmelCase	(				self			:				Any):







      """simple docstring"""







      lowercase_								= SpeechTaFeatureExtractionTester(self)

    def 					_UpperCAmelCase	(				self			:				List[Any] ,  lowerCAmelCase_			:				Optional[int]):







      """simple docstring"""







      self.assertTrue(np.all(np.mean(lowerCAmelCase_ ,  axis=0) < 1E-3))
      self.assertTrue(np.all(np.abs(np.var(lowerCAmelCase_ ,  axis=0) - 1) < 1E-3))

    def 					_UpperCAmelCase	(				self			:				int):







      """simple docstring"""







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

      # Test not batched input
      lowercase_								= feat_extract(speech_inputs[0] ,  return_tensors="""np""").input_values
      lowercase_								= feat_extract(np_speech_inputs[0] ,  return_tensors="""np""").input_values
      self.assertTrue(np.allclose(lowerCAmelCase_ ,  lowerCAmelCase_ ,  atol=1E-3))

      # Test batched
      lowercase_								= feat_extract(lowerCAmelCase_ ,  return_tensors="""np""").input_values
      lowercase_								= feat_extract(lowerCAmelCase_ ,  return_tensors="""np""").input_values
      for enc_seq_a, enc_seq_a in zip(lowerCAmelCase_ ,  lowerCAmelCase_):
        self.assertTrue(np.allclose(lowerCAmelCase_ ,  lowerCAmelCase_ ,  atol=1E-3))

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







      """simple docstring"""







      lowercase_								= self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict())
      lowercase_								= [floats_list((1, x))[0] for x in range(8_0_0 ,  1_4_0_0 ,  2_0_0)]

      lowercase_								= ["""longest""", """max_length""", """do_not_pad"""]
      lowercase_								= [None, 1_6_0_0, None]
      for max_length, padding in zip(lowerCAmelCase_ ,  lowerCAmelCase_):
        lowercase_								= feat_extract(lowerCAmelCase_ ,  padding=lowerCAmelCase_ ,  max_length=lowerCAmelCase_ ,  return_tensors="""np""")
        lowercase_								= processed.input_values

        self._check_zero_mean_unit_variance(input_values[0][:8_0_0])
        self.assertTrue(input_values[0][8_0_0:].sum() < 1E-6)
        self._check_zero_mean_unit_variance(input_values[1][:1_0_0_0])
        self.assertTrue(input_values[0][1_0_0_0:].sum() < 1E-6)
        self._check_zero_mean_unit_variance(input_values[2][:1_2_0_0])

    def 					_UpperCAmelCase	(				self			:				List[str]):







      """simple docstring"""







      lowercase_								= self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict())
      lowercase_								= range(8_0_0 ,  1_4_0_0 ,  2_0_0)
      lowercase_								= [floats_list((1, x))[0] for x in lengths]

      lowercase_								= ["""longest""", """max_length""", """do_not_pad"""]
      lowercase_								= [None, 1_6_0_0, None]

      for max_length, padding in zip(lowerCAmelCase_ ,  lowerCAmelCase_):
        lowercase_								= feat_extract(lowerCAmelCase_ ,  max_length=lowerCAmelCase_ ,  padding=lowerCAmelCase_)
        lowercase_								= processed.input_values

        self._check_zero_mean_unit_variance(input_values[0][:8_0_0])
        self._check_zero_mean_unit_variance(input_values[1][:1_0_0_0])
        self._check_zero_mean_unit_variance(input_values[2][:1_2_0_0])

    def 					_UpperCAmelCase	(				self			:				str):







      """simple docstring"""







      lowercase_								= self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict())
      lowercase_								= [floats_list((1, x))[0] for x in range(8_0_0 ,  1_4_0_0 ,  2_0_0)]
      lowercase_								= feat_extract(
          lowerCAmelCase_ ,  truncation=lowerCAmelCase_ ,  max_length=1_0_0_0 ,  padding="""max_length""" ,  return_tensors="""np""")
      lowercase_								= processed.input_values

      self._check_zero_mean_unit_variance(input_values[0, :8_0_0])
      self._check_zero_mean_unit_variance(input_values[1])
      self._check_zero_mean_unit_variance(input_values[2])

    def 					_UpperCAmelCase	(				self			:				List[Any]):







      """simple docstring"""







      lowercase_								= self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict())
      lowercase_								= [floats_list((1, x))[0] for x in range(8_0_0 ,  1_4_0_0 ,  2_0_0)]
      lowercase_								= feat_extract(
          lowerCAmelCase_ ,  truncation=lowerCAmelCase_ ,  max_length=1_0_0_0 ,  padding="""longest""" ,  return_tensors="""np""")
      lowercase_								= processed.input_values

      self._check_zero_mean_unit_variance(input_values[0, :8_0_0])
      self._check_zero_mean_unit_variance(input_values[1, :1_0_0_0])
      self._check_zero_mean_unit_variance(input_values[2])

      # make sure that if max_length < longest -> then pad to max_length
      self.assertTrue(input_values.shape == (3, 1_0_0_0))

      lowercase_								= [floats_list((1, x))[0] for x in range(8_0_0 ,  1_4_0_0 ,  2_0_0)]
      lowercase_								= feat_extract(
          lowerCAmelCase_ ,  truncation=lowerCAmelCase_ ,  max_length=2_0_0_0 ,  padding="""longest""" ,  return_tensors="""np""")
      lowercase_								= processed.input_values

      self._check_zero_mean_unit_variance(input_values[0, :8_0_0])
      self._check_zero_mean_unit_variance(input_values[1, :1_0_0_0])
      self._check_zero_mean_unit_variance(input_values[2])

      # make sure that if max_length > longest -> then pad to longest
      self.assertTrue(input_values.shape == (3, 1_2_0_0))

    def 					_UpperCAmelCase	(				self			:				Dict):







      """simple docstring"""







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

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

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







      """simple docstring"""







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

      # Test feature size
      lowercase_								= feature_extractor(audio_target=lowerCAmelCase_ ,  padding=lowerCAmelCase_ ,  return_tensors="""np""").input_values
      self.assertTrue(input_values.ndim == 3)
      self.assertTrue(input_values.shape[-1] == feature_extractor.num_mel_bins)

      # Test not batched input
      lowercase_								= feature_extractor(speech_inputs[0] ,  return_tensors="""np""").input_values
      lowercase_								= feature_extractor(np_speech_inputs[0] ,  return_tensors="""np""").input_values
      self.assertTrue(np.allclose(lowerCAmelCase_ ,  lowerCAmelCase_ ,  atol=1E-3))

      # Test batched
      lowercase_								= feature_extractor(lowerCAmelCase_ ,  return_tensors="""np""").input_values
      lowercase_								= feature_extractor(lowerCAmelCase_ ,  return_tensors="""np""").input_values
      for enc_seq_a, enc_seq_a in zip(lowerCAmelCase_ ,  lowerCAmelCase_):
        self.assertTrue(np.allclose(lowerCAmelCase_ ,  lowerCAmelCase_ ,  atol=1E-3))

      # Test 2-D numpy arrays are batched.
      lowercase_								= [floats_list((1, x))[0] for x in (8_0_0, 8_0_0, 8_0_0)]
      lowercase_								= np.asarray(lowerCAmelCase_)
      lowercase_								= feature_extractor(lowerCAmelCase_ ,  return_tensors="""np""").input_values
      lowercase_								= feature_extractor(lowerCAmelCase_ ,  return_tensors="""np""").input_values
      for enc_seq_a, enc_seq_a in zip(lowerCAmelCase_ ,  lowerCAmelCase_):
        self.assertTrue(np.allclose(lowerCAmelCase_ ,  lowerCAmelCase_ ,  atol=1E-3))

    def 					_UpperCAmelCase	(				self			:				List[Any]):







      """simple docstring"""







      lowercase_								= self.feat_extract_tester.prepare_inputs_for_target()
      lowercase_								= self.feature_extraction_class(**self.feat_extract_dict)
      lowercase_								= feat_extract.model_input_names[0]

      lowercase_								= BatchFeature({input_name: speech_inputs})

      self.assertTrue(all(len(lowerCAmelCase_) == len(lowerCAmelCase_) for x, y in zip(lowerCAmelCase_ ,  processed_features[input_name])))

      lowercase_								= self.feat_extract_tester.prepare_inputs_for_target(equal_length=lowerCAmelCase_)
      lowercase_								= BatchFeature({input_name: speech_inputs} ,  tensor_type="""np""")

      lowercase_								= processed_features[input_name]

      if len(batch_features_input.shape) < 3:
        lowercase_								= batch_features_input[:, :, None]

      self.assertTrue(
          batch_features_input.shape
          == (self.feat_extract_tester.batch_size, len(speech_inputs[0]), self.feat_extract_tester.num_mel_bins))

    @require_torch
    def 					_UpperCAmelCase	(				self			:				int):







      """simple docstring"""







      lowercase_								= self.feat_extract_tester.prepare_inputs_for_target(equal_length=lowerCAmelCase_)
      lowercase_								= self.feature_extraction_class(**self.feat_extract_dict)
      lowercase_								= feat_extract.model_input_names[0]

      lowercase_								= BatchFeature({input_name: speech_inputs} ,  tensor_type="""pt""")

      lowercase_								= processed_features[input_name]

      if len(batch_features_input.shape) < 3:
        lowercase_								= batch_features_input[:, :, None]

      self.assertTrue(
          batch_features_input.shape
          == (self.feat_extract_tester.batch_size, len(speech_inputs[0]), self.feat_extract_tester.num_mel_bins))

    @require_torch
    def 					_UpperCAmelCase	(				self			:				List[Any]):







      """simple docstring"""







      lowercase_								= self.feature_extraction_class(**self.feat_extract_dict)
      lowercase_								= self.feat_extract_tester.prepare_inputs_for_target()
      lowercase_								= feat_extract.model_input_names[0]

      lowercase_								= BatchFeature({input_name: speech_inputs})

      lowercase_								= feat_extract.num_mel_bins  # hack!

      lowercase_								= feat_extract.pad(lowerCAmelCase_ ,  padding="""longest""" ,  return_tensors="""np""")[input_name]
      lowercase_								= feat_extract.pad(lowerCAmelCase_ ,  padding="""longest""" ,  return_tensors="""pt""")[input_name]

      self.assertTrue(abs(input_np.astype(np.floataa).sum() - input_pt.numpy().astype(np.floataa).sum()) < 1E-2)

    def 					_UpperCAmelCase	(				self			:				int):







      """simple docstring"""







      lowercase_								= self.feat_extract_dict
      lowercase_								= True
      lowercase_								= self.feature_extraction_class(**lowerCAmelCase_)
      lowercase_								= self.feat_extract_tester.prepare_inputs_for_target()
      lowercase_								= [len(lowerCAmelCase_) for x in speech_inputs]
      lowercase_								= feat_extract.model_input_names[0]

      lowercase_								= BatchFeature({input_name: speech_inputs})

      lowercase_								= feat_extract.num_mel_bins  # hack!

      lowercase_								= feat_extract.pad(lowerCAmelCase_ ,  padding="""longest""" ,  return_tensors="""np""")
      self.assertIn("""attention_mask""" ,  lowerCAmelCase_)
      self.assertListEqual(list(processed.attention_mask.shape) ,  list(processed[input_name].shape[:2]))
      self.assertListEqual(processed.attention_mask.sum(-1).tolist() ,  lowerCAmelCase_)

    def 					_UpperCAmelCase	(				self			:				str):







      """simple docstring"""







      lowercase_								= self.feat_extract_dict
      lowercase_								= True
      lowercase_								= self.feature_extraction_class(**lowerCAmelCase_)
      lowercase_								= self.feat_extract_tester.prepare_inputs_for_target()
      lowercase_								= [len(lowerCAmelCase_) for x in speech_inputs]
      lowercase_								= feat_extract.model_input_names[0]

      lowercase_								= BatchFeature({input_name: speech_inputs})
      lowercase_								= min(lowerCAmelCase_)

      lowercase_								= feat_extract.num_mel_bins  # hack!

      lowercase_								= feat_extract.pad(
          lowerCAmelCase_ ,  padding="""max_length""" ,  max_length=lowerCAmelCase_ ,  truncation=lowerCAmelCase_ ,  return_tensors="""np""")
      self.assertIn("""attention_mask""" ,  lowerCAmelCase_)
      self.assertListEqual(
          list(processed_pad.attention_mask.shape) ,  [processed_pad[input_name].shape[0], max_length])
      self.assertListEqual(
          processed_pad.attention_mask[:, :max_length].sum(-1).tolist() ,  [max_length for x in speech_inputs])

    def 					_UpperCAmelCase	(				self			:				int ,  lowerCAmelCase_			:				List[str]):







      """simple docstring"""







      from datasets import load_dataset

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

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

    def 					_UpperCAmelCase	(				self			:				Any):







      """simple docstring"""







      lowercase_								= torch.tensor(
          [2.3804E-03, 2.0752E-03, 1.9836E-03, 2.1057E-03, 1.6174E-03,
           3.0518E-04, 9.1553E-05, 3.3569E-04, 9.7656E-04, 1.8311E-03,
           2.0142E-03, 2.1057E-03, 1.7395E-03, 4.5776E-04, -3.9673E-04,
           4.5776E-04, 1.0071E-03, 9.1553E-05, 4.8828E-04, 1.1597E-03,
           7.3242E-04, 9.4604E-04, 1.8005E-03, 1.8311E-03, 8.8501E-04,
           4.2725E-04, 4.8828E-04, 7.3242E-04, 1.0986E-03, 2.1057E-03])
      # fmt: on

      lowercase_								= self._load_datasamples(1)
      lowercase_								= SpeechTaFeatureExtractor()
      lowercase_								= feature_extractor(lowerCAmelCase_ ,  return_tensors="""pt""").input_values
      self.assertEquals(input_values.shape ,  (1, 9_3_6_8_0))
      self.assertTrue(torch.allclose(input_values[0, :3_0] ,  lowerCAmelCase_ ,  atol=1E-6))




    def 					_UpperCAmelCase	(				self			:				List[Any]):







      """simple docstring"""







      lowercase_								= torch.tensor(
          [-2.6_870, -3.0_104, -3.1_356, -3.5_352, -3.0_044, -3.0_353, -3.4_719, -3.6_777,
           -3.1_520, -2.9_435, -2.6_553, -2.8_795, -2.9_944, -2.5_921, -3.0_279, -3.0_386,
           -3.0_864, -3.1_291, -3.2_353, -2.7_444, -2.6_831, -2.7_287, -3.1_761, -3.1_571,
           -3.2_726, -3.0_582, -3.1_007, -3.4_533, -3.4_695, -3.0_998])
      # fmt: on

      lowercase_								= self._load_datasamples(1)
      lowercase_								= SpeechTaFeatureExtractor()
      lowercase_								= feature_extractor(audio_target=lowerCAmelCase_ ,  return_tensors="""pt""").input_values
      self.assertEquals(input_values.shape ,  (1, 3_6_6, 8_0))
      self.assertTrue(torch.allclose(input_values[0, 0, :3_0] ,  lowerCAmelCase_ ,  atol=1E-4))






"""simple docstring"""
from typing import List

import datasets
from datasets.tasks import AudioClassification

from ..folder_based_builder import folder_based_builder


UpperCAmelCase						:		Union[str, Any]			= datasets.utils.logging.get_logger(__name__)


class    SCREAMING_SNAKE_CASE__ (							folder_based_builder.FolderBasedBuilderConfig   ):
    lowercase__      =   None
    lowercase__      =   None







class    SCREAMING_SNAKE_CASE__ (							folder_based_builder.FolderBasedBuilder   ):
    lowercase__      =   datasets.Audio()
    lowercase__      =   "audio"
    lowercase__      =   AudioFolderConfig
    lowercase__      =   42  # definition at the bottom of the script
    lowercase__      =   AudioClassification(audio_column="audio"      ,  label_column="label"   )







UpperCAmelCase						:		Tuple			= [
    ".aiff",
    ".au",
    ".avr",
    ".caf",
    ".flac",
    ".htk",
    ".svx",
    ".mat4",
    ".mat5",
    ".mpc2k",
    ".ogg",
    ".paf",
    ".pvf",
    ".raw",
    ".rf64",
    ".sd2",
    ".sds",
    ".ircam",
    ".voc",
    ".w64",
    ".wav",
    ".nist",
    ".wavex",
    ".wve",
    ".xi",
    ".mp3",
    ".opus",
]
UpperCAmelCase						:		Any			= AUDIO_EXTENSIONS

