
"""simple docstring"""




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

A__   :					Optional[Any]							=   random.Random()




def  _lowerCAmelCase		(		_UpperCamelCase ,				_UpperCamelCase=1.0 ,				_UpperCamelCase=None ,				_UpperCamelCase=None						):






  """simple docstring"""



  if rng is None:
    _lowercase:			Optional[Any]       =     global_rng

  _lowercase:			int       =     []
  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 			__magic_name__       (       unittest.TestCase ):
       def __init__(     self ,				A_ ,				A_=7 ,				A_=400 ,				A_=2000 ,				A_=24 ,				A_=24 ,				A_=0.0 ,				A_=1_6000 ,				A_=True ,				A_=True ,				)     ->	int:





         """simple docstring"""




         _lowercase:			Union[str, Any]       =     parent
         _lowercase:			int       =     batch_size
         _lowercase:			Tuple       =     min_seq_length
         _lowercase:			Optional[int]       =     max_seq_length
         _lowercase:			Union[str, Any]       =     (self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
         _lowercase:			Union[str, Any]       =     feature_size
         _lowercase:			Tuple       =     num_mel_bins
         _lowercase:			Union[str, Any]       =     padding_value
         _lowercase:			Optional[Any]       =     sampling_rate
         _lowercase:			Union[str, Any]       =     return_attention_mask
         _lowercase:			str       =     do_normalize
       def 							lowercase_							(     self       )     ->	int:





         """simple docstring"""




         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 							lowercase_							(     self ,				A_=False ,				A_=False       )     ->	Tuple:





         """simple docstring"""




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

         if equal_length:
           _lowercase:			Optional[int]       =     [floats_list((self.max_seq_length, self.feature_size)       ) for _ in range(self.batch_size       )]
         else:
           # make sure that inputs increase in size
           _lowercase:			int       =     [
               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:			Tuple       =     [np.asarray(A_       ) for x in speech_inputs]
         return speech_inputs


@require_torch
@require_torchaudio
class 			__magic_name__       (       SCREAMING_SNAKE_CASE__   ,					unittest.TestCase ):
       UpperCamelCase_   =		SpeechaTextFeatureExtractor if is_speech_available() else None
       def 							lowercase_							(     self       )     ->	Any:





         """simple docstring"""




         _lowercase:			Any       =     SpeechaTextFeatureExtractionTester(self       )
       def 							lowercase_							(     self ,				A_       )     ->	int:





         """simple docstring"""




         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 							lowercase_							(     self       )     ->	List[str]:





         """simple docstring"""




         _lowercase:			Any       =     self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()       )
         # create three inputs of length 800, 1000, and 1200
         _lowercase:			List[str]       =     [floats_list((1, x)       )[0] for x in range(800 ,				1400 ,				200       )]
         _lowercase:			Optional[Any]       =     [np.asarray(A_       ) for speech_input in speech_inputs]

         # Test feature size
         _lowercase:			List[Any]       =     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
         _lowercase:			Optional[int]       =     feature_extractor(speech_inputs[0] ,				return_tensors='''np'''       ).input_features
         _lowercase:			List[Any]       =     feature_extractor(np_speech_inputs[0] ,				return_tensors='''np'''       ).input_features
         self.assertTrue(np.allclose(A_ ,				A_ ,				atol=1E-3       )       )

         # Test batched
         _lowercase:			List[Any]       =     feature_extractor(A_ ,				return_tensors='''np'''       ).input_features
         _lowercase:			Dict       =     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.
         _lowercase:			Any       =     [floats_list((1, x)       )[0] for x in (800, 800, 800)]
         _lowercase:			Optional[int]       =     np.asarray(A_       )
         _lowercase:			int       =     feature_extractor(A_ ,				return_tensors='''np'''       ).input_features
         _lowercase:			Tuple       =     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 							lowercase_							(     self       )     ->	List[str]:





         """simple docstring"""




         _lowercase:			Any       =     self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()       )
         _lowercase:			int       =     [floats_list((1, x)       )[0] for x in range(800 ,				1400 ,				200       )]

         _lowercase:			Union[str, Any]       =     ['''longest''', '''max_length''', '''do_not_pad''']
         _lowercase:			List[str]       =     [None, 16, None]
         for max_length, padding in zip(A_ ,				A_       ):
           _lowercase:			Tuple       =     feature_extractor(
               A_ ,				padding=A_ ,				max_length=A_ ,				return_attention_mask=A_       )
           _lowercase:			Optional[Any]       =     inputs.input_features
           _lowercase:			str       =     inputs.attention_mask
           _lowercase:			Optional[Any]       =     [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 							lowercase_							(     self       )     ->	Any:





         """simple docstring"""




         _lowercase:			Any       =     self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()       )
         _lowercase:			List[str]       =     [floats_list((1, x)       )[0] for x in range(800 ,				1400 ,				200       )]

         _lowercase:			Optional[int]       =     ['''longest''', '''max_length''', '''do_not_pad''']
         _lowercase:			List[str]       =     [None, 16, None]
         for max_length, padding in zip(A_ ,				A_       ):
           _lowercase:			Tuple       =     feature_extractor(
               A_ ,				max_length=A_ ,				padding=A_ ,				return_tensors='''np''' ,				return_attention_mask=A_       )
           _lowercase:			str       =     inputs.input_features
           _lowercase:			Any       =     inputs.attention_mask
           _lowercase:			Optional[int]       =     [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 							lowercase_							(     self       )     ->	str:





         """simple docstring"""




         _lowercase:			List[Any]       =     self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()       )
         _lowercase:			Dict       =     [floats_list((1, x)       )[0] for x in range(800 ,				1400 ,				200       )]
         _lowercase:			Any       =     feature_extractor(
             A_ ,				padding='''max_length''' ,				max_length=4 ,				truncation=A_ ,				return_tensors='''np''' ,				return_attention_mask=A_ ,				)
         _lowercase:			Dict       =     inputs.input_features
         _lowercase:			Optional[Any]       =     inputs.attention_mask
         _lowercase:			int       =     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 							lowercase_							(     self       )     ->	List[Any]:





         """simple docstring"""




         _lowercase:			Tuple       =     self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()       )
         _lowercase:			Optional[Any]       =     [floats_list((1, x)       )[0] for x in range(800 ,				1400 ,				200       )]
         _lowercase:			Dict       =     feature_extractor(
             A_ ,				padding='''longest''' ,				max_length=4 ,				truncation=A_ ,				return_tensors='''np''' ,				return_attention_mask=A_ ,				)
         _lowercase:			int       =     inputs.input_features
         _lowercase:			Dict       =     inputs.attention_mask
         _lowercase:			Union[str, Any]       =     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)       )

         _lowercase:			Optional[Any]       =     [floats_list((1, x)       )[0] for x in range(800 ,				1400 ,				200       )]
         _lowercase:			Optional[int]       =     feature_extractor(
             A_ ,				padding='''longest''' ,				max_length=16 ,				truncation=A_ ,				return_tensors='''np''' ,				return_attention_mask=A_ ,				)
         _lowercase:			int       =     inputs.input_features
         _lowercase:			Tuple       =     inputs.attention_mask
         _lowercase:			Optional[Any]       =     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 							lowercase_							(     self       )     ->	Union[str, Any]:





         """simple docstring"""




         import torch

         _lowercase:			Any       =     self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()       )
         _lowercase:			List[str]       =     np.random.rand(100 ,				32       ).astype(np.floataa       )
         _lowercase:			List[str]       =     np_speech_inputs.tolist()

         for inputs in [py_speech_inputs, np_speech_inputs]:
           _lowercase:			Tuple       =     feature_extractor.pad([{'''input_features''': inputs}] ,				return_tensors='''np'''       )
           self.assertTrue(np_processed.input_features.dtype == np.floataa       )
           _lowercase:			Union[str, Any]       =     feature_extractor.pad([{'''input_features''': inputs}] ,				return_tensors='''pt'''       )
           self.assertTrue(pt_processed.input_features.dtype == torch.floataa       )
       def 							lowercase_							(     self ,				A_       )     ->	int:





         """simple docstring"""




         from datasets import load_dataset

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

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



       def 							lowercase_							(     self       )     ->	List[Any]:





         """simple docstring"""




         _lowercase:			List[Any]       =     np.array([
             -1.57_45, -1.77_13, -1.70_20, -1.60_69, -1.22_50, -1.11_05, -0.90_72, -0.82_41,
             -1.23_10, -0.80_98, -0.33_20, -0.41_01, -0.79_85, -0.49_96, -0.82_13, -0.91_28,
             -1.04_20, -1.12_86, -1.04_40, -0.79_99, -0.84_05, -1.22_75, -1.54_43, -1.46_25,
         ]       )
         # fmt: on

         _lowercase:			List[Any]       =     self._load_datasamples(1       )
         _lowercase:			Optional[int]       =     self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()       )
         _lowercase:			List[Any]       =     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       )       )


"""simple docstring"""




def  _lowerCAmelCase		(		_UpperCamelCase						):






  """simple docstring"""



  if not isinstance(_UpperCamelCase ,				_UpperCamelCase						):
    raise ValueError('''Input series is not valid, valid series - [2, 4, 6]'''						)
  if len(_UpperCamelCase						) == 0:
    raise ValueError('''Input list must be a non empty list'''						)
  if len(_UpperCamelCase						) == 1:
    return True
  _lowercase:			Any       =     series[1] - series[0]
  for index in range(len(_UpperCamelCase						) - 1						):
    if series[index + 1] - series[index] != common_diff:
      return False
  return True




def  _lowerCAmelCase		(		_UpperCamelCase						):






  """simple docstring"""



  if not isinstance(_UpperCamelCase ,				_UpperCamelCase						):
    raise ValueError('''Input series is not valid, valid series - [2, 4, 6]'''						)
  if len(_UpperCamelCase						) == 0:
    raise ValueError('''Input list must be a non empty list'''						)
  _lowercase:			Tuple       =     0
  for val in series:
    answer += val
  return answer / len(_UpperCamelCase						)


if __name__ == "__main__":
  import doctest

  doctest.testmod()
