





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

__A				:    Dict       =   random.Random()





def 						__SCREAMING_SNAKE_CASE  (				UpperCamelCase__			,			UpperCamelCase__=1.0			,			UpperCamelCase__=None			,			UpperCamelCase__=None )  ->				Any:







			'''simple docstring'''

			if rng is None:
						UpperCAmelCase   		=				global_rng

			UpperCAmelCase   		=				[]
			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 	A_       (unittest.TestCase			):
	def __init__(    self							,					_A							,					_A=7							,					_A=4_0_0							,					_A=2_0_0_0							,					_A=2_4							,					_A=2_4							,					_A=0.0							,					_A=1_6_0_0_0							,					_A=True							,					_A=True							,					):






				'''simple docstring'''







				UpperCAmelCase   		=				parent
				UpperCAmelCase   		=				batch_size
				UpperCAmelCase   		=				min_seq_length
				UpperCAmelCase   		=				max_seq_length
				UpperCAmelCase   		=				(self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
				UpperCAmelCase   		=				feature_size
				UpperCAmelCase   		=				num_mel_bins
				UpperCAmelCase   		=				padding_value
				UpperCAmelCase   		=				sampling_rate
				UpperCAmelCase   		=				return_attention_mask
				UpperCAmelCase   		=				do_normalize
	def      _lowercase				(    self		):






				'''simple docstring'''







				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      _lowercase				(    self							,					_A=False							,					_A=False		):






				'''simple docstring'''







				def _flatten(_A		):
							return list(itertools.chain(*__SCREAMING_SNAKE_CASE		)		)

				if equal_length:
							UpperCAmelCase   		=				[floats_list((self.max_seq_length, self.feature_size)		) for _ in range(self.batch_size		)]
				else:
							# make sure that inputs increase in size
							UpperCAmelCase   		=				[
							    floats_list((x, self.feature_size)		)
							    for x in range(self.min_seq_length							,					self.max_seq_length							,					self.seq_length_diff		)
							]
				if numpify:
							UpperCAmelCase   		=				[np.asarray(__SCREAMING_SNAKE_CASE		) for x in speech_inputs]
				return speech_inputs

@require_torch
@require_torchaudio
class 	A_       (a_     ,							unittest.TestCase			):
	UpperCAmelCase__					=			SpeechaTextFeatureExtractor if is_speech_available() else None
	def      _lowercase				(    self		):






				'''simple docstring'''







				UpperCAmelCase   		=				SpeechaTextFeatureExtractionTester(self		)
	def      _lowercase				(    self							,					_A		):






				'''simple docstring'''







				self.assertTrue(np.all(np.mean(__SCREAMING_SNAKE_CASE							,					axis=0		) < 1E-3		)		)
				self.assertTrue(np.all(np.abs(np.var(__SCREAMING_SNAKE_CASE							,					axis=0		) - 1		) < 1E-3		)		)
	def      _lowercase				(    self		):






				'''simple docstring'''







				UpperCAmelCase   		=				self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()		)
				# create three inputs of length 800, 1000, and 1200
				UpperCAmelCase   		=				[floats_list((1, x)		)[0] for x in range(8_0_0							,					1_4_0_0							,					2_0_0		)]
				UpperCAmelCase   		=				[np.asarray(__SCREAMING_SNAKE_CASE		) for speech_input in speech_inputs]

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

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

				# Test 2-D numpy arrays are batched.
				UpperCAmelCase   		=				[floats_list((1, x)		)[0] for x in (8_0_0, 8_0_0, 8_0_0)]
				UpperCAmelCase   		=				np.asarray(__SCREAMING_SNAKE_CASE		)
				UpperCAmelCase   		=				feature_extractor(__SCREAMING_SNAKE_CASE							,					return_tensors='''np'''		).input_features
				UpperCAmelCase   		=				feature_extractor(__SCREAMING_SNAKE_CASE							,					return_tensors='''np'''		).input_features
				for enc_seq_a, enc_seq_a in zip(__SCREAMING_SNAKE_CASE							,					__SCREAMING_SNAKE_CASE		):
							self.assertTrue(np.allclose(__SCREAMING_SNAKE_CASE							,					__SCREAMING_SNAKE_CASE							,					atol=1E-3		)		)
	def      _lowercase				(    self		):






				'''simple docstring'''







				UpperCAmelCase   		=				self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()		)
				UpperCAmelCase   		=				[floats_list((1, x)		)[0] for x in range(8_0_0							,					1_4_0_0							,					2_0_0		)]

				UpperCAmelCase   		=				['''longest''', '''max_length''', '''do_not_pad''']
				UpperCAmelCase   		=				[None, 1_6, None]
				for max_length, padding in zip(__SCREAMING_SNAKE_CASE							,					__SCREAMING_SNAKE_CASE		):
							UpperCAmelCase   		=				feature_extractor(
							    __SCREAMING_SNAKE_CASE							,					padding=__SCREAMING_SNAKE_CASE							,					max_length=__SCREAMING_SNAKE_CASE							,					return_attention_mask=__SCREAMING_SNAKE_CASE		)
							UpperCAmelCase   		=				inputs.input_features
							UpperCAmelCase   		=				inputs.attention_mask
							UpperCAmelCase   		=				[np.sum(__SCREAMING_SNAKE_CASE		) 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      _lowercase				(    self		):






				'''simple docstring'''







				UpperCAmelCase   		=				self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()		)
				UpperCAmelCase   		=				[floats_list((1, x)		)[0] for x in range(8_0_0							,					1_4_0_0							,					2_0_0		)]

				UpperCAmelCase   		=				['''longest''', '''max_length''', '''do_not_pad''']
				UpperCAmelCase   		=				[None, 1_6, None]
				for max_length, padding in zip(__SCREAMING_SNAKE_CASE							,					__SCREAMING_SNAKE_CASE		):
							UpperCAmelCase   		=				feature_extractor(
							    __SCREAMING_SNAKE_CASE							,					max_length=__SCREAMING_SNAKE_CASE							,					padding=__SCREAMING_SNAKE_CASE							,					return_tensors='''np'''							,					return_attention_mask=__SCREAMING_SNAKE_CASE		)
							UpperCAmelCase   		=				inputs.input_features
							UpperCAmelCase   		=				inputs.attention_mask
							UpperCAmelCase   		=				[np.sum(__SCREAMING_SNAKE_CASE		) 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      _lowercase				(    self		):






				'''simple docstring'''







				UpperCAmelCase   		=				self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()		)
				UpperCAmelCase   		=				[floats_list((1, x)		)[0] for x in range(8_0_0							,					1_4_0_0							,					2_0_0		)]
				UpperCAmelCase   		=				feature_extractor(
				    __SCREAMING_SNAKE_CASE							,					padding='''max_length'''							,					max_length=4							,					truncation=__SCREAMING_SNAKE_CASE							,					return_tensors='''np'''							,					return_attention_mask=__SCREAMING_SNAKE_CASE							,					)
				UpperCAmelCase   		=				inputs.input_features
				UpperCAmelCase   		=				inputs.attention_mask
				UpperCAmelCase   		=				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      _lowercase				(    self		):






				'''simple docstring'''







				UpperCAmelCase   		=				self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()		)
				UpperCAmelCase   		=				[floats_list((1, x)		)[0] for x in range(8_0_0							,					1_4_0_0							,					2_0_0		)]
				UpperCAmelCase   		=				feature_extractor(
				    __SCREAMING_SNAKE_CASE							,					padding='''longest'''							,					max_length=4							,					truncation=__SCREAMING_SNAKE_CASE							,					return_tensors='''np'''							,					return_attention_mask=__SCREAMING_SNAKE_CASE							,					)
				UpperCAmelCase   		=				inputs.input_features
				UpperCAmelCase   		=				inputs.attention_mask
				UpperCAmelCase   		=				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)		)

				UpperCAmelCase   		=				[floats_list((1, x)		)[0] for x in range(8_0_0							,					1_4_0_0							,					2_0_0		)]
				UpperCAmelCase   		=				feature_extractor(
				    __SCREAMING_SNAKE_CASE							,					padding='''longest'''							,					max_length=1_6							,					truncation=__SCREAMING_SNAKE_CASE							,					return_tensors='''np'''							,					return_attention_mask=__SCREAMING_SNAKE_CASE							,					)
				UpperCAmelCase   		=				inputs.input_features
				UpperCAmelCase   		=				inputs.attention_mask
				UpperCAmelCase   		=				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      _lowercase				(    self		):






				'''simple docstring'''







				import torch

				UpperCAmelCase   		=				self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()		)
				UpperCAmelCase   		=				np.random.rand(1_0_0							,					3_2		).astype(np.floataa		)
				UpperCAmelCase   		=				np_speech_inputs.tolist()

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






				'''simple docstring'''







				from datasets import load_dataset

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

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







	def      _lowercase				(    self		):






				'''simple docstring'''







				UpperCAmelCase   		=				np.array([
				    -1.57_45, -1.77_13, -1.70_20, -1.60_69, -1.22_50, -1.11_05, -0.90_72, -0.82_41,
				    -1.23_10, -0.80_98, -0.33_20, -0.41_01, -0.79_85, -0.49_96, -0.82_13, -0.91_28,
				    -1.04_20, -1.12_86, -1.04_40, -0.79_99, -0.84_05, -1.22_75, -1.54_43, -1.46_25,
				]		)
				# fmt: on

				UpperCAmelCase   		=				self._load_datasamples(1		)
				UpperCAmelCase   		=				self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()		)
				UpperCAmelCase   		=				feature_extractor(__SCREAMING_SNAKE_CASE							,					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]							,					__SCREAMING_SNAKE_CASE							,					atol=1E-4		)		)






'''simple docstring'''



from itertools import count







def    a__       (  a__ = 50						):




     """simple docstring"""


     __SCREAMING_SNAKE_CASE     =      [1] * min_block_length

     for n in count(a__						):
          fill_count_functions.append(1						)

          for block_length in range(a__      ,    n + 1						):
               for block_start in range(n - block_length						):
                    fill_count_functions[n] += fill_count_functions[
                        n - block_start - block_length - 1
                    ]

               fill_count_functions[n] += 1

          if fill_count_functions[n] > 1_00_00_00:
               break

     return n


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






