


'''simple docstring'''







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

lowerCAmelCase    :     List[Any]					=						random.Random()






def 			lowercase				(_A   ,						_A=1.0   ,						_A=None   ,						_A=None					):







       """simple docstring"""







       if rng is None:
              _lowerCAmelCase    :							Tuple   			=       global_rng

       _lowerCAmelCase    :							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 	UpperCamelCase__					( unittest.TestCase	):



     """simple docstring"""






     def __init__( self      ,	snake_case__      ,	snake_case__=7      ,	snake_case__=400      ,	snake_case__=2000      ,	snake_case__=10      ,	snake_case__=160      ,	snake_case__=8      ,	snake_case__=0.0      ,	snake_case__=4000      ,	snake_case__=False      ,	snake_case__=True      ,	):

            '''simple docstring'''

            _lowerCAmelCase    :							int   			=       parent
            _lowerCAmelCase    :							Union[str, Any]   			=       batch_size
            _lowerCAmelCase    :							Optional[int]   			=       min_seq_length
            _lowerCAmelCase    :							Any   			=       max_seq_length
            _lowerCAmelCase    :							str   			=       (self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
            _lowerCAmelCase    :							Tuple   			=       padding_value
            _lowerCAmelCase    :							Union[str, Any]   			=       sampling_rate
            _lowerCAmelCase    :							List[str]   			=       return_attention_mask
            _lowerCAmelCase    :							Dict   			=       do_normalize
            _lowerCAmelCase    :							Optional[Any]   			=       feature_size
            _lowerCAmelCase    :							Optional[int]   			=       chunk_length
            _lowerCAmelCase    :							List[Any]   			=       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      ,	snake_case__=False      ,	snake_case__=False   ):

            '''simple docstring'''

            def _flatten(snake_case__   ):
                   return list(itertools.chain(*lowerCamelCase__   )   )

            if equal_length:
                   _lowerCAmelCase    :							Tuple   			=       [floats_list((self.max_seq_length, self.feature_size)   ) for _ in range(self.batch_size   )]
            else:
                   # make sure that inputs increase in size
                   _lowerCAmelCase    :							Optional[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:
                   _lowerCAmelCase    :							Tuple   			=       [np.asarray(lowerCamelCase__   ) for x in speech_inputs]
            return speech_inputs
@require_torch
@require_torchaudio
class 	UpperCamelCase__					( UpperCAmelCase__    ,					unittest.TestCase	):



     """simple docstring"""






     __magic_name__    			=    WhisperFeatureExtractor if is_speech_available() else None







     def a	( self   ):

            '''simple docstring'''

            _lowerCAmelCase    :							List[str]   			=       WhisperFeatureExtractionTester(self   )







     def a	( self   ):

            '''simple docstring'''

            _lowerCAmelCase    :							str   			=       self.feature_extraction_class(**self.feat_extract_dict   )

            with tempfile.TemporaryDirectory() as tmpdirname:
                   _lowerCAmelCase    :							Dict   			=       feat_extract_first.save_pretrained(lowerCamelCase__   )[0]
                   check_json_file_has_correct_format(lowerCamelCase__   )
                   _lowerCAmelCase    :							int   			=       self.feature_extraction_class.from_pretrained(lowerCamelCase__   )

            _lowerCAmelCase    :							Dict   			=       feat_extract_first.to_dict()
            _lowerCAmelCase    :							Any   			=       feat_extract_second.to_dict()
            _lowerCAmelCase    :							List[Any]   			=       feat_extract_first.mel_filters
            _lowerCAmelCase    :							Dict   			=       feat_extract_second.mel_filters
            self.assertTrue(np.allclose(lowerCamelCase__      ,	lowerCamelCase__   )   )
            self.assertEqual(lowerCamelCase__      ,	lowerCamelCase__   )







     def a	( self   ):

            '''simple docstring'''

            _lowerCAmelCase    :							Optional[Any]   			=       self.feature_extraction_class(**self.feat_extract_dict   )

            with tempfile.TemporaryDirectory() as tmpdirname:
                   _lowerCAmelCase    :							Dict   			=       os.path.join(lowerCamelCase__      ,	'feat_extract.json'   )
                   feat_extract_first.to_json_file(lowerCamelCase__   )
                   _lowerCAmelCase    :							Tuple   			=       self.feature_extraction_class.from_json_file(lowerCamelCase__   )

            _lowerCAmelCase    :							Tuple   			=       feat_extract_first.to_dict()
            _lowerCAmelCase    :							Optional[Any]   			=       feat_extract_second.to_dict()
            _lowerCAmelCase    :							Optional[int]   			=       feat_extract_first.mel_filters
            _lowerCAmelCase    :							Tuple   			=       feat_extract_second.mel_filters
            self.assertTrue(np.allclose(lowerCamelCase__      ,	lowerCamelCase__   )   )
            self.assertEqual(lowerCamelCase__      ,	lowerCamelCase__   )







     def a	( self   ):

            '''simple docstring'''

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

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

            # Test batched
            _lowerCAmelCase    :							int   			=       feature_extractor(lowerCamelCase__      ,	return_tensors='np'   ).input_features
            _lowerCAmelCase    :							str   			=       feature_extractor(lowerCamelCase__      ,	return_tensors='np'   ).input_features
            for enc_seq_a, enc_seq_a in zip(lowerCamelCase__      ,	lowerCamelCase__   ):
                   self.assertTrue(np.allclose(lowerCamelCase__      ,	lowerCamelCase__      ,	atol=1E-3   )   )

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

            # Test truncation required
            _lowerCAmelCase    :							Union[str, Any]   			=       [floats_list((1, x)   )[0] for x in range(200      ,	(feature_extractor.n_samples + 500)      ,	200   )]
            _lowerCAmelCase    :							Any   			=       [np.asarray(lowerCamelCase__   ) for speech_input in speech_inputs]

            _lowerCAmelCase    :							str   			=       [x[: feature_extractor.n_samples] for x in speech_inputs]
            _lowerCAmelCase    :							int   			=       [np.asarray(lowerCamelCase__   ) for speech_input in speech_inputs_truncated]

            _lowerCAmelCase    :							List[str]   			=       feature_extractor(lowerCamelCase__      ,	return_tensors='np'   ).input_features
            _lowerCAmelCase    :							Optional[Any]   			=       feature_extractor(lowerCamelCase__      ,	return_tensors='np'   ).input_features
            for enc_seq_a, enc_seq_a in zip(lowerCamelCase__      ,	lowerCamelCase__   ):
                   self.assertTrue(np.allclose(lowerCamelCase__      ,	lowerCamelCase__      ,	atol=1E-3   )   )







     def a	( self   ):

            '''simple docstring'''

            import torch

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

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







     def a	( self      ,	snake_case__   ):

            '''simple docstring'''

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

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







     def a	( self   ):

            '''simple docstring'''

            _lowerCAmelCase    :							Optional[int]   			=       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    :							Union[str, Any]   			=       self._load_datasamples(1   )
            _lowerCAmelCase    :							int   			=       WhisperFeatureExtractor()
            _lowerCAmelCase    :							List[Any]   			=       feature_extractor(lowerCamelCase__      ,	return_tensors='pt'   ).input_features
            self.assertEqual(input_features.shape      ,	(1, 80, 3000)   )
            self.assertTrue(torch.allclose(input_features[0, 0, :30]      ,	lowerCamelCase__      ,	atol=1E-4   )   )







     def a	( self   ):

            '''simple docstring'''

            _lowerCAmelCase    :							List[str]   			=       self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()   )
            _lowerCAmelCase    :							List[str]   			=       self._load_datasamples(1   )[0]
            _lowerCAmelCase    :							Optional[int]   			=       ((audio - audio.min()) / (audio.max() - audio.min())) * 6_5535  # Rescale to [0, 65535] to show issue
            _lowerCAmelCase    :							List[str]   			=       feat_extract.zero_mean_unit_var_norm([audio]      ,	attention_mask=lowerCamelCase__   )[0]

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





