






"""simple docstring"""






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


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



def 			__lowerCamelCase       (       lowerCAmelCase__							,lowerCAmelCase__=1.0							,lowerCAmelCase__=None							,lowerCAmelCase__=None					):
				if rng is None:
								A__							=							global_rng

				A__							=							[]
				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    snake_case_							(     unittest.TestCase							):



	"""simple docstring"""

	def __init__(   self	,       __a	,       __a=7	,       __a=400	,       __a=2000	,       __a=1	,       __a=0.0	,       __a=1_6000	,       __a=True	,       __a=80	,       __a=16	,       __a=64	,       __a="hann_window"	,       __a=80	,       __a=7600	,       __a=1E-10	,       __a=True	,       ):


					"""simple docstring"""

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


	def    _UpperCAmelCase    (   self    ):


					"""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    _UpperCAmelCase    (   self	,       __a=False	,       __a=False    ):


					"""simple docstring"""

					def _flatten(__a    ):
									return list(itertools.chain(*a__    )    )

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

					return speech_inputs






	def    _UpperCAmelCase    (   self	,       __a=False	,       __a=False    ):


					"""simple docstring"""

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

					return speech_inputs





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



	"""simple docstring"""

	SCREAMING_SNAKE_CASE_:				Any       =       SpeechTaFeatureExtractor


	def    _UpperCAmelCase    (   self    ):


					"""simple docstring"""

					A__							=							SpeechTaFeatureExtractionTester(self    )


	def    _UpperCAmelCase    (   self	,       __a    ):


					"""simple docstring"""

					self.assertTrue(np.all(np.mean(a__	,       axis=0    ) < 1E-3    )    )
					self.assertTrue(np.all(np.abs(np.var(a__	,       axis=0    ) - 1    ) < 1E-3    )    )


	def    _UpperCAmelCase    (   self    ):


					"""simple docstring"""

					A__							=							self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()    )
					# create three inputs of length 800, 1000, and 1200
					A__							=							[floats_list((1, x)    )[0] for x in range(800	,       1400	,       200    )]
					A__							=							[np.asarray(a__    ) for speech_input in speech_inputs]

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

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


	def    _UpperCAmelCase    (   self    ):


					"""simple docstring"""

					A__							=							self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()    )
					A__							=							[floats_list((1, x)    )[0] for x in range(800	,       1400	,       200    )]

					A__							=							['longest', 'max_length', 'do_not_pad']
					A__							=							[None, 1600, None]
					for max_length, padding in zip(a__	,       a__    ):
									A__							=							feat_extract(a__	,       padding=a__	,       max_length=a__	,       return_tensors='np'    )
									A__							=							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][:1000]    )
									self.assertTrue(input_values[0][1000:].sum() < 1E-6    )
									self._check_zero_mean_unit_variance(input_values[2][:1200]    )


	def    _UpperCAmelCase    (   self    ):


					"""simple docstring"""

					A__							=							self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()    )
					A__							=							range(800	,       1400	,       200    )
					A__							=							[floats_list((1, x)    )[0] for x in lengths]

					A__							=							['longest', 'max_length', 'do_not_pad']
					A__							=							[None, 1600, None]

					for max_length, padding in zip(a__	,       a__    ):
									A__							=							feat_extract(a__	,       max_length=a__	,       padding=a__    )
									A__							=							processed.input_values

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


	def    _UpperCAmelCase    (   self    ):


					"""simple docstring"""

					A__							=							self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()    )
					A__							=							[floats_list((1, x)    )[0] for x in range(800	,       1400	,       200    )]
					A__							=							feat_extract(
					    a__	,       truncation=a__	,       max_length=1000	,       padding='max_length'	,       return_tensors='np'    )
					A__							=							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    _UpperCAmelCase    (   self    ):


					"""simple docstring"""

					A__							=							self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()    )
					A__							=							[floats_list((1, x)    )[0] for x in range(800	,       1400	,       200    )]
					A__							=							feat_extract(
					    a__	,       truncation=a__	,       max_length=1000	,       padding='longest'	,       return_tensors='np'    )
					A__							=							processed.input_values

					self._check_zero_mean_unit_variance(input_values[0, :800]    )
					self._check_zero_mean_unit_variance(input_values[1, :1000]    )
					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, 1000)    )

					A__							=							[floats_list((1, x)    )[0] for x in range(800	,       1400	,       200    )]
					A__							=							feat_extract(
					    a__	,       truncation=a__	,       max_length=2000	,       padding='longest'	,       return_tensors='np'    )
					A__							=							processed.input_values

					self._check_zero_mean_unit_variance(input_values[0, :800]    )
					self._check_zero_mean_unit_variance(input_values[1, :1000]    )
					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, 1200)    )


	def    _UpperCAmelCase    (   self    ):


					"""simple docstring"""

					A__							=							self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()    )
					A__							=							np.random.rand(100    ).astype(np.floataa    )
					A__							=							np_speech_inputs.tolist()

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


	def    _UpperCAmelCase    (   self    ):


					"""simple docstring"""

					A__							=							self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()    )
					# create three inputs of length 800, 1000, and 1200
					A__							=							[floats_list((1, x)    )[0] for x in range(800	,       1400	,       200    )]
					A__							=							[np.asarray(a__    ) for speech_input in speech_inputs]

					# Test feature size
					A__							=							feature_extractor(audio_target=a__	,       padding=a__	,       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
					A__							=							feature_extractor(speech_inputs[0]	,       return_tensors='np'    ).input_values
					A__							=							feature_extractor(np_speech_inputs[0]	,       return_tensors='np'    ).input_values
					self.assertTrue(np.allclose(a__	,       a__	,       atol=1E-3    )    )

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

					# Test 2-D numpy arrays are batched.
					A__							=							[floats_list((1, x)    )[0] for x in (800, 800, 800)]
					A__							=							np.asarray(a__    )
					A__							=							feature_extractor(a__	,       return_tensors='np'    ).input_values
					A__							=							feature_extractor(a__	,       return_tensors='np'    ).input_values
					for enc_seq_a, enc_seq_a in zip(a__	,       a__    ):
									self.assertTrue(np.allclose(a__	,       a__	,       atol=1E-3    )    )


	def    _UpperCAmelCase    (   self    ):


					"""simple docstring"""

					A__							=							self.feat_extract_tester.prepare_inputs_for_target()
					A__							=							self.feature_extraction_class(**self.feat_extract_dict    )
					A__							=							feat_extract.model_input_names[0]

					A__							=							BatchFeature({input_name: speech_inputs}    )

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

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

					A__							=							processed_features[input_name]

					if len(batch_features_input.shape    ) < 3:
									A__							=							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    _UpperCAmelCase    (   self    ):


					"""simple docstring"""

					A__							=							self.feat_extract_tester.prepare_inputs_for_target(equal_length=a__    )
					A__							=							self.feature_extraction_class(**self.feat_extract_dict    )
					A__							=							feat_extract.model_input_names[0]

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

					A__							=							processed_features[input_name]

					if len(batch_features_input.shape    ) < 3:
									A__							=							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    _UpperCAmelCase    (   self    ):


					"""simple docstring"""

					A__							=							self.feature_extraction_class(**self.feat_extract_dict    )
					A__							=							self.feat_extract_tester.prepare_inputs_for_target()
					A__							=							feat_extract.model_input_names[0]

					A__							=							BatchFeature({input_name: speech_inputs}    )

					A__							=							feat_extract.num_mel_bins  # hack!

					A__							=							feat_extract.pad(a__	,       padding='longest'	,       return_tensors='np'    )[input_name]
					A__							=							feat_extract.pad(a__	,       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    _UpperCAmelCase    (   self    ):


					"""simple docstring"""

					A__							=							self.feat_extract_dict
					A__							=							True
					A__							=							self.feature_extraction_class(**a__    )
					A__							=							self.feat_extract_tester.prepare_inputs_for_target()
					A__							=							[len(a__    ) for x in speech_inputs]
					A__							=							feat_extract.model_input_names[0]

					A__							=							BatchFeature({input_name: speech_inputs}    )

					A__							=							feat_extract.num_mel_bins  # hack!

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


	def    _UpperCAmelCase    (   self    ):


					"""simple docstring"""

					A__							=							self.feat_extract_dict
					A__							=							True
					A__							=							self.feature_extraction_class(**a__    )
					A__							=							self.feat_extract_tester.prepare_inputs_for_target()
					A__							=							[len(a__    ) for x in speech_inputs]
					A__							=							feat_extract.model_input_names[0]

					A__							=							BatchFeature({input_name: speech_inputs}    )
					A__							=							min(a__    )

					A__							=							feat_extract.num_mel_bins  # hack!

					A__							=							feat_extract.pad(
					    a__	,       padding='max_length'	,       max_length=a__	,       truncation=a__	,       return_tensors='np'    )
					self.assertIn('attention_mask'	,       a__    )
					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    _UpperCAmelCase    (   self	,       __a    ):


					"""simple docstring"""

					from datasets import load_dataset

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

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


	def    _UpperCAmelCase    (   self    ):


					"""simple docstring"""

					A__							=							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

					A__							=							self._load_datasamples(1    )
					A__							=							SpeechTaFeatureExtractor()
					A__							=							feature_extractor(a__	,       return_tensors='pt'    ).input_values
					self.assertEquals(input_values.shape	,       (1, 9_3680)    )
					self.assertTrue(torch.allclose(input_values[0, :30]	,       a__	,       atol=1E-6    )    )






	def    _UpperCAmelCase    (   self    ):


					"""simple docstring"""

					A__							=							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

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







_lowercase    	=		[0, 2, 4, 6, 8]
_lowercase    	=		[1, 3, 5, 7, 9]



def 		lowerCAmelCase__     (       UpperCamelCase_					:							int			,							UpperCamelCase_					:							int			,							UpperCamelCase_					:							list[int]			,							UpperCamelCase_					:							int						)->	int:
    if remaining_length == 0:
        if digits[0] == 0 or digits[-1] == 0:
            return 0

        for i in range(length // 2 - 1			,							-1			,							-1						):
            remainder += digits[i] + digits[length - i - 1]

            if remainder % 2 == 0:
                return 0

            remainder //= 1_0

        return 1

    if remaining_length == 1:
        if remainder % 2 == 0:
            return 0

        A__					=       0
        for digit in range(1_0						):
            A__					=       digit
            result += reversible_numbers(
                0			,							(remainder + 2 * digit) // 1_0			,							UpperCamelCase_			,							UpperCamelCase_						)
        return result

    A__					=       0
    for digita in range(1_0						):
        A__					=       digita

        if (remainder + digita) % 2 == 0:
            A__					=       ODD_DIGITS
        else:
            A__					=       EVEN_DIGITS

        for digita in other_parity_digits:
            A__					=       digita
            result += reversible_numbers(
                remaining_length - 2			,							(remainder + digita + digita) // 1_0			,							UpperCamelCase_			,							UpperCamelCase_			,							)
    return result



def 		lowerCAmelCase__     (       UpperCamelCase_					:							int = 9						)->	int:
    A__					=       0
    for length in range(1			,							max_power + 1						):
        result += reversible_numbers(UpperCamelCase_			,							0			,							[0] * length			,							UpperCamelCase_						)
    return result


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