




from __future__ import annotations

from random import random
from typing import Generic, TypeVar

__A        =    TypeVar("KT")
__A        =    TypeVar("VT")







class     __lowerCAmelCase (       Generic[KT, VT] ):

			"""simple docstring"""







			def __init__(      self			,						lowerCamelCase__ = "root"			,						lowerCamelCase__ = None							)    ->      Any:



							'''simple docstring'''
							__lowerCamelCase		       =    key
							__lowerCamelCase		       =    value
							__lowerCamelCase		       =    []


			def __repr__(      self							)    ->      str:



							'''simple docstring'''
							return f"""Node({self.key}: {self.value})"""






			@property
			def       lowercase_    (      self							)    ->      int:



							'''simple docstring'''
							return len(self.forward							)







class     __lowerCAmelCase (       Generic[KT, VT] ):

			"""simple docstring"""







			def __init__(      self			,						lowerCamelCase__ = 0.5			,						lowerCamelCase__ = 16							)    ->      Tuple:



							'''simple docstring'''
							__lowerCamelCase		       =    Node[KT, VT]()
							__lowerCamelCase		       =    0
							__lowerCamelCase		       =    p
							__lowerCamelCase		       =    max_level


			def __str__(      self							)    ->      str:



							'''simple docstring'''
							__lowerCamelCase		       =    list(self							)

							if len(lowerCamelCase__							) == 0:
											return f"""SkipList(level={self.level})"""

							__lowerCamelCase		       =    max((len(str(lowerCamelCase__							)							) for item in items)			,						default=4							)
							__lowerCamelCase		       =    max(lowerCamelCase__			,						4							) + 4

							__lowerCamelCase		       =    self.head
							__lowerCamelCase		       =    []

							__lowerCamelCase		       =    node.forward.copy()
							lines.append(f"""[{node.key}]""".ljust(lowerCamelCase__			,						'-'							) + '* ' * len(lowerCamelCase__							)							)
							lines.append(' ' * label_size + '| ' * len(lowerCamelCase__							)							)

							while len(node.forward							) != 0:
											__lowerCamelCase		       =    node.forward[0]

											lines.append(
											    f"""[{node.key}]""".ljust(lowerCamelCase__			,						'-'							)
											    + ' '.join(str(n.key							) if n.key == node.key else '|' for n in forwards							)							)
											lines.append(' ' * label_size + '| ' * len(lowerCamelCase__							)							)
											__lowerCamelCase		       =    node.forward

							lines.append('None'.ljust(lowerCamelCase__							) + '* ' * len(lowerCamelCase__							)							)
							return f"""SkipList(level={self.level})\n""" + "\n".join(lowerCamelCase__							)


			def __iter__(      self							)    ->      List[Any]:



							'''simple docstring'''
							__lowerCamelCase		       =    self.head

							while len(node.forward							) != 0:
											yield node.forward[0].key
											__lowerCamelCase		       =    node.forward[0]


			def       lowercase_    (      self							)    ->      int:



							'''simple docstring'''
							__lowerCamelCase		       =    1
							while random() < self.p and level < self.max_level:
											level += 1

							return level


			def       lowercase_    (      self			,						lowerCamelCase__							)    ->      tuple[Node[KT, VT] | None, list[Node[KT, VT]]]:



							'''simple docstring'''
							__lowerCamelCase		       =    []

							__lowerCamelCase		       =    self.head

							for i in reversed(range(self.level							)							):
											# i < node.level - When node level is lesser than `i` decrement `i`.
											# node.forward[i].key < key - Jumping to node with key value higher
											#                             or equal to searched key would result
											#                             in skipping searched key.
											while i < node.level and node.forward[i].key < key:
															__lowerCamelCase		       =    node.forward[i]
											# Each leftmost node (relative to searched node) will potentially have to
											# be updated.
											update_vector.append(lowerCamelCase__							)

							update_vector.reverse()  # Note that we were inserting values in reverse order.

							# len(node.forward) != 0 - If current node doesn't contain any further
							#                          references then searched key is not present.
							# node.forward[0].key == key - Next node key should be equal to search key
							#                              if key is present.
							if len(node.forward							) != 0 and node.forward[0].key == key:
											return node.forward[0], update_vector
							else:
											return None, update_vector


			def       lowercase_    (      self			,						lowerCamelCase__							)    ->      str:



							'''simple docstring'''
							__lowerCamelCase       ,						__lowerCamelCase		       =    self._locate_node(lowerCamelCase__							)

							if node is not None:
											for i, update_node in enumerate(lowerCamelCase__							):
															# Remove or replace all references to removed node.
															if update_node.level > i and update_node.forward[i].key == key:
																			if node.level > i:
																							__lowerCamelCase		       =    node.forward[i]
																			else:
																							__lowerCamelCase		       =    update_node.forward[:i]


			def       lowercase_    (      self			,						lowerCamelCase__			,						lowerCamelCase__							)    ->      List[Any]:



							'''simple docstring'''
							__lowerCamelCase       ,						__lowerCamelCase		       =    self._locate_node(lowerCamelCase__							)
							if node is not None:
											__lowerCamelCase		       =    value
							else:
											__lowerCamelCase		       =    self.random_level()

											if level > self.level:
															# After level increase we have to add additional nodes to head.
															for _ in range(self.level - 1			,						lowerCamelCase__							):
																			update_vector.append(self.head							)
															__lowerCamelCase		       =    level

											__lowerCamelCase		       =    Node(lowerCamelCase__			,						lowerCamelCase__							)

											for i, update_node in enumerate(update_vector[:level]							):
															# Change references to pass through new node.
															if update_node.level > i:
																			new_node.forward.append(update_node.forward[i]							)

															if update_node.level < i + 1:
																			update_node.forward.append(lowerCamelCase__							)
															else:
																			__lowerCamelCase		       =    new_node






			def       lowercase_    (      self			,						lowerCamelCase__							)    ->      VT | None:



							'''simple docstring'''
							__lowerCamelCase       ,						__lowerCamelCase		       =    self._locate_node(lowerCamelCase__							)

							if node is not None:
											return node.value

							return None







