





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

UpperCamelCase__      =random.Random()






def     lowerCamelCase__			(__lowerCamelCase,       __lowerCamelCase=1.0,       __lowerCamelCase=None,       __lowerCamelCase=None	):
     if rng is None:
          _SCREAMING_SNAKE_CASE       :	str						    =							global_rng

     _SCREAMING_SNAKE_CASE       :	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 			lowerCAmelCase__( unittest.TestCase    ):






       '''simple docstring'''


       def __init__(      self    ,						__lowerCamelCase    ,						__lowerCamelCase=7    ,						__lowerCamelCase=4_0_0    ,						__lowerCamelCase=2_0_0_0    ,						__lowerCamelCase=2_4    ,						__lowerCamelCase=2_4    ,						__lowerCamelCase=0.0    ,						__lowerCamelCase=1_6_0_0_0    ,						__lowerCamelCase=True    ,						__lowerCamelCase=True    ,						)			->     Optional[int]:
            _SCREAMING_SNAKE_CASE       :	Optional[int]						    =							parent
            _SCREAMING_SNAKE_CASE       :	Dict						    =							batch_size
            _SCREAMING_SNAKE_CASE       :	str						    =							min_seq_length
            _SCREAMING_SNAKE_CASE       :	Optional[Any]						    =							max_seq_length
            _SCREAMING_SNAKE_CASE       :	Union[str, Any]						    =							(self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
            _SCREAMING_SNAKE_CASE       :	Any						    =							feature_size
            _SCREAMING_SNAKE_CASE       :	Optional[int]						    =							num_mel_bins
            _SCREAMING_SNAKE_CASE       :	str						    =							padding_value
            _SCREAMING_SNAKE_CASE       :	int						    =							sampling_rate
            _SCREAMING_SNAKE_CASE       :	Any						    =							return_attention_mask
            _SCREAMING_SNAKE_CASE       :	Union[str, Any]						    =							do_normalize




       def     UpperCamelCase_			(      self							)			->     Union[str, Any]:
            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    ,						__lowerCamelCase=False    ,						__lowerCamelCase=False							)			->     Tuple:
            def _flatten(__lowerCamelCase							):
                 return list(itertools.chain(*__lowerCamelCase							)							)

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