'''simple docstring'''







def 			lowercase				(_A   ,						_A					):







       """simple docstring"""







       _lowerCAmelCase    :							Optional[int]   			=       (boundary[1] - boundary[0]) / steps
       _lowerCAmelCase    :							Any   			=       boundary[0]
       _lowerCAmelCase    :							List[str]   			=       boundary[1]
       _lowerCAmelCase    :							Tuple   			=       make_points(_A   ,						_A   ,						_A					)
       _lowerCAmelCase    :							Tuple   			=       0.0
       y += (h / 2.0) * f(_A					)
       for i in x_i:
              # print(i)
              y += h * f(_A					)
       y += (h / 2.0) * f(_A					)
       return y






def 			lowercase				(_A   ,						_A   ,						_A					):







       """simple docstring"""







       _lowerCAmelCase    :							Tuple   			=       a + h
       while x < (b - h):
              yield x
              _lowerCAmelCase    :							Any   			=       x + h






def 			lowercase				(_A					):  # enter your function here







       """simple docstring"""







       _lowerCAmelCase    :							int   			=       (x - 0) * (x - 0)
       return y






def 			lowercase				():







       """simple docstring"""







       _lowerCAmelCase    :							Optional[Any]   			=       0.0  # Lower bound of integration
       _lowerCAmelCase    :							Dict   			=       1.0  # Upper bound of integration
       _lowerCAmelCase    :							Optional[Any]   			=       10.0  # define number of steps or resolution
       _lowerCAmelCase    :							Optional[int]   			=       [a, b]  # define boundary of integration
       _lowerCAmelCase    :							List[Any]   			=       method_a(_A   ,						_A					)
       print(f'y = {y}'					)


if __name__ == "__main__":
       main()