def 			lowerCamelCase_		(       )     ->       List[str]:





				"""simple docstring"""


				__lowerCamelCase		       =    SkipList()
				skip_list.insert('Key1' ,     3      )
				skip_list.insert('Key2' ,     12      )
				skip_list.insert('Key3' ,     41      )
				skip_list.insert('Key4' ,     -19      )

				__lowerCamelCase		       =    skip_list.head
				__lowerCamelCase		       =    {}
				while node.level != 0:
								__lowerCamelCase		       =    node.forward[0]
								__lowerCamelCase		       =    node.value

				assert len(UpperCamelCase__      ) == 4
				assert all_values["Key1"] == 3
				assert all_values["Key2"] == 12
				assert all_values["Key3"] == 41
				assert all_values["Key4"] == -19







def 			lowerCamelCase_		(       )     ->       str:





				"""simple docstring"""


				__lowerCamelCase		       =    SkipList()
				skip_list.insert('Key1' ,     10      )
				skip_list.insert('Key1' ,     12      )

				skip_list.insert('Key5' ,     7      )
				skip_list.insert('Key7' ,     10      )
				skip_list.insert('Key10' ,     5      )

				skip_list.insert('Key7' ,     7      )
				skip_list.insert('Key5' ,     5      )
				skip_list.insert('Key10' ,     10      )

				__lowerCamelCase		       =    skip_list.head
				__lowerCamelCase		       =    {}
				while node.level != 0:
								__lowerCamelCase		       =    node.forward[0]
								__lowerCamelCase		       =    node.value

				if len(UpperCamelCase__      ) != 4:
								print()
				assert len(UpperCamelCase__      ) == 4
				assert all_values["Key1"] == 12
				assert all_values["Key7"] == 7
				assert all_values["Key5"] == 5
				assert all_values["Key10"] == 10







def 			lowerCamelCase_		(       )     ->       Optional[Any]:





				"""simple docstring"""


				__lowerCamelCase		       =    SkipList()
				assert skip_list.find('Some key'      ) is None







