



import itertools
import os
import random
import tempfile
import unittest

import numpy as np
from datasets import load_dataset

from transformers import is_speech_available
from transformers.testing_utils import check_json_file_has_correct_format, require_torch, require_torchaudio
from transformers.utils.import_utils import is_torch_available

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


if is_speech_available():
     from transformers import WhisperFeatureExtractor

if is_torch_available():
     import torch

a_    :  Dict						  =		random.Random()

def      __lowercase(						UpperCAmelCase__ , UpperCAmelCase__=1.0 , UpperCAmelCase__=None , UpperCAmelCase__=None			):


      """simple docstring"""



      if rng is None:
            lowerCamelCase             =		global_rng

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

      return values





@require_torch
@require_torchaudio
class  lowerCamelCase__	(    unittest.TestCase):
     """simple docstring"""



     def __init__(self					,      __a					,      __a=7					,      __a=4_00					,      __a=20_00					,      __a=10					,      __a=1_60					,      __a=8					,      __a=0.0					,      __a=40_00					,      __a=False					,      __a=True					,      ):






           '''simple docstring'''



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







     def     _a   (self     ):






           '''simple docstring'''



           return {
               "feature_size": self.feature_size,
               "hop_length": self.hop_length,
               "chunk_length": self.chunk_length,
               "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					,      __a=False					,      __a=False     ):






           '''simple docstring'''



           def _flatten(__a     ):
                 return list(itertools.chain(*__a     )     )

           if equal_length:
                 lowerCamelCase             =		[floats_list((self.max_seq_length, self.feature_size)     ) for _ in range(self.batch_size     )]
           else:
                 # make sure that inputs increase in size
                 lowerCamelCase             =		[
                     floats_list((x, self.feature_size)     )
                     for x in range(self.min_seq_length					,      self.max_seq_length					,      self.seq_length_diff     )
                 ]
           if numpify:
                 lowerCamelCase             =		[np.asarray(__a     ) for x in speech_inputs]
           return speech_inputs





@require_torch
@require_torchaudio
class  lowerCamelCase__	(    UpperCAmelCase_							,     unittest.TestCase):
     """simple docstring"""



     _A      =      WhisperFeatureExtractor if is_speech_available() else None







     def     _a   (self     ):






           '''simple docstring'''



           lowerCamelCase             =		WhisperFeatureExtractionTester(self     )







     def     _a   (self     ):






           '''simple docstring'''



           lowerCamelCase             =		self.feature_extraction_class(**self.feat_extract_dict     )

           with tempfile.TemporaryDirectory() as tmpdirname:
                 lowerCamelCase             =		feat_extract_first.save_pretrained(__a     )[0]
                 check_json_file_has_correct_format(__a     )
                 lowerCamelCase             =		self.feature_extraction_class.from_pretrained(__a     )

           lowerCamelCase             =		feat_extract_first.to_dict()
           lowerCamelCase             =		feat_extract_second.to_dict()
           lowerCamelCase             =		feat_extract_first.mel_filters
           lowerCamelCase             =		feat_extract_second.mel_filters
           self.assertTrue(np.allclose(__a					,      __a     )     )
           self.assertEqual(__a					,      __a     )







     def     _a   (self     ):






           '''simple docstring'''



           lowerCamelCase             =		self.feature_extraction_class(**self.feat_extract_dict     )

           with tempfile.TemporaryDirectory() as tmpdirname:
                 lowerCamelCase             =		os.path.join(__a					,      "feat_extract.json"     )
                 feat_extract_first.to_json_file(__a     )
                 lowerCamelCase             =		self.feature_extraction_class.from_json_file(__a     )

           lowerCamelCase             =		feat_extract_first.to_dict()
           lowerCamelCase             =		feat_extract_second.to_dict()
           lowerCamelCase             =		feat_extract_first.mel_filters
           lowerCamelCase             =		feat_extract_second.mel_filters
           self.assertTrue(np.allclose(__a					,      __a     )     )
           self.assertEqual(__a					,      __a     )







     def     _a   (self     ):






           '''simple docstring'''



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

           # Test feature size
           lowerCamelCase             =		feature_extractor(__a					,      padding="max_length"					,      return_tensors="np"     ).input_features
           self.assertTrue(input_features.ndim == 3     )
           self.assertTrue(input_features.shape[-1] == feature_extractor.nb_max_frames     )
           self.assertTrue(input_features.shape[-2] == feature_extractor.feature_size     )

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

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

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

           # Test truncation required
           lowerCamelCase             =		[floats_list((1, x)     )[0] for x in range(2_00					,      (feature_extractor.n_samples + 5_00)					,      2_00     )]
           lowerCamelCase             =		[np.asarray(__a     ) for speech_input in speech_inputs]

           lowerCamelCase             =		[x[: feature_extractor.n_samples] for x in speech_inputs]
           lowerCamelCase             =		[np.asarray(__a     ) for speech_input in speech_inputs_truncated]

           lowerCamelCase             =		feature_extractor(__a					,      return_tensors="np"     ).input_features
           lowerCamelCase             =		feature_extractor(__a					,      return_tensors="np"     ).input_features
           for enc_seq_a, enc_seq_a in zip(__a					,      __a     ):
                 self.assertTrue(np.allclose(__a					,      __a					,      atol=1E-3     )     )







     def     _a   (self     ):






           '''simple docstring'''



           import torch

           lowerCamelCase             =		self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()     )
           lowerCamelCase             =		np.random.rand(1_00					,      32     ).astype(np.floataa     )
           lowerCamelCase             =		np_speech_inputs.tolist()

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







     def     _a   (self					,      __a     ):






           '''simple docstring'''



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

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







     def     _a   (self     ):






           '''simple docstring'''



           lowerCamelCase             =		torch.tensor(
               [
                   0.1193, -0.0946, -0.1098, -0.0196, 0.0225, -0.0690, -0.1736, 0.0951,
                   0.0971, -0.0817, -0.0702, 0.0162, 0.0260, 0.0017, -0.0192, -0.1678,
                   0.0709, -0.1867, -0.0655, -0.0274, -0.0234, -0.1884, -0.0516, -0.0554,
                   -0.0274, -0.1425, -0.1423, 0.0837, 0.0377, -0.0854
               ]     )
           # fmt: on

           lowerCamelCase             =		self._load_datasamples(1     )
           lowerCamelCase             =		WhisperFeatureExtractor()
           lowerCamelCase             =		feature_extractor(__a					,      return_tensors="pt"     ).input_features
           self.assertEqual(input_features.shape					,      (1, 80, 30_00)     )
           self.assertTrue(torch.allclose(input_features[0, 0, :30]					,      __a					,      atol=1E-4     )     )







     def     _a   (self     ):






           '''simple docstring'''



           lowerCamelCase             =		self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()     )
           lowerCamelCase             =		self._load_datasamples(1     )[0]
           lowerCamelCase             =		((audio - audio.min()) / (audio.max() - audio.min())) * 6_55_35  # Rescale to [0, 65535] to show issue
           lowerCamelCase             =		feat_extract.zero_mean_unit_var_norm([audio]					,      attention_mask=__a     )[0]

           self.assertTrue(np.all(np.mean(__a     ) < 1E-3     )     )
           self.assertTrue(np.all(np.abs(np.var(__a     ) - 1     ) < 1E-3     )     )




from __future__ import annotations

def      __lowercase(						UpperCAmelCase__			):


      """simple docstring"""



      lowerCamelCase             =		2
      lowerCamelCase             =		[]
      while i * i <= n:
            if n % i:
                  i += 1
            else:
                  n //= i
                  factors.append(UpperCAmelCase__			)
      if n > 1:
            factors.append(UpperCAmelCase__			)
      return factors


if __name__ == "__main__":
     import doctest

     doctest.testmod()