






'''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

lowerCAmelCase__          =						random.Random()







def       __UpperCAmelCase						(  lowerCamelCase_     ,      lowerCamelCase_=1.0     ,      lowerCamelCase_=None     ,      lowerCamelCase_=None)							->     str:
  if rng is None:
    UpperCamelCase__				:					List[Any]					=					global_rng

  UpperCamelCase__				:					str					=					[]
  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       __lowercase					(unittest.TestCase    ):

 def __init__(      self   :						str  ,					UpperCAmelCase_   :						Union[str, Any]  ,					UpperCAmelCase_   :						Tuple=7  ,					UpperCAmelCase_   :						Any=400  ,					UpperCAmelCase_   :						List[str]=2_000  ,					UpperCAmelCase_   :						int=24  ,					UpperCAmelCase_   :						Dict=24  ,					UpperCAmelCase_   :						Tuple=0.0  ,					UpperCAmelCase_   :						Optional[int]=16_000  ,					UpperCAmelCase_   :						List[Any]=True  ,					UpperCAmelCase_   :						List[str]=True  ,					):
   UpperCamelCase__				:					Any					=					parent
   UpperCamelCase__				:					Optional[Any]					=					batch_size
   UpperCamelCase__				:					Any					=					min_seq_length
   UpperCamelCase__				:					Optional[Any]					=					max_seq_length
   UpperCamelCase__				:					int					=					(self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
   UpperCamelCase__				:					List[str]					=					feature_size
   UpperCamelCase__				:					Optional[int]					=					num_mel_bins
   UpperCamelCase__				:					Tuple					=					padding_value
   UpperCamelCase__				:					List[str]					=					sampling_rate
   UpperCamelCase__				:					Optional[Any]					=					return_attention_mask
   UpperCamelCase__				:					int					=					do_normalize

 def      __UpperCamelCase							(      self   :						Tuple):
   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      __UpperCamelCase							(      self   :						Dict  ,					UpperCAmelCase_   :						Dict=False  ,					UpperCAmelCase_   :						Any=False):
   def _flatten(UpperCAmelCase_   :						List[Any]):
     return list(itertools.chain(*UpperCAmelCase_))

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







@require_torch
@require_torchaudio
class       __lowercase					(__lowerCamelCase   ,				unittest.TestCase    ):
 _lowerCamelCase              =  SpeechaTextFeatureExtractor if is_speech_available() else None

 def      __UpperCamelCase							(      self   :						Optional[int]):
   UpperCamelCase__				:					Optional[Any]					=					SpeechaTextFeatureExtractionTester(self)

 def      __UpperCamelCase							(      self   :						str  ,					UpperCAmelCase_   :						str):
   self.assertTrue(np.all(np.mean(UpperCAmelCase_  ,					axis=0) < 1e-3))
   self.assertTrue(np.all(np.abs(np.var(UpperCAmelCase_  ,					axis=0) - 1) < 1e-3))

 def      __UpperCamelCase							(      self   :						Optional[int]):
   # Tests that all call wrap to encode_plus and batch_encode_plus
   UpperCamelCase__				:					List[Any]					=					self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict())
   # create three inputs of length 800, 1000, and 1200
   UpperCamelCase__				:					Optional[int]					=					[floats_list((1, x))[0] for x in range(800  ,					1_400  ,					200)]
   UpperCamelCase__				:					int					=					[np.asarray(UpperCAmelCase_) for speech_input in speech_inputs]

   # Test feature size
   UpperCamelCase__				:					Union[str, Any]					=					feature_extractor(UpperCAmelCase_  ,					padding=UpperCAmelCase_  ,					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
   UpperCamelCase__				:					str					=					feature_extractor(speech_inputs[0]  ,					return_tensors='np').input_features
   UpperCamelCase__				:					Optional[int]					=					feature_extractor(np_speech_inputs[0]  ,					return_tensors='np').input_features
   self.assertTrue(np.allclose(UpperCAmelCase_  ,					UpperCAmelCase_  ,					atol=1e-3))

   # Test batched
   UpperCamelCase__				:					Tuple					=					feature_extractor(UpperCAmelCase_  ,					return_tensors='np').input_features
   UpperCamelCase__				:					Optional[Any]					=					feature_extractor(UpperCAmelCase_  ,					return_tensors='np').input_features
   for enc_seq_a, enc_seq_a in zip(UpperCAmelCase_  ,					UpperCAmelCase_):
     self.assertTrue(np.allclose(UpperCAmelCase_  ,					UpperCAmelCase_  ,					atol=1e-3))

   # Test 2-D numpy arrays are batched.
   UpperCamelCase__				:					Optional[Any]					=					[floats_list((1, x))[0] for x in (800, 800, 800)]
   UpperCamelCase__				:					Dict					=					np.asarray(UpperCAmelCase_)
   UpperCamelCase__				:					str					=					feature_extractor(UpperCAmelCase_  ,					return_tensors='np').input_features
   UpperCamelCase__				:					Tuple					=					feature_extractor(UpperCAmelCase_  ,					return_tensors='np').input_features
   for enc_seq_a, enc_seq_a in zip(UpperCAmelCase_  ,					UpperCAmelCase_):
     self.assertTrue(np.allclose(UpperCAmelCase_  ,					UpperCAmelCase_  ,					atol=1e-3))

 def      __UpperCamelCase							(      self   :						Tuple):
   UpperCamelCase__				:					str					=					self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict())
   UpperCamelCase__				:					Union[str, Any]					=					[floats_list((1, x))[0] for x in range(800  ,					1_400  ,					200)]

   UpperCamelCase__				:					Union[str, Any]					=					['longest', 'max_length', 'do_not_pad']
   UpperCamelCase__				:					Tuple					=					[None, 16, None]
   for max_length, padding in zip(UpperCAmelCase_  ,					UpperCAmelCase_):
     UpperCamelCase__				:					Optional[Any]					=					feature_extractor(
         UpperCAmelCase_  ,					padding=UpperCAmelCase_  ,					max_length=UpperCAmelCase_  ,					return_attention_mask=UpperCAmelCase_)
     UpperCamelCase__				:					List[str]					=					inputs.input_features
     UpperCamelCase__				:					int					=					inputs.attention_mask
     UpperCamelCase__				:					Optional[Any]					=					[np.sum(UpperCAmelCase_) 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      __UpperCamelCase							(      self   :						Optional[int]):
   UpperCamelCase__				:					List[Any]					=					self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict())
   UpperCamelCase__				:					str					=					[floats_list((1, x))[0] for x in range(800  ,					1_400  ,					200)]

   UpperCamelCase__				:					int					=					['longest', 'max_length', 'do_not_pad']
   UpperCamelCase__				:					Union[str, Any]					=					[None, 16, None]
   for max_length, padding in zip(UpperCAmelCase_  ,					UpperCAmelCase_):
     UpperCamelCase__				:					Dict					=					feature_extractor(
         UpperCAmelCase_  ,					max_length=UpperCAmelCase_  ,					padding=UpperCAmelCase_  ,					return_tensors='np'  ,					return_attention_mask=UpperCAmelCase_)
     UpperCamelCase__				:					Optional[int]					=					inputs.input_features
     UpperCamelCase__				:					List[str]					=					inputs.attention_mask
     UpperCamelCase__				:					Dict					=					[np.sum(UpperCAmelCase_) 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      __UpperCamelCase							(      self   :						Union[str, Any]):
   UpperCamelCase__				:					List[Any]					=					self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict())
   UpperCamelCase__				:					Optional[Any]					=					[floats_list((1, x))[0] for x in range(800  ,					1_400  ,					200)]
   UpperCamelCase__				:					int					=					feature_extractor(
       UpperCAmelCase_  ,					padding='max_length'  ,					max_length=4  ,					truncation=UpperCAmelCase_  ,					return_tensors='np'  ,					return_attention_mask=UpperCAmelCase_  ,					)
   UpperCamelCase__				:					Tuple					=					inputs.input_features
   UpperCamelCase__				:					str					=					inputs.attention_mask
   UpperCamelCase__				:					Tuple					=					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      __UpperCamelCase							(      self   :						List[Any]):
   UpperCamelCase__				:					Any					=					self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict())
   UpperCamelCase__				:					str					=					[floats_list((1, x))[0] for x in range(800  ,					1_400  ,					200)]
   UpperCamelCase__				:					int					=					feature_extractor(
       UpperCAmelCase_  ,					padding='longest'  ,					max_length=4  ,					truncation=UpperCAmelCase_  ,					return_tensors='np'  ,					return_attention_mask=UpperCAmelCase_  ,					)
   UpperCamelCase__				:					int					=					inputs.input_features
   UpperCamelCase__				:					Any					=					inputs.attention_mask
   UpperCamelCase__				:					Optional[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, : 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))

   UpperCamelCase__				:					Optional[Any]					=					[floats_list((1, x))[0] for x in range(800  ,					1_400  ,					200)]
   UpperCamelCase__				:					Optional[Any]					=					feature_extractor(
       UpperCAmelCase_  ,					padding='longest'  ,					max_length=16  ,					truncation=UpperCAmelCase_  ,					return_tensors='np'  ,					return_attention_mask=UpperCAmelCase_  ,					)
   UpperCamelCase__				:					List[Any]					=					inputs.input_features
   UpperCamelCase__				:					int					=					inputs.attention_mask
   UpperCamelCase__				:					Tuple					=					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      __UpperCamelCase							(      self   :						Any):
   import torch

   UpperCamelCase__				:					Union[str, Any]					=					self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict())
   UpperCamelCase__				:					Dict					=					np.random.rand(100  ,					32).astype(np.floataa)
   UpperCamelCase__				:					Optional[int]					=					np_speech_inputs.tolist()

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

 def      __UpperCamelCase							(      self   :						Dict  ,					UpperCAmelCase_   :						Tuple):
   from datasets import load_dataset

   UpperCamelCase__				:					Tuple					=					load_dataset('hf-internal-testing/librispeech_asr_dummy'  ,					'clean'  ,					split='validation')
   # automatic decoding with librispeech
   UpperCamelCase__				:					List[str]					=					ds.sort('id').select(range(UpperCAmelCase_))[:num_samples]['audio']

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





 def      __UpperCamelCase							(      self   :						List[Any]):
   # fmt: off
   UpperCamelCase__				:					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

   UpperCamelCase__				:					List[str]					=					self._load_datasamples(1)
   UpperCamelCase__				:					str					=					self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict())
   UpperCamelCase__				:					int					=					feature_extractor(UpperCAmelCase_  ,					return_tensors='pt').input_features
   self.assertEquals(input_features.shape  ,					(1, 584, 24))
   self.assertTrue(np.allclose(input_features[0, 0, :30]  ,					UpperCAmelCase_  ,					atol=1e-4))












'''simple docstring'''




from ..utils import DummyObject, requires_backends







class       __lowercase					(metaclass=__lowerCamelCase    ):
	_lowerCamelCase              =  ['''torch''', '''scipy''']

	def __init__(      self   :						List[Any]  ,					*UpperCAmelCase_   :						Any  ,					**UpperCAmelCase_   :						int):
			requires_backends(self  ,					['torch', 'scipy'])

	@classmethod
	def      __UpperCamelCase							(      cls   :						Union[str, Any]  ,					*UpperCAmelCase_   :						Any  ,					**UpperCAmelCase_   :						List[Any]):
			requires_backends(cls  ,					['torch', 'scipy'])





	@classmethod
	def      __UpperCamelCase							(      cls   :						Union[str, Any]  ,					*UpperCAmelCase_   :						Optional[Any]  ,					**UpperCAmelCase_   :						Any):
			requires_backends(cls  ,					['torch', 'scipy'])