def 			lowerCamelCase_		(       )     ->       Optional[int]:





				"""simple docstring"""


				__lowerCamelCase		       =    SkipList()

				skip_list.insert('Key2' ,     20      )
				assert skip_list.find('Key2'      ) == 20

				skip_list.insert('Some Key' ,     10      )
				skip_list.insert('Key2' ,     8      )
				skip_list.insert('V' ,     13      )

				assert skip_list.find('Y'      ) is None
				assert skip_list.find('Key2'      ) == 8
				assert skip_list.find('Some Key'      ) == 10
				assert skip_list.find('V'      ) == 13







def 			lowerCamelCase_		(       )     ->       Any:





				"""simple docstring"""


				__lowerCamelCase		       =    SkipList()
				skip_list.delete('Some key'      )

				assert len(skip_list.head.forward      ) == 0







def 			lowerCamelCase_		(       )     ->       List[Any]:





				"""simple docstring"""


				__lowerCamelCase		       =    SkipList()

				skip_list.insert('Key1' ,     12      )
				skip_list.insert('V' ,     13      )
				skip_list.insert('X' ,     14      )
				skip_list.insert('Key2' ,     15      )

				skip_list.delete('V'      )
				skip_list.delete('Key2'      )

				assert skip_list.find('V'      ) is None
				assert skip_list.find('Key2'      ) is None







def 			lowerCamelCase_		(       )     ->       str:





				"""simple docstring"""


				__lowerCamelCase		       =    SkipList()

				skip_list.insert('Key1' ,     12      )
				skip_list.insert('V' ,     13      )
				skip_list.insert('X' ,     14      )
				skip_list.insert('Key2' ,     15      )

				skip_list.delete('V'      )
				assert skip_list.find('V'      ) is None
				assert skip_list.find('X'      ) == 14
				assert skip_list.find('Key1'      ) == 12
				assert skip_list.find('Key2'      ) == 15

				skip_list.delete('X'      )
				assert skip_list.find('V'      ) is None
				assert skip_list.find('X'      ) is None
				assert skip_list.find('Key1'      ) == 12
				assert skip_list.find('Key2'      ) == 15

				skip_list.delete('Key1'      )
				assert skip_list.find('V'      ) is None
				assert skip_list.find('X'      ) is None
				assert skip_list.find('Key1'      ) is None
				assert skip_list.find('Key2'      ) == 15

				skip_list.delete('Key2'      )
				assert skip_list.find('V'      ) is None
				assert skip_list.find('X'      ) is None
				assert skip_list.find('Key1'      ) is None
				assert skip_list.find('Key2'      ) is None







def 			lowerCamelCase_		(       )     ->       Optional[Any]:





				"""simple docstring"""


				__lowerCamelCase		       =    SkipList()

				skip_list.insert('Key1' ,     12      )
				skip_list.insert('V' ,     13      )
				skip_list.insert('X' ,     142      )
				skip_list.insert('Key2' ,     15      )

				skip_list.delete('X'      )

				def traverse_keys(UpperCamelCase__				:      int      ):
								yield node.key
								for forward_node in node.forward:
												yield from traverse_keys(UpperCamelCase__      )

				assert len(set(traverse_keys(skip_list.head      )      )      ) == 4







def 			lowerCamelCase_		(       )     ->       Optional[Any]:





				"""simple docstring"""


				def is_sorted(UpperCamelCase__				:      Tuple      ):
								return all(next_item >= item for item, next_item in zip(UpperCamelCase__ ,     lst[1:]      )      )

				__lowerCamelCase		       =    SkipList()
				for i in range(10      ):
								skip_list.insert(UpperCamelCase__ ,     UpperCamelCase__      )
				assert is_sorted(list(UpperCamelCase__      )      )
				skip_list.delete(5      )
				skip_list.delete(8      )
				skip_list.delete(2      )
				assert is_sorted(list(UpperCamelCase__      )      )
				skip_list.insert(-12 ,     -12      )
				skip_list.insert(77 ,     77      )
				assert is_sorted(list(UpperCamelCase__      )      )







def 			lowerCamelCase_		(       )     ->       str:





				"""simple docstring"""


				for _ in range(100      ):
								# Repeat test 100 times due to the probabilistic nature of skip list
								# random values == random bugs
								test_insert()
								test_insert_overrides_existing_value()

								test_searching_empty_list_returns_none()
								test_search()

								test_deleting_item_from_empty_list_do_nothing()
								test_deleted_items_are_not_founded_by_find_method()
								test_delete_removes_only_given_key()
								test_delete_doesnt_leave_dead_nodes()

								test_iter_always_yields_sorted_values()