@require_torch
@require_torchaudio
class 			lowerCAmelCase__( __lowercase  ,     unittest.TestCase    ):






       '''simple docstring'''


       __snake_case 			=    SpeechaTextFeatureExtractor if is_speech_available() else None




       def     UpperCamelCase_			(      self							)			->     int:
            _SCREAMING_SNAKE_CASE       :	Any						    =							SpeechaTextFeatureExtractionTester(self							)




       def     UpperCamelCase_			(      self    ,						__lowerCamelCase							)			->     Tuple:
            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     UpperCamelCase_			(      self							)			->     List[Any]:
            # Tests that all call wrap to encode_plus and batch_encode_plus
            _SCREAMING_SNAKE_CASE       :	int						    =							self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()							)
            # create three inputs of length 800, 1000, and 1200
            _SCREAMING_SNAKE_CASE       :	List[str]						    =							[floats_list((1, x)							)[0] for x in range(8_0_0    ,						1_4_0_0    ,						2_0_0							)]
            _SCREAMING_SNAKE_CASE       :	Optional[Any]						    =							[np.asarray(__lowerCamelCase							) for speech_input in speech_inputs]

            # Test feature size
            _SCREAMING_SNAKE_CASE       :	Union[str, Any]						    =							feature_extractor(__lowerCamelCase    ,						padding=__lowerCamelCase    ,						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
            _SCREAMING_SNAKE_CASE       :	Optional[Any]						    =							feature_extractor(speech_inputs[0]    ,						return_tensors="np"							).input_features
            _SCREAMING_SNAKE_CASE       :	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
            _SCREAMING_SNAKE_CASE       :	str						    =							feature_extractor(__lowerCamelCase    ,						return_tensors="np"							).input_features
            _SCREAMING_SNAKE_CASE       :	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							)							)

            # Test 2-D numpy arrays are batched.
            _SCREAMING_SNAKE_CASE       :	List[str]						    =							[floats_list((1, x)							)[0] for x in (8_0_0, 8_0_0, 8_0_0)]
            _SCREAMING_SNAKE_CASE       :	List[Any]						    =							np.asarray(__lowerCamelCase							)
            _SCREAMING_SNAKE_CASE       :	str						    =							feature_extractor(__lowerCamelCase    ,						return_tensors="np"							).input_features
            _SCREAMING_SNAKE_CASE       :	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     UpperCamelCase_			(      self							)			->     Union[str, Any]:
            _SCREAMING_SNAKE_CASE       :	Union[str, Any]						    =							self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()							)
            _SCREAMING_SNAKE_CASE       :	List[str]						    =							[floats_list((1, x)							)[0] for x in range(8_0_0    ,						1_4_0_0    ,						2_0_0							)]

            _SCREAMING_SNAKE_CASE       :	str						    =							["longest", "max_length", "do_not_pad"]
            _SCREAMING_SNAKE_CASE       :	str						    =							[None, 1_6, None]
            for max_length, padding in zip(__lowerCamelCase    ,						__lowerCamelCase							):
                 _SCREAMING_SNAKE_CASE       :	List[Any]						    =							feature_extractor(
                     __lowerCamelCase    ,						padding=__lowerCamelCase    ,						max_length=__lowerCamelCase    ,						return_attention_mask=__lowerCamelCase							)
                 _SCREAMING_SNAKE_CASE       :	str						    =							inputs.input_features
                 _SCREAMING_SNAKE_CASE       :	List[str]						    =							inputs.attention_mask
                 _SCREAMING_SNAKE_CASE       :	int						    =							[np.sum(__lowerCamelCase							) 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							)			->     int:
            _SCREAMING_SNAKE_CASE       :	Union[str, Any]						    =							self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()							)
            _SCREAMING_SNAKE_CASE       :	Optional[int]						    =							[floats_list((1, x)							)[0] for x in range(8_0_0    ,						1_4_0_0    ,						2_0_0							)]

            _SCREAMING_SNAKE_CASE       :	Any						    =							["longest", "max_length", "do_not_pad"]
            _SCREAMING_SNAKE_CASE       :	Optional[Any]						    =							[None, 1_6, None]
            for max_length, padding in zip(__lowerCamelCase    ,						__lowerCamelCase							):
                 _SCREAMING_SNAKE_CASE       :	Tuple						    =							feature_extractor(
                     __lowerCamelCase    ,						max_length=__lowerCamelCase    ,						padding=__lowerCamelCase    ,						return_tensors="np"    ,						return_attention_mask=__lowerCamelCase							)
                 _SCREAMING_SNAKE_CASE       :	int						    =							inputs.input_features
                 _SCREAMING_SNAKE_CASE       :	Dict						    =							inputs.attention_mask
                 _SCREAMING_SNAKE_CASE       :	Tuple						    =							[np.sum(__lowerCamelCase							) 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							)			->     List[str]:
            _SCREAMING_SNAKE_CASE       :	int						    =							self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()							)
            _SCREAMING_SNAKE_CASE       :	List[str]						    =							[floats_list((1, x)							)[0] for x in range(8_0_0    ,						1_4_0_0    ,						2_0_0							)]
            _SCREAMING_SNAKE_CASE       :	List[str]						    =							feature_extractor(
                __lowerCamelCase    ,						padding="max_length"    ,						max_length=4    ,						truncation=__lowerCamelCase    ,						return_tensors="np"    ,						return_attention_mask=__lowerCamelCase    ,						)
            _SCREAMING_SNAKE_CASE       :	Dict						    =							inputs.input_features
            _SCREAMING_SNAKE_CASE       :	str						    =							inputs.attention_mask
            _SCREAMING_SNAKE_CASE       :	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]							)
            self._check_zero_mean_unit_variance(input_features[2]							)




       def     UpperCamelCase_			(      self							)			->     Optional[int]:
            _SCREAMING_SNAKE_CASE       :	List[str]						    =							self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()							)
            _SCREAMING_SNAKE_CASE       :	Optional[int]						    =							[floats_list((1, x)							)[0] for x in range(8_0_0    ,						1_4_0_0    ,						2_0_0							)]
            _SCREAMING_SNAKE_CASE       :	Any						    =							feature_extractor(
                __lowerCamelCase    ,						padding="longest"    ,						max_length=4    ,						truncation=__lowerCamelCase    ,						return_tensors="np"    ,						return_attention_mask=__lowerCamelCase    ,						)
            _SCREAMING_SNAKE_CASE       :	Any						    =							inputs.input_features
            _SCREAMING_SNAKE_CASE       :	str						    =							inputs.attention_mask
            _SCREAMING_SNAKE_CASE       :	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, 2_4)							)

            _SCREAMING_SNAKE_CASE       :	Union[str, Any]						    =							[floats_list((1, x)							)[0] for x in range(8_0_0    ,						1_4_0_0    ,						2_0_0							)]
            _SCREAMING_SNAKE_CASE       :	Dict						    =							feature_extractor(
                __lowerCamelCase    ,						padding="longest"    ,						max_length=1_6    ,						truncation=__lowerCamelCase    ,						return_tensors="np"    ,						return_attention_mask=__lowerCamelCase    ,						)
            _SCREAMING_SNAKE_CASE       :	int						    =							inputs.input_features
            _SCREAMING_SNAKE_CASE       :	Optional[Any]						    =							inputs.attention_mask
            _SCREAMING_SNAKE_CASE       :	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, 6, 2_4)							)




       def     UpperCamelCase_			(      self							)			->     int:
            import torch

            _SCREAMING_SNAKE_CASE       :	Optional[int]						    =							self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()							)
            _SCREAMING_SNAKE_CASE       :	Dict						    =							np.random.rand(1_0_0    ,						3_2							).astype(np.floataa							)
            _SCREAMING_SNAKE_CASE       :	List[str]						    =							np_speech_inputs.tolist()

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




       def     UpperCamelCase_			(      self    ,						__lowerCamelCase							)			->     Any:
            from datasets import load_dataset

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

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







       def     UpperCamelCase_			(      self							)			->     Union[str, Any]:
            # fmt: off
            _SCREAMING_SNAKE_CASE       :	Dict						    =							np.array([
                -1.5745, -1.7713, -1.7020, -1.6069, -1.2250, -1.1105, -0.9072, -0.8241,
                -1.2310, -0.8098, -0.3320, -0.4101, -0.7985, -0.4996, -0.8213, -0.9128,
                -1.0420, -1.1286, -1.0440, -0.7999, -0.8405, -1.2275, -1.5443, -1.4625,
            ]							)
            # fmt: on

            _SCREAMING_SNAKE_CASE       :	Optional[Any]						    =							self._load_datasamples(1							)
            _SCREAMING_SNAKE_CASE       :	List[str]						    =							self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()							)
            _SCREAMING_SNAKE_CASE       :	List[str]						    =							feature_extractor(__lowerCamelCase    ,						return_tensors="pt"							).input_features
            self.assertEquals(input_features.shape    ,						(1, 5_8_4, 2_4)							)
            self.assertTrue(np.allclose(input_features[0, 0, :3_0]    ,						__lowerCamelCase    ,						atol=1E-4							)							)






