



"""simple docstring"""






import itertools
import random
import unittest

import numpy as np

from transformers import ASTFeatureExtractor
from transformers.testing_utils import require_torch, require_torchaudio
from transformers.utils.import_utils import is_torch_available

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


__snake_case							:   Tuple      =    random.Random()

if is_torch_available():
	import torch


def 			_lowercase				(  __snake_case					,__snake_case=1.0					,__snake_case=None					,__snake_case=None	)						->   Union[str, Any]:
			if rng is None:
						__lowerCAmelCase      :  List[str]												=       global_rng

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

			return values



class 			A__   (  unittest.TestCase							):




	'''simple docstring'''





	def __init__(     self:		Union[str, Any]       ,			_SCREAMING_SNAKE_CASE:		Dict       ,			_SCREAMING_SNAKE_CASE:		Tuple=7       ,			_SCREAMING_SNAKE_CASE:		Dict=400       ,			_SCREAMING_SNAKE_CASE:		Optional[int]=2000       ,			_SCREAMING_SNAKE_CASE:		Any=1       ,			_SCREAMING_SNAKE_CASE:		List[str]=0.0       ,			_SCREAMING_SNAKE_CASE:		Union[str, Any]=1_6000       ,			_SCREAMING_SNAKE_CASE:		Tuple=True       ,			_SCREAMING_SNAKE_CASE:		Union[str, Any]=True       ,			)				->       List[Any]:

				"""simple docstring"""

				__lowerCAmelCase      :  Tuple												=       parent
				__lowerCAmelCase      :  Union[str, Any]												=       batch_size
				__lowerCAmelCase      :  Tuple												=       min_seq_length
				__lowerCAmelCase      :  Optional[int]												=       max_seq_length
				__lowerCAmelCase      :  List[Any]												=       (self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
				__lowerCAmelCase      :  Any												=       feature_size
				__lowerCAmelCase      :  Optional[Any]												=       padding_value
				__lowerCAmelCase      :  str												=       sampling_rate
				__lowerCAmelCase      :  Optional[Any]												=       return_attention_mask
				__lowerCAmelCase      :  Dict												=       do_normalize

	def 							_SCREAMING_SNAKE_CASE   (     self:		Optional[int])				->       Dict:

				"""simple docstring"""

				return {
				    "feature_size": self.feature_size,
				    "padding_value": self.padding_value,
				    "sampling_rate": self.sampling_rate,
				    "return_attention_mask": self.return_attention_mask,
				    "do_normalize": self.do_normalize,
				}







	def 							_SCREAMING_SNAKE_CASE   (     self:		str       ,			_SCREAMING_SNAKE_CASE:		List[str]=False       ,			_SCREAMING_SNAKE_CASE:		int=False)				->       Any:

				"""simple docstring"""

				def _flatten(_SCREAMING_SNAKE_CASE:		Union[str, Any]):
							return list(itertools.chain(*_SCREAMING_SNAKE_CASE))

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

				return speech_inputs






@require_torch
@require_torchaudio
class 			A__   (  __SCREAMING_SNAKE_CASE  ,		unittest.TestCase							):




	'''simple docstring'''





	SCREAMING_SNAKE_CASE          =	ASTFeatureExtractor

	def 							_SCREAMING_SNAKE_CASE   (     self:		int)				->       List[str]:

				"""simple docstring"""

				__lowerCAmelCase      :  Optional[Any]												=       ASTFeatureExtractionTester(self)

	def 							_SCREAMING_SNAKE_CASE   (     self:		Optional[int])				->       Optional[int]:

				"""simple docstring"""

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

				# Test not batched input
				__lowerCAmelCase      :  Optional[Any]												=       feat_extract(speech_inputs[0]       ,			return_tensors="np").input_values
				__lowerCAmelCase      :  str												=       feat_extract(np_speech_inputs[0]       ,			return_tensors="np").input_values
				self.assertTrue(np.allclose(_SCREAMING_SNAKE_CASE       ,			_SCREAMING_SNAKE_CASE       ,			atol=1e-3))

				# Test batched
				__lowerCAmelCase      :  Optional[int]												=       feat_extract(_SCREAMING_SNAKE_CASE       ,			padding=_SCREAMING_SNAKE_CASE       ,			return_tensors="np").input_values
				__lowerCAmelCase      :  Any												=       feat_extract(_SCREAMING_SNAKE_CASE       ,			padding=_SCREAMING_SNAKE_CASE       ,			return_tensors="np").input_values
				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.
				__lowerCAmelCase      :  List[Any]												=       [floats_list((1, x))[0] for x in (800, 800, 800)]
				__lowerCAmelCase      :  Optional[int]												=       np.asarray(_SCREAMING_SNAKE_CASE)
				__lowerCAmelCase      :  List[str]												=       feat_extract(_SCREAMING_SNAKE_CASE       ,			return_tensors="np").input_values
				__lowerCAmelCase      :  Tuple												=       feat_extract(_SCREAMING_SNAKE_CASE       ,			return_tensors="np").input_values
				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))

	@require_torch
	def 							_SCREAMING_SNAKE_CASE   (     self:		Dict)				->       Tuple:

				"""simple docstring"""

				import torch

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

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

	def 							_SCREAMING_SNAKE_CASE   (     self:		Dict       ,			_SCREAMING_SNAKE_CASE:		Optional[int])				->       int:

				"""simple docstring"""

				from datasets import load_dataset

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

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







	@require_torch
	def 							_SCREAMING_SNAKE_CASE   (     self:		Dict)				->       Dict:

				"""simple docstring"""

				__lowerCAmelCase      :  Dict												=       torch.tensor(
				    [-0.9894, -1.2776, -0.9066, -1.2776, -0.9349, -1.2609, -1.0386, -1.2776,
				     -1.1561, -1.2776, -1.2052, -1.2723, -1.2190, -1.2132, -1.2776, -1.1133,
				     -1.1953, -1.1343, -1.1584, -1.2203, -1.1770, -1.2474, -1.2381, -1.1936,
				     -0.9270, -0.8317, -0.8049, -0.7706, -0.7565, -0.7869])
				# fmt: on

				__lowerCAmelCase      :  Dict												=       self._load_datasamples(1)
				__lowerCAmelCase      :  Any												=       ASTFeatureExtractor()
				__lowerCAmelCase      :  int												=       feature_extractor(_SCREAMING_SNAKE_CASE       ,			return_tensors="pt").input_values
				self.assertEquals(input_values.shape       ,			(1, 1024, 128))
				self.assertTrue(torch.allclose(input_values[0, 0, :30]       ,			_SCREAMING_SNAKE_CASE       ,			atol=1e-4))




"""simple docstring"""






import os
from math import logaa


def 			_lowercase				(  __snake_case = "base_exp.txt"	)						->   int:
			__lowerCAmelCase      :  float												=       0
			__lowerCAmelCase      :  Any												=       0
			for i, line in enumerate(open(os.path.join(os.path.dirname(__snake_case	)					,__snake_case	)	)	):
						__lowerCAmelCase						,	__lowerCAmelCase      :  List[str]												=       list(map(__snake_case					,line.split(","	)	)	)
						if x * logaa(__snake_case	) > largest:
									__lowerCAmelCase      :  Tuple												=       x * logaa(__snake_case	)
									__lowerCAmelCase      :  Optional[Any]												=       i + 1
			return result


if __name__ == "__main__":
	print(solution())