

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


lowercase_             =     random.Random()
def   a   (    A__			:     Dict   ,     A__			:     List[str]=1.0   ,     A__			:     Optional[Any]=None   ,     A__			:     Dict=None  )					->   Optional[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 				__lowerCAmelCase  (      unittest.TestCase							):




  def __init__(       self							,     lowerCAmelCase							,     lowerCAmelCase=7							,     lowerCAmelCase=400							,     lowerCAmelCase=2_000							,     lowerCAmelCase=1							,     lowerCAmelCase=0.0							,     lowerCAmelCase=16_000							,     lowerCAmelCase=True							,     lowerCAmelCase=80							,     lowerCAmelCase=16							,     lowerCAmelCase=64							,     lowerCAmelCase="hann_window"							,     lowerCAmelCase=80							,     lowerCAmelCase=7_600							,     lowerCAmelCase=1e-10							,     lowerCAmelCase=True							,     )						->				Tuple:
        '''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 						A__  (       self      )						->				Dict:
        '''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 						A__  (       self							,     lowerCAmelCase=False							,     lowerCAmelCase=False      )						->				Tuple:
        '''simple docstring'''






        def _flatten(lowerCAmelCase      ):
              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 						A__  (       self							,     lowerCAmelCase=False							,     lowerCAmelCase=False      )						->				Tuple:
        '''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 				__lowerCAmelCase  (      SCREAMING_SNAKE_CASE    ,    unittest.TestCase							):
  _a		    =						SpeechTaFeatureExtractor




  def 						A__  (       self      )						->				int:
        '''simple docstring'''






        _lowercase			 =SpeechTaFeatureExtractionTester(self      )




  def 						A__  (       self							,     lowerCAmelCase      )						->				Any:
        '''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 						A__  (       self      )						->				List[str]:
        '''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(800							,     1_400							,     200      )]
        _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 						A__  (       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(800							,     1_400							,     200      )]

        _lowercase			 =['longest', 'max_length', 'do_not_pad']
        _lowercase			 =[None, 1_600, 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][:800]      )
              self.assertTrue(input_values[0][800:].sum() < 1e-6      )
              self._check_zero_mean_unit_variance(input_values[1][:1_000]      )
              self.assertTrue(input_values[0][1_000:].sum() < 1e-6      )
              self._check_zero_mean_unit_variance(input_values[2][:1_200]      )




  def 						A__  (       self      )						->				Optional[Any]:
        '''simple docstring'''






        _lowercase			 =self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()      )
        _lowercase			 =range(800							,     1_400							,     200      )
        _lowercase			 =[floats_list((1, x)      )[0] for x in lengths]

        _lowercase			 =['longest', 'max_length', 'do_not_pad']
        _lowercase			 =[None, 1_600, 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][:800]      )
              self._check_zero_mean_unit_variance(input_values[1][:1_000]      )
              self._check_zero_mean_unit_variance(input_values[2][:1_200]      )




  def 						A__  (       self      )						->				Dict:
        '''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(800							,     1_400							,     200      )]
        _lowercase			 =feat_extract(
            lowerCAmelCase							,     truncation=lowerCAmelCase							,     max_length=1_000							,     padding='max_length'							,     return_tensors='np'      )
        _lowercase			 =processed.input_values

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




  def 						A__  (       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(800							,     1_400							,     200      )]
        _lowercase			 =feat_extract(
            lowerCAmelCase							,     truncation=lowerCAmelCase							,     max_length=1_000							,     padding='longest'							,     return_tensors='np'      )
        _lowercase			 =processed.input_values

        self._check_zero_mean_unit_variance(input_values[0, :800]      )
        self._check_zero_mean_unit_variance(input_values[1, :1_000]      )
        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_000)      )

        _lowercase			 =[floats_list((1, x)      )[0] for x in range(800							,     1_400							,     200      )]
        _lowercase			 =feat_extract(
            lowerCAmelCase							,     truncation=lowerCAmelCase							,     max_length=2_000							,     padding='longest'							,     return_tensors='np'      )
        _lowercase			 =processed.input_values

        self._check_zero_mean_unit_variance(input_values[0, :800]      )
        self._check_zero_mean_unit_variance(input_values[1, :1_000]      )
        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_200)      )




  def 						A__  (       self      )						->				List[Any]:
        '''simple docstring'''






        _lowercase			 =self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()      )
        _lowercase			 =np.random.rand(100      ).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 						A__  (       self      )						->				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(800							,     1_400							,     200      )]
        _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 (800, 800, 800)]
        _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 						A__  (       self      )						->				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 						A__  (       self      )						->				List[str]:
        '''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 						A__  (       self      )						->				Optional[int]:
        '''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 						A__  (       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			 =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 						A__  (       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			 =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 						A__  (       self							,     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 						A__  (       self      )						->				List[str]:
        '''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, 93_680)      )
        self.assertTrue(torch.allclose(input_values[0, :30]							,     lowerCAmelCase							,     atol=1e-6      )      )




  def 						A__  (       self      )						->				List[str]:
        '''simple docstring'''






        _lowercase			 =torch.tensor(
            [-2.6870, -3.0104, -3.1356, -3.5352, -3.0044, -3.0353, -3.4719, -3.6777,
             -3.1520, -2.9435, -2.6553, -2.8795, -2.9944, -2.5921, -3.0279, -3.0386,
             -3.0864, -3.1291, -3.2353, -2.7444, -2.6831, -2.7287, -3.1761, -3.1571,
             -3.2726, -3.0582, -3.1007, -3.4533, -3.4695, -3.0998]      )
        # 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, 366, 80)      )
        self.assertTrue(torch.allclose(input_values[0, 0, :30]							,     lowerCAmelCase							,     atol=1e-4      )      )





def   a   (    A__			:     str   ,     A__			:     int  )					->   list[str]:





      """simple docstring"""



      return [sentence[i : i + ngram_size] for i in range(len(A__  ) - ngram_size + 1  )]


if __name__ == "__main__":
  from doctest import testmod

  testmod()


