






"""simple docstring"""



from copy import deepcopy






class 							__SCREAMING_SNAKE_CASE  :


							def __init__(     self :  str     ,      snake_case :  list[int] | None = None     ,      snake_case :  int | None = None							):
													'''simple docstring'''





													if arr is None and size is not None:
																			A__  :					Union[str, Any]											=					size
																			A__  :					List[str]											=					[0] * size
													elif arr is not None:
																			self.init(snake_case							)
													else:
																			raise ValueError("""Either arr or size must be specified"""							)


							def   _UpperCamelCase    (     self :  int     ,      snake_case :  list[int]							):
													'''simple docstring'''





													A__  :					Optional[Any]											=					len(snake_case							)
													A__  :					str											=					deepcopy(snake_case							)
													for i in range(1     ,      self.size							):
																			A__  :					Dict											=					self.next_(snake_case							)
																			if j < self.size:
																									self.tree[j] += self.tree[i]


							def   _UpperCamelCase    (     self :  Optional[int]							):
													'''simple docstring'''





													A__  :					Dict											=					self.tree[:]
													for i in range(self.size - 1     ,      0     ,      -1							):
																			A__  :					List[str]											=					self.next_(snake_case							)
																			if j < self.size:
																									arr[j] -= arr[i]
													return arr


							@staticmethod
							def   _UpperCamelCase    (     snake_case :  int							):
													'''simple docstring'''





													return index + (index & (-index))


							@staticmethod
							def   _UpperCamelCase    (     snake_case :  int							):
													'''simple docstring'''





													return index - (index & (-index))


							def   _UpperCamelCase    (     self :  Optional[int]     ,      snake_case :  int     ,      snake_case :  int							):
													'''simple docstring'''





													if index == 0:
																			self.tree[0] += value
																			return
													while index < self.size:
																			self.tree[index] += value
																			A__  :					Dict											=					self.next_(snake_case							)


							def   _UpperCamelCase    (     self :  Optional[int]     ,      snake_case :  int     ,      snake_case :  int							):
													'''simple docstring'''





													self.add(snake_case     ,      value - self.get(snake_case							)							)


							def   _UpperCamelCase    (     self :  List[Any]     ,      snake_case :  int							):
													'''simple docstring'''





													if right == 0:
																			return 0
													A__  :					Any											=					self.tree[0]
													right -= 1  # make right inclusive
													while right > 0:
																			result += self.tree[right]
																			A__  :					Optional[Any]											=					self.prev(snake_case							)
													return result


							def   _UpperCamelCase    (     self :  Union[str, Any]     ,      snake_case :  int     ,      snake_case :  int							):
													'''simple docstring'''





													return self.prefix(snake_case							) - self.prefix(snake_case							)


							def   _UpperCamelCase    (     self :  Dict     ,      snake_case :  int							):
													'''simple docstring'''





													return self.query(snake_case     ,      index + 1							)


							def   _UpperCamelCase    (     self :  List[Any]     ,      snake_case :  int							):
													'''simple docstring'''





													value -= self.tree[0]
													if value < 0:
																			return -1

													A__  :					Optional[Any]											=					1  # Largest power of 2 <= size
													while j * 2 < self.size:
																			j *= 2

													A__  :					Tuple											=					0

													while j > 0:
																			if i + j < self.size and self.tree[i + j] <= value:
																									value -= self.tree[i + j]
																									i += j
																			j //= 2
													return i


if __name__ == "__main__":
						import doctest

						doctest.testmod()














"""simple docstring"""



import itertools
import os
import random
import tempfile
import unittest

import numpy as np
from datasets import load_dataset

from transformers import is_speech_available
from transformers.testing_utils import check_json_file_has_correct_format, require_torch, require_torchaudio
from transformers.utils.import_utils import is_torch_available

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


if is_speech_available():
						from transformers import WhisperFeatureExtractor

if is_torch_available():
						import torch

A_      =							random.Random()




