




import itertools
import random
import unittest

import numpy as np

from transformers import is_speech_available
from transformers.testing_utils import require_torch, require_torchaudio

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


if is_speech_available():
     from transformers import SpeechaTextFeatureExtractor

UpperCamelCase								=					random.Random()



def 							_A       (						lowerCAmelCase_					: Optional[Any]       ,    lowerCAmelCase_					: int=1.0       ,    lowerCAmelCase_					: Union[str, Any]=None       ,    lowerCAmelCase_					: Optional[int]=None      ) ->    List[Any]:
     """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					:					List[Any]       ,     SCREAMING_SNAKE_CASE__					:					str       ,     SCREAMING_SNAKE_CASE__					:					Union[str, Any]=7       ,     SCREAMING_SNAKE_CASE__					:					List[str]=400       ,     SCREAMING_SNAKE_CASE__					:					Any=2_000       ,     SCREAMING_SNAKE_CASE__					:					Union[str, Any]=24       ,     SCREAMING_SNAKE_CASE__					:					int=24       ,     SCREAMING_SNAKE_CASE__					:					List[Any]=0.0       ,     SCREAMING_SNAKE_CASE__					:					Optional[int]=16_000       ,     SCREAMING_SNAKE_CASE__					:					Union[str, Any]=True       ,     SCREAMING_SNAKE_CASE__					:					Tuple=True       ,     )				->	Union[str, Any]:
         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__          =			feature_size
         lowerCAmelCase__          =			num_mel_bins
         lowerCAmelCase__          =			padding_value
         lowerCAmelCase__          =			sampling_rate
         lowerCAmelCase__          =			return_attention_mask
         lowerCAmelCase__          =			do_normalize


    def        a				(	self					:					Tuple       )				->	Union[str, Any]:
         return {
             "feature_size": self.feature_size,
             "num_mel_bins": self.num_mel_bins,
             "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					:					List[str]       ,     SCREAMING_SNAKE_CASE__					:					Union[str, Any]=False       ,     SCREAMING_SNAKE_CASE__					:					str=False       )				->	str:
         def _flatten(SCREAMING_SNAKE_CASE__					:					List[str]       ):
              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	(   __SCREAMING_SNAKE_CASE     ,    unittest.TestCase   ):




    """simple docstring"""

    snake_case__ =				SpeechaTextFeatureExtractor if is_speech_available() else None


    def        a				(	self					:					List[Any]       )				->	Optional[Any]:
         lowerCAmelCase__          =			SpeechaTextFeatureExtractionTester(self       )


    def        a				(	self					:					Dict       ,     SCREAMING_SNAKE_CASE__					:					Dict       )				->	List[str]:
         self.assertTrue(np.all(np.mean(_a       ,     axis=0       ) < 1e-3       )       )
         self.assertTrue(np.all(np.abs(np.var(_a       ,     axis=0       ) - 1       ) < 1e-3       )       )


    def        a				(	self					:					Optional[Any]       )				->	Union[str, Any]:
         # Tests that all call wrap to encode_plus and batch_encode_plus
         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(800       ,     1_400       ,     200       )]
         lowerCAmelCase__          =			[np.asarray(_a       ) for speech_input in speech_inputs]

         # Test feature size
         lowerCAmelCase__          =			feature_extractor(_a       ,     padding=_a       ,     return_tensors="np"       ).input_features
         self.assertTrue(input_features.ndim == 3       )
         self.assertTrue(input_features.shape[-1] == 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 (800, 800, 800)]
         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       )       )


    def        a				(	self					:					str       )				->	Optional[Any]:
         lowerCAmelCase__          =			self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()       )
         lowerCAmelCase__          =			[floats_list((1, x)       )[0] for x in range(800       ,     1_400       ,     200       )]

         lowerCAmelCase__          =			["longest", "max_length", "do_not_pad"]
         lowerCAmelCase__          =			[None, 16, None]
         for max_length, padding in zip(_a       ,     _a       ):
              lowerCAmelCase__          =			feature_extractor(
                  _a       ,     padding=_a       ,     max_length=_a       ,     return_attention_mask=_a       )
              lowerCAmelCase__          =			inputs.input_features
              lowerCAmelCase__          =			inputs.attention_mask
              lowerCAmelCase__          =			[np.sum(_a       ) for x in attention_mask]

              self._check_zero_mean_unit_variance(input_features[0][: fbank_feat_lengths[0]]       )
              self._check_zero_mean_unit_variance(input_features[1][: fbank_feat_lengths[1]]       )
              self._check_zero_mean_unit_variance(input_features[2][: fbank_feat_lengths[2]]       )


    def        a				(	self					:					Union[str, Any]       )				->	Union[str, Any]:
         lowerCAmelCase__          =			self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()       )
         lowerCAmelCase__          =			[floats_list((1, x)       )[0] for x in range(800       ,     1_400       ,     200       )]

         lowerCAmelCase__          =			["longest", "max_length", "do_not_pad"]
         lowerCAmelCase__          =			[None, 16, None]
         for max_length, padding in zip(_a       ,     _a       ):
              lowerCAmelCase__          =			feature_extractor(
                  _a       ,     max_length=_a       ,     padding=_a       ,     return_tensors="np"       ,     return_attention_mask=_a       )
              lowerCAmelCase__          =			inputs.input_features
              lowerCAmelCase__          =			inputs.attention_mask
              lowerCAmelCase__          =			[np.sum(_a       ) for x in attention_mask]

              self._check_zero_mean_unit_variance(input_features[0][: fbank_feat_lengths[0]]       )
              self.assertTrue(input_features[0][fbank_feat_lengths[0] :].sum() < 1e-6       )
              self._check_zero_mean_unit_variance(input_features[1][: fbank_feat_lengths[1]]       )
              self.assertTrue(input_features[0][fbank_feat_lengths[1] :].sum() < 1e-6       )
              self._check_zero_mean_unit_variance(input_features[2][: fbank_feat_lengths[2]]       )


    def        a				(	self					:					List[Any]       )				->	Any:
         lowerCAmelCase__          =			self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()       )
         lowerCAmelCase__          =			[floats_list((1, x)       )[0] for x in range(800       ,     1_400       ,     200       )]
         lowerCAmelCase__          =			feature_extractor(
             _a       ,     padding="max_length"       ,     max_length=4       ,     truncation=_a       ,     return_tensors="np"       ,     return_attention_mask=_a       ,     )
         lowerCAmelCase__          =			inputs.input_features
         lowerCAmelCase__          =			inputs.attention_mask
         lowerCAmelCase__          =			np.sum(attention_mask == 1       ,     axis=1       )

         self._check_zero_mean_unit_variance(input_features[0, : fbank_feat_lengths[0]]       )
         self._check_zero_mean_unit_variance(input_features[1]       )
         self._check_zero_mean_unit_variance(input_features[2]       )


    def        a				(	self					:					Optional[Any]       )				->	Union[str, Any]:
         lowerCAmelCase__          =			self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()       )
         lowerCAmelCase__          =			[floats_list((1, x)       )[0] for x in range(800       ,     1_400       ,     200       )]
         lowerCAmelCase__          =			feature_extractor(
             _a       ,     padding="longest"       ,     max_length=4       ,     truncation=_a       ,     return_tensors="np"       ,     return_attention_mask=_a       ,     )
         lowerCAmelCase__          =			inputs.input_features
         lowerCAmelCase__          =			inputs.attention_mask
         lowerCAmelCase__          =			np.sum(attention_mask == 1       ,     axis=1       )

         self._check_zero_mean_unit_variance(input_features[0, : fbank_feat_lengths[0]]       )
         self._check_zero_mean_unit_variance(input_features[1, : fbank_feat_lengths[1]]       )
         self._check_zero_mean_unit_variance(input_features[2]       )

         # make sure that if max_length < longest -> then pad to max_length
         self.assertEqual(input_features.shape       ,     (3, 4, 24)       )

         lowerCAmelCase__          =			[floats_list((1, x)       )[0] for x in range(800       ,     1_400       ,     200       )]
         lowerCAmelCase__          =			feature_extractor(
             _a       ,     padding="longest"       ,     max_length=16       ,     truncation=_a       ,     return_tensors="np"       ,     return_attention_mask=_a       ,     )
         lowerCAmelCase__          =			inputs.input_features
         lowerCAmelCase__          =			inputs.attention_mask
         lowerCAmelCase__          =			np.sum(attention_mask == 1       ,     axis=1       )

         self._check_zero_mean_unit_variance(input_features[0, : fbank_feat_lengths[0]]       )
         self._check_zero_mean_unit_variance(input_features[1, : fbank_feat_lengths[1]]       )
         self._check_zero_mean_unit_variance(input_features[2]       )

         # make sure that if max_length < longest -> then pad to max_length
         self.assertEqual(input_features.shape       ,     (3, 6, 24)       )


    def        a				(	self					:					Optional[int]       )				->	Tuple:
         import torch

         lowerCAmelCase__          =			self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()       )
         lowerCAmelCase__          =			np.random.rand(100       ,     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					:					Optional[Any]       ,     SCREAMING_SNAKE_CASE__					:					Optional[int]       )				->	List[Any]:
         from datasets import load_dataset

         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					:					Dict       )				->	Optional[int]:
         # fmt: off
         lowerCAmelCase__          =			np.array([
             -1.5_745, -1.7_713, -1.7_020, -1.6_069, -1.2_250, -1.1_105, -0.9_072, -0.8_241,
             -1.2_310, -0.8_098, -0.3_320, -0.4_101, -0.7_985, -0.4_996, -0.8_213, -0.9_128,
             -1.0_420, -1.1_286, -1.0_440, -0.7_999, -0.8_405, -1.2_275, -1.5_443, -1.4_625,
         ]       )
         # fmt: on

         lowerCAmelCase__          =			self._load_datasamples(1       )
         lowerCAmelCase__          =			self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()       )
         lowerCAmelCase__          =			feature_extractor(_a       ,     return_tensors="pt"       ).input_features
         self.assertEquals(input_features.shape       ,     (1, 584, 24)       )
         self.assertTrue(np.allclose(input_features[0, 0, :30]       ,     _a       ,     atol=1e-4       )       )






def 							_A       (						lowerCAmelCase_					: int = 1000      ):
     """simple docstring"""

     return sum(2 * a * ((a - 1) // 2) for a in range(3       ,    n + 1      )      )


if __name__ == "__main__":
     print(solution())
