





"""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


lowerCAmelCase_			=							random.Random()

if is_torch_available():
				import torch

def       __lowerCamelCase    (       SCREAMING_SNAKE_CASE,SCREAMING_SNAKE_CASE=1.0,SCREAMING_SNAKE_CASE=None,SCREAMING_SNAKE_CASE=None							)		->       str:






							"""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



class 	lowerCAmelCase					(      unittest.TestCase							):






							def __init__(   self    ,  a__    ,  a__=7    ,  a__=4_00    ,  a__=20_00    ,  a__=1    ,  a__=0.0    ,  a__=1_60_00    ,  a__=True    ,  a__=True    ,  ):
														_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     =     padding_value
														_UpperCAmelCase     =     sampling_rate
														_UpperCAmelCase     =     return_attention_mask
														_UpperCAmelCase     =     do_normalize






							def 							__A (   self     ):
														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 							__A (   self    ,  a__=False    ,  a__=False     ):
														def _flatten(a__     ):
																					return list(itertools.chain(*lowerCAmelCase_     )     )

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

														return speech_inputs



@require_torch
@require_torchaudio
class 	lowerCAmelCase					(      __lowerCAmelCase			,	unittest.TestCase							):
							lowerCAmelCase__						 =  ASTFeatureExtractor






							def 							__A (   self     ):
														_UpperCAmelCase     =     ASTFeatureExtractionTester(self     )






							def 							__A (   self     ):
														# Tests that all call wrap to encode_plus and batch_encode_plus
														_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_00    ,  14_00    ,  2_00     )]
														_UpperCAmelCase     =     [np.asarray(lowerCAmelCase_     ) for speech_input in speech_inputs]

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

														# Test batched
														_UpperCAmelCase     =     feat_extract(lowerCAmelCase_    ,  padding=lowerCAmelCase_    ,  return_tensors='np'     ).input_values
														_UpperCAmelCase     =     feat_extract(lowerCAmelCase_    ,  padding=lowerCAmelCase_    ,  return_tensors='np'     ).input_values
														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.
														_UpperCAmelCase     =     [floats_list((1, x)     )[0] for x in (8_00, 8_00, 8_00)]
														_UpperCAmelCase     =     np.asarray(lowerCAmelCase_     )
														_UpperCAmelCase     =     feat_extract(lowerCAmelCase_    ,  return_tensors='np'     ).input_values
														_UpperCAmelCase     =     feat_extract(lowerCAmelCase_    ,  return_tensors='np'     ).input_values
														for enc_seq_a, enc_seq_a in zip(lowerCAmelCase_    ,  lowerCAmelCase_     ):
																					self.assertTrue(np.allclose(lowerCAmelCase_    ,  lowerCAmelCase_    ,  atol=1E-3     )     )






							@require_torch
							def 							__A (   self     ):
														import torch

														_UpperCAmelCase     =     self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()     )
														_UpperCAmelCase     =     np.random.rand(1_00     ).astype(np.floataa     )
														_UpperCAmelCase     =     np_speech_inputs.tolist()

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






							def 							__A (   self    ,  a__     ):
														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(lowerCAmelCase_     )     )[:num_samples]['audio']

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






							@require_torch
							def 							__A (   self     ):
														# fmt: off
														_UpperCAmelCase     =     torch.tensor(
														    [-0.9_894, -1.2_776, -0.9_066, -1.2_776, -0.9_349, -1.2_609, -1.0_386, -1.2_776,
														     -1.1_561, -1.2_776, -1.2_052, -1.2_723, -1.2_190, -1.2_132, -1.2_776, -1.1_133,
														     -1.1_953, -1.1_343, -1.1_584, -1.2_203, -1.1_770, -1.2_474, -1.2_381, -1.1_936,
														     -0.9_270, -0.8_317, -0.8_049, -0.7_706, -0.7_565, -0.7_869]     )
														# fmt: on

														_UpperCAmelCase     =     self._load_datasamples(1     )
														_UpperCAmelCase     =     ASTFeatureExtractor()
														_UpperCAmelCase     =     feature_extractor(lowerCAmelCase_    ,  return_tensors='pt'     ).input_values
														self.assertEquals(input_values.shape    ,  (1, 10_24, 1_28)     )
														self.assertTrue(torch.allclose(input_values[0, 0, :30]    ,  lowerCAmelCase_    ,  atol=1E-4     )     )













"""simple docstring"""






def       __lowerCamelCase    (       SCREAMING_SNAKE_CASE,SCREAMING_SNAKE_CASE							)		->       int:






       """simple docstring"""




       return number | (1 << position)

def       __lowerCamelCase    (       SCREAMING_SNAKE_CASE,SCREAMING_SNAKE_CASE							)		->       int:






       """simple docstring"""




       return number & ~(1 << position)

def       __lowerCamelCase    (       SCREAMING_SNAKE_CASE,SCREAMING_SNAKE_CASE							)		->       int:






       """simple docstring"""




       return number ^ (1 << position)

def       __lowerCamelCase    (       SCREAMING_SNAKE_CASE,SCREAMING_SNAKE_CASE							)		->       bool:






       """simple docstring"""




       return ((number >> position) & 1) == 1

def       __lowerCamelCase    (       SCREAMING_SNAKE_CASE,SCREAMING_SNAKE_CASE							)		->       int:






       """simple docstring"""




       return int((number & (1 << position)) != 0							)


if __name__ == "__main__":
    import doctest

    doctest.testmod()






