


import itertools
import random
import unittest

import numpy as np

from transformers import ASTFeatureExtractor
from transformers.testing_utils import require_torch, require_torchaudio
from transformers.utils.import_utils import is_torch_available

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


UpperCAmelCase     :   List[str]    =					random.Random()

if is_torch_available():
   import torch






def  __lowerCAmelCase					(SCREAMING_SNAKE_CASE      ,      SCREAMING_SNAKE_CASE=1.0      ,      SCREAMING_SNAKE_CASE=None      ,      SCREAMING_SNAKE_CASE=None      )->						Dict:




      """simple docstring"""

      if rng is None:
            snake_case_ =   global_rng

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

      return values







class lowerCAmelCase_		(				unittest.TestCase ):

 '''simple docstring'''

 def __init__(			self	,   _UpperCAmelCase	,   _UpperCAmelCase=7	,   _UpperCAmelCase=4_00	,   _UpperCAmelCase=20_00	,   _UpperCAmelCase=1	,   _UpperCAmelCase=0.0	,   _UpperCAmelCase=1_60_00	,   _UpperCAmelCase=True	,   _UpperCAmelCase=True	,   ):
       snake_case_ =   parent
       snake_case_ =   batch_size
       snake_case_ =   min_seq_length
       snake_case_ =   max_seq_length
       snake_case_ =   (self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
       snake_case_ =   feature_size
       snake_case_ =   padding_value
       snake_case_ =   sampling_rate
       snake_case_ =   return_attention_mask
       snake_case_ =   do_normalize



 def 		UpperCamelCase__  (			self      ):
       return {
           "feature_size": self.feature_size,
           "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	,   _UpperCAmelCase=False	,   _UpperCAmelCase=False      ):
       def _flatten(_UpperCAmelCase      ):
             return list(itertools.chain(*_UpperCAmelCase      )      )

       if equal_length:
             snake_case_ =   floats_list((self.batch_size, self.max_seq_length)      )
       else:
             # make sure that inputs increase in size
             snake_case_ =   [
                 _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:
             snake_case_ =   [np.asarray(_UpperCAmelCase      ) for x in speech_inputs]

       return speech_inputs







@require_torch
@require_torchaudio
class lowerCAmelCase_		(				lowerCamelCase__      ,		unittest.TestCase ):

 '''simple docstring'''

 __snake_case				=						ASTFeatureExtractor



 def 		UpperCamelCase__  (			self      ):
       snake_case_ =   ASTFeatureExtractionTester(self      )



 def 		UpperCamelCase__  (			self      ):
       # Tests that all call wrap to encode_plus and batch_encode_plus
       snake_case_ =   self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()      )
       # create three inputs of length 800, 1000, and 1200
       snake_case_ =   [floats_list((1, x)      )[0] for x in range(8_00	,   14_00	,   2_00      )]
       snake_case_ =   [np.asarray(_UpperCAmelCase      ) for speech_input in speech_inputs]

       # Test not batched input
       snake_case_ =   feat_extract(speech_inputs[0]	,   return_tensors='''np'''      ).input_values
       snake_case_ =   feat_extract(np_speech_inputs[0]	,   return_tensors='''np'''      ).input_values
       self.assertTrue(np.allclose(_UpperCAmelCase	,   _UpperCAmelCase	,   atol=1E-3      )      )

       # Test batched
       snake_case_ =   feat_extract(_UpperCAmelCase	,   padding=_UpperCAmelCase	,   return_tensors='''np'''      ).input_values
       snake_case_ =   feat_extract(_UpperCAmelCase	,   padding=_UpperCAmelCase	,   return_tensors='''np'''      ).input_values
       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.
       snake_case_ =   [floats_list((1, x)      )[0] for x in (8_00, 8_00, 8_00)]
       snake_case_ =   np.asarray(_UpperCAmelCase      )
       snake_case_ =   feat_extract(_UpperCAmelCase	,   return_tensors='''np'''      ).input_values
       snake_case_ =   feat_extract(_UpperCAmelCase	,   return_tensors='''np'''      ).input_values
       for enc_seq_a, enc_seq_a in zip(_UpperCAmelCase	,   _UpperCAmelCase      ):
             self.assertTrue(np.allclose(_UpperCAmelCase	,   _UpperCAmelCase	,   atol=1E-3      )      )



 @require_torch
 def 		UpperCamelCase__  (			self      ):
       import torch

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

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



 def 		UpperCamelCase__  (			self	,   _UpperCAmelCase      ):
       from datasets import load_dataset

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

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





 @require_torch
 def 		UpperCamelCase__  (			self      ):
       # fmt: off
       snake_case_ =   torch.tensor(
           [-0.9_894, -1.2_776, -0.9_066, -1.2_776, -0.9_349, -1.2_609, -1.0_386, -1.2_776,
            -1.1_561, -1.2_776, -1.2_052, -1.2_723, -1.2_190, -1.2_132, -1.2_776, -1.1_133,
            -1.1_953, -1.1_343, -1.1_584, -1.2_203, -1.1_770, -1.2_474, -1.2_381, -1.1_936,
            -0.9_270, -0.8_317, -0.8_049, -0.7_706, -0.7_565, -0.7_869]      )
       # fmt: on

       snake_case_ =   self._load_datasamples(1      )
       snake_case_ =   ASTFeatureExtractor()
       snake_case_ =   feature_extractor(_UpperCAmelCase	,   return_tensors='''pt'''      ).input_values
       self.assertEquals(input_values.shape	,   (1, 10_24, 1_28)      )
       self.assertTrue(torch.allclose(input_values[0, 0, :30]	,   _UpperCAmelCase	,   atol=1E-4      )      )



from collections import namedtuple

UpperCAmelCase    =					namedtuple("""from_to""", """from_ to""")

UpperCAmelCase    =					{
    """cubicmeter""": from_to(1, 1),
    """litre""": from_to(0.001, 1000),
    """kilolitre""": from_to(1, 1),
    """gallon""": from_to(0.00_454, 264.172),
    """cubicyard""": from_to(0.76_455, 1.30_795),
    """cubicfoot""": from_to(0.028, 35.3_147),
    """cup""": from_to(0.000_236_588, 4_226.75),
}






def  __lowerCAmelCase					(SCREAMING_SNAKE_CASE      ,      SCREAMING_SNAKE_CASE      ,      SCREAMING_SNAKE_CASE      )->						float:




      """simple docstring"""

      if from_type not in METRIC_CONVERSION:
            raise ValueError(
                f'''Invalid \'from_type\' value: {from_type!r}  Supported values are:\n'''
                + ''', '''.join(SCREAMING_SNAKE_CASE      )      )
      if to_type not in METRIC_CONVERSION:
            raise ValueError(
                f'''Invalid \'to_type\' value: {to_type!r}.  Supported values are:\n'''
                + ''', '''.join(SCREAMING_SNAKE_CASE      )      )
      return value * METRIC_CONVERSION[from_type].from_ * METRIC_CONVERSION[to_type].to


if __name__ == "__main__":
   import doctest

   doctest.testmod()