def 			lowerCamelCase_		(       )     ->       Optional[Any]:





				"""simple docstring"""


				__lowerCamelCase		       =    SkipList()
				skip_list.insert(2 ,     '2'      )
				skip_list.insert(4 ,     '4'      )
				skip_list.insert(6 ,     '4'      )
				skip_list.insert(4 ,     '5'      )
				skip_list.insert(8 ,     '4'      )
				skip_list.insert(9 ,     '4'      )

				skip_list.delete(4      )

				print(UpperCamelCase__      )


if __name__ == "__main__":
					import doctest

					doctest.testmod()
					main()








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__				:      Optional[int] ,     UpperCamelCase__				:      List[str]=1.0 ,     UpperCamelCase__				:      Union[str, Any]=None ,     UpperCamelCase__				:      Optional[int]=None      )     ->       Optional[Any]:





				"""simple docstring"""


				if rng is None:
								__lowerCamelCase		       =    global_rng

				__lowerCamelCase		       =    []
				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__=400			,						lowerCamelCase__=2_000			,						lowerCamelCase__=10			,						lowerCamelCase__=160			,						lowerCamelCase__=8			,						lowerCamelCase__=0.0			,						lowerCamelCase__=4_000			,						lowerCamelCase__=False			,						lowerCamelCase__=True			,						)    ->      List[str]:



							'''simple docstring'''
							__lowerCamelCase		       =    parent
							__lowerCamelCase		       =    batch_size
							__lowerCamelCase		       =    min_seq_length
							__lowerCamelCase		       =    max_seq_length
							__lowerCamelCase		       =    (self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
							__lowerCamelCase		       =    padding_value
							__lowerCamelCase		       =    sampling_rate
							__lowerCamelCase		       =    return_attention_mask
							__lowerCamelCase		       =    do_normalize
							__lowerCamelCase		       =    feature_size
							__lowerCamelCase		       =    chunk_length
							__lowerCamelCase		       =    hop_length


			def       lowercase_    (      self							)    ->      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       lowercase_    (      self			,						lowerCamelCase__=False			,						lowerCamelCase__=False							)    ->      Optional[int]:



							'''simple docstring'''
							def _flatten(lowerCamelCase__							):
											return list(itertools.chain(*lowerCamelCase__							)							)

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







@require_torch
@require_torchaudio
class     __lowerCAmelCase (       __magic_name__			,				unittest.TestCase ):

			"""simple docstring"""







			snake_case_   		=       WhisperFeatureExtractor if is_speech_available() else None


			def       lowercase_    (      self							)    ->      Any:



							'''simple docstring'''
							__lowerCamelCase		       =    WhisperFeatureExtractionTester(self							)


			def       lowercase_    (      self							)    ->      List[str]:



							'''simple docstring'''
							__lowerCamelCase		       =    self.feature_extraction_class(**self.feat_extract_dict							)

							with tempfile.TemporaryDirectory() as tmpdirname:
											__lowerCamelCase		       =    feat_extract_first.save_pretrained(lowerCamelCase__							)[0]
											check_json_file_has_correct_format(lowerCamelCase__							)
											__lowerCamelCase		       =    self.feature_extraction_class.from_pretrained(lowerCamelCase__							)

							__lowerCamelCase		       =    feat_extract_first.to_dict()
							__lowerCamelCase		       =    feat_extract_second.to_dict()
							__lowerCamelCase		       =    feat_extract_first.mel_filters
							__lowerCamelCase		       =    feat_extract_second.mel_filters
							self.assertTrue(np.allclose(lowerCamelCase__			,						lowerCamelCase__							)							)
							self.assertEqual(lowerCamelCase__			,						lowerCamelCase__							)


			def       lowercase_    (      self							)    ->      Dict:



							'''simple docstring'''
							__lowerCamelCase		       =    self.feature_extraction_class(**self.feat_extract_dict							)

							with tempfile.TemporaryDirectory() as tmpdirname:
											__lowerCamelCase		       =    os.path.join(lowerCamelCase__			,						'feat_extract.json'							)
											feat_extract_first.to_json_file(lowerCamelCase__							)
											__lowerCamelCase		       =    self.feature_extraction_class.from_json_file(lowerCamelCase__							)

							__lowerCamelCase		       =    feat_extract_first.to_dict()
							__lowerCamelCase		       =    feat_extract_second.to_dict()
							__lowerCamelCase		       =    feat_extract_first.mel_filters
							__lowerCamelCase		       =    feat_extract_second.mel_filters
							self.assertTrue(np.allclose(lowerCamelCase__			,						lowerCamelCase__							)							)
							self.assertEqual(lowerCamelCase__			,						lowerCamelCase__							)


			def       lowercase_    (      self							)    ->      Dict:



							'''simple docstring'''
							# Tests that all call wrap to encode_plus and batch_encode_plus
							__lowerCamelCase		       =    self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()							)
							# create three inputs of length 800, 1000, and 1200
							__lowerCamelCase		       =    [floats_list((1, x)							)[0] for x in range(800			,						1_400			,						200							)]
							__lowerCamelCase		       =    [np.asarray(lowerCamelCase__							) for speech_input in speech_inputs]

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

							# Test batched
							__lowerCamelCase		       =    feature_extractor(lowerCamelCase__			,						return_tensors='np'							).input_features
							__lowerCamelCase		       =    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.
							__lowerCamelCase		       =    [floats_list((1, x)							)[0] for x in (800, 800, 800)]
							__lowerCamelCase		       =    np.asarray(lowerCamelCase__							)
							__lowerCamelCase		       =    feature_extractor(lowerCamelCase__			,						return_tensors='np'							).input_features
							__lowerCamelCase		       =    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 truncation required
							__lowerCamelCase		       =    [floats_list((1, x)							)[0] for x in range(200			,						(feature_extractor.n_samples + 500)			,						200							)]
							__lowerCamelCase		       =    [np.asarray(lowerCamelCase__							) for speech_input in speech_inputs]

							__lowerCamelCase		       =    [x[: feature_extractor.n_samples] for x in speech_inputs]
							__lowerCamelCase		       =    [np.asarray(lowerCamelCase__							) for speech_input in speech_inputs_truncated]

							__lowerCamelCase		       =    feature_extractor(lowerCamelCase__			,						return_tensors='np'							).input_features
							__lowerCamelCase		       =    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       lowercase_    (      self							)    ->      List[str]:



							'''simple docstring'''
							import torch

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

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


			def       lowercase_    (      self			,						lowerCamelCase__							)    ->      List[str]:



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

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


			def       lowercase_    (      self							)    ->      Tuple:



							'''simple docstring'''
							# fmt: off
							__lowerCamelCase		       =    torch.tensor(
							    [
							        0.11_93, -0.09_46, -0.10_98, -0.01_96, 0.02_25, -0.06_90, -0.17_36, 0.09_51,
							        0.09_71, -0.08_17, -0.07_02, 0.01_62, 0.02_60, 0.00_17, -0.01_92, -0.16_78,
							        0.07_09, -0.18_67, -0.06_55, -0.02_74, -0.02_34, -0.18_84, -0.05_16, -0.05_54,
							        -0.02_74, -0.14_25, -0.14_23, 0.08_37, 0.03_77, -0.08_54
							    ]							)
							# fmt: on

							__lowerCamelCase		       =    self._load_datasamples(1							)
							__lowerCamelCase		       =    WhisperFeatureExtractor()
							__lowerCamelCase		       =    feature_extractor(lowerCamelCase__			,						return_tensors='pt'							).input_features
							self.assertEqual(input_features.shape			,						(1, 80, 3_000)							)
							self.assertTrue(torch.allclose(input_features[0, 0, :30]			,						lowerCamelCase__			,						atol=1e-4							)							)






			def       lowercase_    (      self							)    ->      List[Any]:



							'''simple docstring'''
							__lowerCamelCase		       =    self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()							)
							__lowerCamelCase		       =    self._load_datasamples(1							)[0]
							__lowerCamelCase		       =    ((audio - audio.min()) / (audio.max() - audio.min())) * 65_535  # Rescale to [0, 65535] to show issue
							__lowerCamelCase		       =    feat_extract.zero_mean_unit_var_norm([audio]			,						attention_mask=lowerCamelCase__							)[0]

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