def     lowerCamelCase__			(__lowerCamelCase,       __lowerCamelCase	):
     while a != 0:
          _SCREAMING_SNAKE_CASE    ,			_SCREAMING_SNAKE_CASE       :	Any						    =							b % a, a
     return b






def     lowerCamelCase__			(__lowerCamelCase,       __lowerCamelCase	):
     if gcd(__lowerCamelCase,       __lowerCamelCase	) != 1:
          _SCREAMING_SNAKE_CASE       :	int						    =							f"""mod inverse of {a!r} and {m!r} does not exist"""
          raise ValueError(__lowerCamelCase	)
     _SCREAMING_SNAKE_CASE    ,			_SCREAMING_SNAKE_CASE    ,			_SCREAMING_SNAKE_CASE       :	List[str]						    =							1, 0, a
     _SCREAMING_SNAKE_CASE    ,			_SCREAMING_SNAKE_CASE    ,			_SCREAMING_SNAKE_CASE       :	List[str]						    =							0, 1, m
     while va != 0:
          _SCREAMING_SNAKE_CASE       :	Union[str, Any]						    =							ua // va
          _SCREAMING_SNAKE_CASE    ,			_SCREAMING_SNAKE_CASE    ,			_SCREAMING_SNAKE_CASE    ,			_SCREAMING_SNAKE_CASE    ,			_SCREAMING_SNAKE_CASE    ,			_SCREAMING_SNAKE_CASE       :	Union[str, Any]						    =							(ua - q * va), (ua - q * va), (ua - q * va), va, va, va
     return ua % m