






import itertools
import random
import unittest

import numpy as np

from transformers import BatchFeature, SpeechTaFeatureExtractor
from transformers.testing_utils import require_torch
from transformers.utils.import_utils import is_torch_available

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


if is_torch_available():
       import torch


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






def 						a    (		lowerCamelCase_	,     lowerCamelCase_=1.0	,     lowerCamelCase_=None	,     lowerCamelCase_=None       ):






    '''simple docstring'''
    if rng is None:
        lowercase__     				=    global_rng

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

    return values
@require_torch
class    _UpperCAmelCase      ( unittest.TestCase			):

    """simple docstring"""




    def __init__(  self		:					int,						lowerCamelCase		:					List[str],						lowerCamelCase		:					Dict=7,						lowerCamelCase		:					Dict=400,						lowerCamelCase		:					Dict=2_000,						lowerCamelCase		:					Optional[int]=1,						lowerCamelCase		:					Tuple=0.0,						lowerCamelCase		:					Tuple=16_000,						lowerCamelCase		:					Optional[int]=True,						lowerCamelCase		:					List[Any]=80,						lowerCamelCase		:					str=16,						lowerCamelCase		:					List[Any]=64,						lowerCamelCase		:					List[Any]="hann_window",						lowerCamelCase		:					Any=80,						lowerCamelCase		:					List[Any]=7_600,						lowerCamelCase		:					Any=1E-10,						lowerCamelCase		:					Any=True,						):

        '''simple docstring'''
        lowercase__     				=    parent
        lowercase__     				=    batch_size
        lowercase__     				=    min_seq_length
        lowercase__     				=    max_seq_length
        lowercase__     				=    (self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
        lowercase__     				=    feature_size
        lowercase__     				=    padding_value
        lowercase__     				=    sampling_rate
        lowercase__     				=    do_normalize
        lowercase__     				=    num_mel_bins
        lowercase__     				=    hop_length
        lowercase__     				=    win_length
        lowercase__     				=    win_function
        lowercase__     				=    fmin
        lowercase__     				=    fmax
        lowercase__     				=    mel_floor
        lowercase__     				=    return_attention_mask




    def        lowercase__     (  self		:					Dict						):

        '''simple docstring'''
        return {
            "feature_size": self.feature_size,
            "padding_value": self.padding_value,
            "sampling_rate": self.sampling_rate,
            "do_normalize": self.do_normalize,
            "num_mel_bins": self.num_mel_bins,
            "hop_length": self.hop_length,
            "win_length": self.win_length,
            "win_function": self.win_function,
            "fmin": self.fmin,
            "fmax": self.fmax,
            "mel_floor": self.mel_floor,
            "return_attention_mask": self.return_attention_mask,
        }




    def        lowercase__     (  self		:					List[str],						lowerCamelCase		:					Dict=False,						lowerCamelCase		:					Union[str, Any]=False						):

        '''simple docstring'''
        def _flatten(lowerCamelCase		:					List[str]						):
            return list(itertools.chain(*lowerCamelCase						)						)

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

        return speech_inputs




    def        lowercase__     (  self		:					Dict,						lowerCamelCase		:					List[Any]=False,						lowerCamelCase		:					Optional[Any]=False						):

        '''simple docstring'''
        if equal_length:
            lowercase__     				=    [floats_list((self.max_seq_length, self.num_mel_bins)						) for _ in range(self.batch_size						)]
        else:
            # make sure that inputs increase in size
            lowercase__     				=    [
                floats_list((x, self.num_mel_bins)						)
                for x in range(self.min_seq_length,						self.max_seq_length,						self.seq_length_diff						)
            ]

        if numpify:
            lowercase__     				=    [np.asarray(lowerCamelCase						) for x in speech_inputs]

        return speech_inputs



@require_torch
class    _UpperCAmelCase      ( A__	,unittest.TestCase			):

    """simple docstring"""




    lowercase__       							= SpeechTaFeatureExtractor




    def        lowercase__     (  self		:					Union[str, Any]						):

        '''simple docstring'''
        lowercase__     				=    SpeechTaFeatureExtractionTester(self						)




    def        lowercase__     (  self		:					Tuple,						lowerCamelCase		:					List[Any]						):

        '''simple docstring'''
        self.assertTrue(np.all(np.mean(lowerCamelCase,						axis=0						) < 1E-3						)						)
        self.assertTrue(np.all(np.abs(np.var(lowerCamelCase,						axis=0						) - 1						) < 1E-3						)						)




    def        lowercase__     (  self		:					List[str]						):

        '''simple docstring'''
        lowercase__     				=    self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()						)
        # create three inputs of length 800, 1000, and 1200
        lowercase__     				=    [floats_list((1, x)						)[0] for x in range(800,						1_400,						200						)]
        lowercase__     				=    [np.asarray(lowerCamelCase						) for speech_input in speech_inputs]

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

        # Test batched
        lowercase__     				=    feat_extract(lowerCamelCase,						return_tensors='''np'''						).input_values
        lowercase__     				=    feat_extract(lowerCamelCase,						return_tensors='''np'''						).input_values
        for enc_seq_a, enc_seq_a in zip(lowerCamelCase,						lowerCamelCase						):
            self.assertTrue(np.allclose(lowerCamelCase,						lowerCamelCase,						atol=1E-3						)						)




    def        lowercase__     (  self		:					str						):

        '''simple docstring'''
        lowercase__     				=    self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()						)
        lowercase__     				=    [floats_list((1, x)						)[0] for x in range(800,						1_400,						200						)]

        lowercase__     				=    ['''longest''', '''max_length''', '''do_not_pad''']
        lowercase__     				=    [None, 1_600, None]
        for max_length, padding in zip(lowerCamelCase,						lowerCamelCase						):
            lowercase__     				=    feat_extract(lowerCamelCase,						padding=lowerCamelCase,						max_length=lowerCamelCase,						return_tensors='''np'''						)
            lowercase__     				=    processed.input_values

            self._check_zero_mean_unit_variance(input_values[0][:800]						)
            self.assertTrue(input_values[0][800:].sum() < 1E-6						)
            self._check_zero_mean_unit_variance(input_values[1][:1_000]						)
            self.assertTrue(input_values[0][1_000:].sum() < 1E-6						)
            self._check_zero_mean_unit_variance(input_values[2][:1_200]						)




    def        lowercase__     (  self		:					Any						):

        '''simple docstring'''
        lowercase__     				=    self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()						)
        lowercase__     				=    range(800,						1_400,						200						)
        lowercase__     				=    [floats_list((1, x)						)[0] for x in lengths]

        lowercase__     				=    ['''longest''', '''max_length''', '''do_not_pad''']
        lowercase__     				=    [None, 1_600, None]

        for max_length, padding in zip(lowerCamelCase,						lowerCamelCase						):
            lowercase__     				=    feat_extract(lowerCamelCase,						max_length=lowerCamelCase,						padding=lowerCamelCase						)
            lowercase__     				=    processed.input_values

            self._check_zero_mean_unit_variance(input_values[0][:800]						)
            self._check_zero_mean_unit_variance(input_values[1][:1_000]						)
            self._check_zero_mean_unit_variance(input_values[2][:1_200]						)




    def        lowercase__     (  self		:					Any						):

        '''simple docstring'''
        lowercase__     				=    self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()						)
        lowercase__     				=    [floats_list((1, x)						)[0] for x in range(800,						1_400,						200						)]
        lowercase__     				=    feat_extract(
            lowerCamelCase,						truncation=lowerCamelCase,						max_length=1_000,						padding='''max_length''',						return_tensors='''np'''						)
        lowercase__     				=    processed.input_values

        self._check_zero_mean_unit_variance(input_values[0, :800]						)
        self._check_zero_mean_unit_variance(input_values[1]						)
        self._check_zero_mean_unit_variance(input_values[2]						)




    def        lowercase__     (  self		:					Any						):

        '''simple docstring'''
        lowercase__     				=    self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()						)
        lowercase__     				=    [floats_list((1, x)						)[0] for x in range(800,						1_400,						200						)]
        lowercase__     				=    feat_extract(
            lowerCamelCase,						truncation=lowerCamelCase,						max_length=1_000,						padding='''longest''',						return_tensors='''np'''						)
        lowercase__     				=    processed.input_values

        self._check_zero_mean_unit_variance(input_values[0, :800]						)
        self._check_zero_mean_unit_variance(input_values[1, :1_000]						)
        self._check_zero_mean_unit_variance(input_values[2]						)

        # make sure that if max_length < longest -> then pad to max_length
        self.assertTrue(input_values.shape == (3, 1_000)						)

        lowercase__     				=    [floats_list((1, x)						)[0] for x in range(800,						1_400,						200						)]
        lowercase__     				=    feat_extract(
            lowerCamelCase,						truncation=lowerCamelCase,						max_length=2_000,						padding='''longest''',						return_tensors='''np'''						)
        lowercase__     				=    processed.input_values

        self._check_zero_mean_unit_variance(input_values[0, :800]						)
        self._check_zero_mean_unit_variance(input_values[1, :1_000]						)
        self._check_zero_mean_unit_variance(input_values[2]						)

        # make sure that if max_length > longest -> then pad to longest
        self.assertTrue(input_values.shape == (3, 1_200)						)




    def        lowercase__     (  self		:					str						):

        '''simple docstring'''
        lowercase__     				=    self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()						)
        lowercase__     				=    np.random.rand(100						).astype(np.floataa						)
        lowercase__     				=    np_speech_inputs.tolist()

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




    def        lowercase__     (  self		:					Optional[int]						):

        '''simple docstring'''
        lowercase__     				=    self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()						)
        # create three inputs of length 800, 1000, and 1200
        lowercase__     				=    [floats_list((1, x)						)[0] for x in range(800,						1_400,						200						)]
        lowercase__     				=    [np.asarray(lowerCamelCase						) for speech_input in speech_inputs]

        # Test feature size
        lowercase__     				=    feature_extractor(audio_target=lowerCamelCase,						padding=lowerCamelCase,						return_tensors='''np'''						).input_values
        self.assertTrue(input_values.ndim == 3						)
        self.assertTrue(input_values.shape[-1] == feature_extractor.num_mel_bins						)

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

        # Test batched
        lowercase__     				=    feature_extractor(lowerCamelCase,						return_tensors='''np'''						).input_values
        lowercase__     				=    feature_extractor(lowerCamelCase,						return_tensors='''np'''						).input_values
        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.
        lowercase__     				=    [floats_list((1, x)						)[0] for x in (800, 800, 800)]
        lowercase__     				=    np.asarray(lowerCamelCase						)
        lowercase__     				=    feature_extractor(lowerCamelCase,						return_tensors='''np'''						).input_values
        lowercase__     				=    feature_extractor(lowerCamelCase,						return_tensors='''np'''						).input_values
        for enc_seq_a, enc_seq_a in zip(lowerCamelCase,						lowerCamelCase						):
            self.assertTrue(np.allclose(lowerCamelCase,						lowerCamelCase,						atol=1E-3						)						)




    def        lowercase__     (  self		:					Optional[Any]						):

        '''simple docstring'''
        lowercase__     				=    self.feat_extract_tester.prepare_inputs_for_target()
        lowercase__     				=    self.feature_extraction_class(**self.feat_extract_dict						)
        lowercase__     				=    feat_extract.model_input_names[0]

        lowercase__     				=    BatchFeature({input_name: speech_inputs}						)

        self.assertTrue(all(len(lowerCamelCase						) == len(lowerCamelCase						) for x, y in zip(lowerCamelCase,						processed_features[input_name]						)						)						)

        lowercase__     				=    self.feat_extract_tester.prepare_inputs_for_target(equal_length=lowerCamelCase						)
        lowercase__     				=    BatchFeature({input_name: speech_inputs},						tensor_type='''np'''						)

        lowercase__     				=    processed_features[input_name]

        if len(batch_features_input.shape						) < 3:
            lowercase__     				=    batch_features_input[:, :, None]

        self.assertTrue(
            batch_features_input.shape
            == (self.feat_extract_tester.batch_size, len(speech_inputs[0]						), self.feat_extract_tester.num_mel_bins)						)




    @require_torch
    def        lowercase__     (  self		:					List[str]						):

        '''simple docstring'''
        lowercase__     				=    self.feat_extract_tester.prepare_inputs_for_target(equal_length=lowerCamelCase						)
        lowercase__     				=    self.feature_extraction_class(**self.feat_extract_dict						)
        lowercase__     				=    feat_extract.model_input_names[0]

        lowercase__     				=    BatchFeature({input_name: speech_inputs},						tensor_type='''pt'''						)

        lowercase__     				=    processed_features[input_name]

        if len(batch_features_input.shape						) < 3:
            lowercase__     				=    batch_features_input[:, :, None]

        self.assertTrue(
            batch_features_input.shape
            == (self.feat_extract_tester.batch_size, len(speech_inputs[0]						), self.feat_extract_tester.num_mel_bins)						)




    @require_torch
    def        lowercase__     (  self		:					Dict						):

        '''simple docstring'''
        lowercase__     				=    self.feature_extraction_class(**self.feat_extract_dict						)
        lowercase__     				=    self.feat_extract_tester.prepare_inputs_for_target()
        lowercase__     				=    feat_extract.model_input_names[0]

        lowercase__     				=    BatchFeature({input_name: speech_inputs}						)

        lowercase__     				=    feat_extract.num_mel_bins  # hack!

        lowercase__     				=    feat_extract.pad(lowerCamelCase,						padding='''longest''',						return_tensors='''np'''						)[input_name]
        lowercase__     				=    feat_extract.pad(lowerCamelCase,						padding='''longest''',						return_tensors='''pt'''						)[input_name]

        self.assertTrue(abs(input_np.astype(np.floataa						).sum() - input_pt.numpy().astype(np.floataa						).sum()						) < 1E-2						)




    def        lowercase__     (  self		:					Dict						):

        '''simple docstring'''
        lowercase__     				=    self.feat_extract_dict
        lowercase__     				=    True
        lowercase__     				=    self.feature_extraction_class(**lowerCamelCase						)
        lowercase__     				=    self.feat_extract_tester.prepare_inputs_for_target()
        lowercase__     				=    [len(lowerCamelCase						) for x in speech_inputs]
        lowercase__     				=    feat_extract.model_input_names[0]

        lowercase__     				=    BatchFeature({input_name: speech_inputs}						)

        lowercase__     				=    feat_extract.num_mel_bins  # hack!

        lowercase__     				=    feat_extract.pad(lowerCamelCase,						padding='''longest''',						return_tensors='''np'''						)
        self.assertIn('''attention_mask''',						lowerCamelCase						)
        self.assertListEqual(list(processed.attention_mask.shape						),						list(processed[input_name].shape[:2]						)						)
        self.assertListEqual(processed.attention_mask.sum(-1						).tolist(),						lowerCamelCase						)




    def        lowercase__     (  self		:					Optional[Any]						):

        '''simple docstring'''
        lowercase__     				=    self.feat_extract_dict
        lowercase__     				=    True
        lowercase__     				=    self.feature_extraction_class(**lowerCamelCase						)
        lowercase__     				=    self.feat_extract_tester.prepare_inputs_for_target()
        lowercase__     				=    [len(lowerCamelCase						) for x in speech_inputs]
        lowercase__     				=    feat_extract.model_input_names[0]

        lowercase__     				=    BatchFeature({input_name: speech_inputs}						)
        lowercase__     				=    min(lowerCamelCase						)

        lowercase__     				=    feat_extract.num_mel_bins  # hack!

        lowercase__     				=    feat_extract.pad(
            lowerCamelCase,						padding='''max_length''',						max_length=lowerCamelCase,						truncation=lowerCamelCase,						return_tensors='''np'''						)
        self.assertIn('''attention_mask''',						lowerCamelCase						)
        self.assertListEqual(
            list(processed_pad.attention_mask.shape						),						[processed_pad[input_name].shape[0], max_length]						)
        self.assertListEqual(
            processed_pad.attention_mask[:, :max_length].sum(-1						).tolist(),						[max_length for x in speech_inputs]						)




    def        lowercase__     (  self		:					str,						lowerCamelCase		:					Any						):

        '''simple docstring'''
        from datasets import load_dataset

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

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




    def        lowercase__     (  self		:					Union[str, Any]						):

        '''simple docstring'''
        lowercase__     				=    torch.tensor(
            [2.3804E-03, 2.0752E-03, 1.9836E-03, 2.1057E-03, 1.6174E-03,
             3.0518E-04, 9.1553E-05, 3.3569E-04, 9.7656E-04, 1.8311E-03,
             2.0142E-03, 2.1057E-03, 1.7395E-03, 4.5776E-04, -3.9673E-04,
             4.5776E-04, 1.0071E-03, 9.1553E-05, 4.8828E-04, 1.1597E-03,
             7.3242E-04, 9.4604E-04, 1.8005E-03, 1.8311E-03, 8.8501E-04,
             4.2725E-04, 4.8828E-04, 7.3242E-04, 1.0986E-03, 2.1057E-03]						)
        # fmt: on

        lowercase__     				=    self._load_datasamples(1						)
        lowercase__     				=    SpeechTaFeatureExtractor()
        lowercase__     				=    feature_extractor(lowerCamelCase,						return_tensors='''pt'''						).input_values
        self.assertEquals(input_values.shape,						(1, 93_680)						)
        self.assertTrue(torch.allclose(input_values[0, :30],						lowerCamelCase,						atol=1E-6						)						)




    def        lowercase__     (  self		:					List[Any]						):

        '''simple docstring'''
        lowercase__     				=    torch.tensor(
            [-2.6870, -3.0104, -3.1356, -3.5352, -3.0044, -3.0353, -3.4719, -3.6777,
             -3.1520, -2.9435, -2.6553, -2.8795, -2.9944, -2.5921, -3.0279, -3.0386,
             -3.0864, -3.1291, -3.2353, -2.7444, -2.6831, -2.7287, -3.1761, -3.1571,
             -3.2726, -3.0582, -3.1007, -3.4533, -3.4695, -3.0998]						)
        # fmt: on

        lowercase__     				=    self._load_datasamples(1						)
        lowercase__     				=    SpeechTaFeatureExtractor()
        lowercase__     				=    feature_extractor(audio_target=lowerCamelCase,						return_tensors='''pt'''						).input_values
        self.assertEquals(input_values.shape,						(1, 366, 80)						)
        self.assertTrue(torch.allclose(input_values[0, 0, :30],						lowerCamelCase,						atol=1E-4						)						)












def 						a    (		lowerCamelCase_	,     lowerCamelCase_	,     lowerCamelCase_       ):






				'''simple docstring'''

				if exponent == 1:
								return base
				if exponent % 2 == 0:
								lowercase__     				=    _modexpt(lowerCamelCase_	,     exponent // 2	,     lowerCamelCase_       ) % modulo_value
								return (x * x) % modulo_value
				else:
								return (base * _modexpt(lowerCamelCase_	,     exponent - 1	,     lowerCamelCase_       )) % modulo_value






def 						a    (		lowerCamelCase_ = 1777	,     lowerCamelCase_ = 1855	,     lowerCamelCase_ = 8       ):






				'''simple docstring'''
				lowercase__     				=    base
				for _ in range(1	,     lowerCamelCase_       ):
								lowercase__     				=    _modexpt(lowerCamelCase_	,     lowerCamelCase_	,     10**digits       )

				return result


if __name__ == "__main__":
							print(F"{solution() = }")