def        _lowerCAmelCase						(							UpperCAmelCase__    :   Dict,  UpperCAmelCase__    :   Tuple=1.0,  UpperCAmelCase__    :   Optional[int]=None,  UpperCAmelCase__    :   str=None )						->Union[str, Any]:
						if rng is None:
												A__  :					Optional[int]											=					global_rng

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


							def __init__(     self :  Union[str, Any]     ,      snake_case :  str     ,      snake_case :  List[str]=7     ,      snake_case :  str=400     ,      snake_case :  Optional[Any]=2000     ,      snake_case :  Union[str, Any]=10     ,      snake_case :  str=160     ,      snake_case :  List[str]=8     ,      snake_case :  List[Any]=0.0     ,      snake_case :  Optional[Any]=4000     ,      snake_case :  Any=False     ,      snake_case :  int=True     ,      ):
													'''simple docstring'''





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


							def   _UpperCamelCase    (     self :  Union[str, Any]							):
													'''simple docstring'''





													return {
													    "feature_size": self.feature_size,
													    "hop_length": self.hop_length,
													    "chunk_length": self.chunk_length,
													    "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 :  Union[str, Any]     ,      snake_case :  Dict=False     ,      snake_case :  Optional[Any]=False							):
													'''simple docstring'''





													def _flatten(snake_case :  Dict							):
																			return list(itertools.chain(*snake_case							)							)

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






@require_torch
@require_torchaudio
class 							__SCREAMING_SNAKE_CASE  (			UpperCamelCase    ,						unittest.TestCase						):
							snake_case_       =							WhisperFeatureExtractor if is_speech_available() else None


							def   _UpperCamelCase    (     self :  Dict							):
													'''simple docstring'''





													A__  :					str											=					WhisperFeatureExtractionTester(self							)


							def   _UpperCamelCase    (     self :  int							):
													'''simple docstring'''





													A__  :					Any											=					self.feature_extraction_class(**self.feat_extract_dict							)

													with tempfile.TemporaryDirectory() as tmpdirname:
																			A__  :					List[Any]											=					feat_extract_first.save_pretrained(snake_case							)[0]
																			check_json_file_has_correct_format(snake_case							)
																			A__  :					Union[str, Any]											=					self.feature_extraction_class.from_pretrained(snake_case							)

													A__  :					str											=					feat_extract_first.to_dict()
													A__  :					Union[str, Any]											=					feat_extract_second.to_dict()
													A__  :					List[Any]											=					feat_extract_first.mel_filters
													A__  :					Optional[Any]											=					feat_extract_second.mel_filters
													self.assertTrue(np.allclose(snake_case     ,      snake_case							)							)
													self.assertEqual(snake_case     ,      snake_case							)


							def   _UpperCamelCase    (     self :  Tuple							):
													'''simple docstring'''





													A__  :					Any											=					self.feature_extraction_class(**self.feat_extract_dict							)

													with tempfile.TemporaryDirectory() as tmpdirname:
																			A__  :					Any											=					os.path.join(snake_case     ,      """feat_extract.json"""							)
																			feat_extract_first.to_json_file(snake_case							)
																			A__  :					int											=					self.feature_extraction_class.from_json_file(snake_case							)

													A__  :					Dict											=					feat_extract_first.to_dict()
													A__  :					str											=					feat_extract_second.to_dict()
													A__  :					str											=					feat_extract_first.mel_filters
													A__  :					Dict											=					feat_extract_second.mel_filters
													self.assertTrue(np.allclose(snake_case     ,      snake_case							)							)
													self.assertEqual(snake_case     ,      snake_case							)


							def   _UpperCamelCase    (     self :  Any							):
													'''simple docstring'''





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

													# Test feature size
													A__  :					Dict											=					feature_extractor(snake_case     ,      padding="""max_length"""     ,      return_tensors="""np"""							).input_features
													self.assertTrue(input_features.ndim == 3							)
													self.assertTrue(input_features.shape[-1] == feature_extractor.nb_max_frames							)
													self.assertTrue(input_features.shape[-2] == feature_extractor.feature_size							)

													# Test not batched input
													A__  :					str											=					feature_extractor(speech_inputs[0]     ,      return_tensors="""np"""							).input_features
													A__  :					Optional[int]											=					feature_extractor(np_speech_inputs[0]     ,      return_tensors="""np"""							).input_features
													self.assertTrue(np.allclose(snake_case     ,      snake_case     ,      atol=1e-3							)							)

													# Test batched
													A__  :					List[str]											=					feature_extractor(snake_case     ,      return_tensors="""np"""							).input_features
													A__  :					List[str]											=					feature_extractor(snake_case     ,      return_tensors="""np"""							).input_features
													for enc_seq_a, enc_seq_a in zip(snake_case     ,      snake_case							):
																			self.assertTrue(np.allclose(snake_case     ,      snake_case     ,      atol=1e-3							)							)

													# Test 2-D numpy arrays are batched.
													A__  :					Tuple											=					[floats_list((1, x)							)[0] for x in (800, 800, 800)]
													A__  :					str											=					np.asarray(snake_case							)
													A__  :					List[str]											=					feature_extractor(snake_case     ,      return_tensors="""np"""							).input_features
													A__  :					Optional[int]											=					feature_extractor(snake_case     ,      return_tensors="""np"""							).input_features
													for enc_seq_a, enc_seq_a in zip(snake_case     ,      snake_case							):
																			self.assertTrue(np.allclose(snake_case     ,      snake_case     ,      atol=1e-3							)							)

													# Test truncation required
													A__  :					Optional[Any]											=					[floats_list((1, x)							)[0] for x in range(200     ,      (feature_extractor.n_samples + 500)     ,      200							)]
													A__  :					Union[str, Any]											=					[np.asarray(snake_case							) for speech_input in speech_inputs]

													A__  :					Union[str, Any]											=					[x[: feature_extractor.n_samples] for x in speech_inputs]
													A__  :					str											=					[np.asarray(snake_case							) for speech_input in speech_inputs_truncated]

													A__  :					Optional[int]											=					feature_extractor(snake_case     ,      return_tensors="""np"""							).input_features
													A__  :					str											=					feature_extractor(snake_case     ,      return_tensors="""np"""							).input_features
													for enc_seq_a, enc_seq_a in zip(snake_case     ,      snake_case							):
																			self.assertTrue(np.allclose(snake_case     ,      snake_case     ,      atol=1e-3							)							)


							def   _UpperCamelCase    (     self :  str							):
													'''simple docstring'''





													import torch

													A__  :					Tuple											=					self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()							)
													A__  :					List[str]											=					np.random.rand(100     ,      32							).astype(np.floataa							)
													A__  :					Tuple											=					np_speech_inputs.tolist()

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


							def   _UpperCamelCase    (     self :  Optional[Any]     ,      snake_case :  Optional[int]							):
													'''simple docstring'''





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

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


							def   _UpperCamelCase    (     self :  List[Any]							):
													'''simple docstring'''





													A__  :					str											=					torch.tensor(
													    [
													        0.1193, -0.0946, -0.1098, -0.0196, 0.0225, -0.0690, -0.1736, 0.0951,
													        0.0971, -0.0817, -0.0702, 0.0162, 0.0260, 0.0017, -0.0192, -0.1678,
													        0.0709, -0.1867, -0.0655, -0.0274, -0.0234, -0.1884, -0.0516, -0.0554,
													        -0.0274, -0.1425, -0.1423, 0.0837, 0.0377, -0.0854
													    ]							)
													# fmt: on

													A__  :					Optional[Any]											=					self._load_datasamples(1							)
													A__  :					Union[str, Any]											=					WhisperFeatureExtractor()
													A__  :					List[str]											=					feature_extractor(snake_case     ,      return_tensors="""pt"""							).input_features
													self.assertEqual(input_features.shape     ,      (1, 80, 3000)							)
													self.assertTrue(torch.allclose(input_features[0, 0, :30]     ,      snake_case     ,      atol=1e-4							)							)


							def   _UpperCamelCase    (     self :  Tuple							):
													'''simple docstring'''





													A__  :					Union[str, Any]											=					self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()							)
													A__  :					Union[str, Any]											=					self._load_datasamples(1							)[0]
													A__  :					Any											=					((audio - audio.min()) / (audio.max() - audio.min())) * 6_5535  # Rescale to [0, 65535] to show issue
													A__  :					str											=					feat_extract.zero_mean_unit_var_norm([audio]     ,      attention_mask=snake_case							)[0]

													self.assertTrue(np.all(np.mean(snake_case							) < 1e-3							)							)
													self.assertTrue(np.all(np.abs(np.var(snake_case							) - 1							) < 1e-3							)							)






