
import itertools
import random
import unittest

import numpy as np

from transformers import BatchFeature, SpeechTaFeatureExtractor
from transformers.testing_utils import require_torch
from transformers.utils.import_utils import is_torch_available

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


if is_torch_available():
				import torch


__snake_case								=  random.Random()






def 							_lowercase							(     UpperCamelCase_	,	UpperCamelCase_=1.0	,	UpperCamelCase_=None	,	UpperCamelCase_=None		)		->		Any:
					'''simple docstring'''


					if rng is None:
										SCREAMING_SNAKE_CASE__													= global_rng

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

					return values




@require_torch
class 						lowercase__  (						unittest.TestCase  ):
	def __init__(			self							:   List[Any]       ,   UpperCAmelCase_							:   List[str]       ,   UpperCAmelCase_							:   Union[str, Any]=7       ,   UpperCAmelCase_							:   str=400       ,   UpperCAmelCase_							:   int=2000       ,   UpperCAmelCase_							:   List[str]=1       ,   UpperCAmelCase_							:   Optional[Any]=0.0       ,   UpperCAmelCase_							:   Optional[int]=16000       ,   UpperCAmelCase_							:   List[str]=True       ,   UpperCAmelCase_							:   int=80       ,   UpperCAmelCase_							:   int=16       ,   UpperCAmelCase_							:   int=64       ,   UpperCAmelCase_							:   Dict="hann_window"       ,   UpperCAmelCase_							:   str=80       ,   UpperCAmelCase_							:   List[Any]=7600       ,   UpperCAmelCase_							:   Optional[Any]=1e-1_0       ,   UpperCAmelCase_							:   List[str]=True       ,   ):
						SCREAMING_SNAKE_CASE__													= parent
						SCREAMING_SNAKE_CASE__													= batch_size
						SCREAMING_SNAKE_CASE__													= min_seq_length
						SCREAMING_SNAKE_CASE__													= max_seq_length
						SCREAMING_SNAKE_CASE__													= (self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
						SCREAMING_SNAKE_CASE__													= feature_size
						SCREAMING_SNAKE_CASE__													= padding_value
						SCREAMING_SNAKE_CASE__													= sampling_rate
						SCREAMING_SNAKE_CASE__													= do_normalize
						SCREAMING_SNAKE_CASE__													= num_mel_bins
						SCREAMING_SNAKE_CASE__													= hop_length
						SCREAMING_SNAKE_CASE__													= win_length
						SCREAMING_SNAKE_CASE__													= win_function
						SCREAMING_SNAKE_CASE__													= fmin
						SCREAMING_SNAKE_CASE__													= fmax
						SCREAMING_SNAKE_CASE__													= mel_floor
						SCREAMING_SNAKE_CASE__													= return_attention_mask
	def      A_				(			self							:   List[str]							):
						return {
						    "feature_size": self.feature_size,
						    "padding_value": self.padding_value,
						    "sampling_rate": self.sampling_rate,
						    "do_normalize": self.do_normalize,
						    "num_mel_bins": self.num_mel_bins,
						    "hop_length": self.hop_length,
						    "win_length": self.win_length,
						    "win_function": self.win_function,
						    "fmin": self.fmin,
						    "fmax": self.fmax,
						    "mel_floor": self.mel_floor,
						    "return_attention_mask": self.return_attention_mask,
						}
	def      A_				(			self							:   Any       ,   UpperCAmelCase_							:   Optional[Any]=False       ,   UpperCAmelCase_							:   Dict=False							):
						def _flatten(UpperCAmelCase_							:   Optional[int]							):
											return list(itertools.chain(*UpperCAmelCase_							)							)

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

						return speech_inputs





	def      A_				(			self							:   Union[str, Any]       ,   UpperCAmelCase_							:   int=False       ,   UpperCAmelCase_							:   List[str]=False							):
						if equal_length:
											SCREAMING_SNAKE_CASE__													= [floats_list((self.max_seq_length, self.num_mel_bins)							) for _ in range(self.batch_size							)]
						else:
											# make sure that inputs increase in size
											SCREAMING_SNAKE_CASE__													= [
											    floats_list((x, self.num_mel_bins)							)
											    for x in range(self.min_seq_length       ,   self.max_seq_length       ,   self.seq_length_diff							)
											]

						if numpify:
											SCREAMING_SNAKE_CASE__													= [np.asarray(UpperCAmelCase_							) for x in speech_inputs]

						return speech_inputs





@require_torch
class 						lowercase__  (						_UpperCAmelCase     ,       unittest.TestCase  ):
	A__    :   Union[str, Any]				       =SpeechTaFeatureExtractor
	def      A_				(			self							:   str							):
						SCREAMING_SNAKE_CASE__													= SpeechTaFeatureExtractionTester(self							)
	def      A_				(			self							:   str       ,   UpperCAmelCase_							:   Dict							):
						self.assertTrue(np.all(np.mean(UpperCAmelCase_       ,   axis=0							) < 1e-3							)							)
						self.assertTrue(np.all(np.abs(np.var(UpperCAmelCase_       ,   axis=0							) - 1							) < 1e-3							)							)
	def      A_				(			self							:   Tuple							):
						# Tests that all call wrap to encode_plus and batch_encode_plus
						SCREAMING_SNAKE_CASE__													= self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()							)
						# create three inputs of length 800, 1000, and 1200
						SCREAMING_SNAKE_CASE__													= [floats_list((1, x)							)[0] for x in range(800       ,   1400       ,   200							)]
						SCREAMING_SNAKE_CASE__													= [np.asarray(UpperCAmelCase_							) for speech_input in speech_inputs]

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

						# Test batched
						SCREAMING_SNAKE_CASE__													= feat_extract(UpperCAmelCase_       ,   return_tensors='np'							).input_values
						SCREAMING_SNAKE_CASE__													= feat_extract(UpperCAmelCase_       ,   return_tensors='np'							).input_values
						for enc_seq_a, enc_seq_a in zip(UpperCAmelCase_       ,   UpperCAmelCase_							):
											self.assertTrue(np.allclose(UpperCAmelCase_       ,   UpperCAmelCase_       ,   atol=1e-3							)							)
	def      A_				(			self							:   Optional[int]							):
						SCREAMING_SNAKE_CASE__													= self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()							)
						SCREAMING_SNAKE_CASE__													= [floats_list((1, x)							)[0] for x in range(800       ,   1400       ,   200							)]

						SCREAMING_SNAKE_CASE__													= ['longest', 'max_length', 'do_not_pad']
						SCREAMING_SNAKE_CASE__													= [None, 1600, None]
						for max_length, padding in zip(UpperCAmelCase_       ,   UpperCAmelCase_							):
											SCREAMING_SNAKE_CASE__													= feat_extract(UpperCAmelCase_       ,   padding=UpperCAmelCase_       ,   max_length=UpperCAmelCase_       ,   return_tensors='np'							)
											SCREAMING_SNAKE_CASE__													= processed.input_values

											self._check_zero_mean_unit_variance(input_values[0][:800]							)
											self.assertTrue(input_values[0][800:].sum() < 1e-6							)
											self._check_zero_mean_unit_variance(input_values[1][:1000]							)
											self.assertTrue(input_values[0][1000:].sum() < 1e-6							)
											self._check_zero_mean_unit_variance(input_values[2][:1200]							)
	def      A_				(			self							:   Optional[Any]							):
						SCREAMING_SNAKE_CASE__													= self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()							)
						SCREAMING_SNAKE_CASE__													= range(800       ,   1400       ,   200							)
						SCREAMING_SNAKE_CASE__													= [floats_list((1, x)							)[0] for x in lengths]

						SCREAMING_SNAKE_CASE__													= ['longest', 'max_length', 'do_not_pad']
						SCREAMING_SNAKE_CASE__													= [None, 1600, None]

						for max_length, padding in zip(UpperCAmelCase_       ,   UpperCAmelCase_							):
											SCREAMING_SNAKE_CASE__													= feat_extract(UpperCAmelCase_       ,   max_length=UpperCAmelCase_       ,   padding=UpperCAmelCase_							)
											SCREAMING_SNAKE_CASE__													= processed.input_values

											self._check_zero_mean_unit_variance(input_values[0][:800]							)
											self._check_zero_mean_unit_variance(input_values[1][:1000]							)
											self._check_zero_mean_unit_variance(input_values[2][:1200]							)
	def      A_				(			self							:   int							):
						SCREAMING_SNAKE_CASE__													= self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()							)
						SCREAMING_SNAKE_CASE__													= [floats_list((1, x)							)[0] for x in range(800       ,   1400       ,   200							)]
						SCREAMING_SNAKE_CASE__													= feat_extract(
						    UpperCAmelCase_       ,   truncation=UpperCAmelCase_       ,   max_length=1000       ,   padding='max_length'       ,   return_tensors='np'							)
						SCREAMING_SNAKE_CASE__													= processed.input_values

						self._check_zero_mean_unit_variance(input_values[0, :800]							)
						self._check_zero_mean_unit_variance(input_values[1]							)
						self._check_zero_mean_unit_variance(input_values[2]							)
	def      A_				(			self							:   Optional[int]							):
						SCREAMING_SNAKE_CASE__													= self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()							)
						SCREAMING_SNAKE_CASE__													= [floats_list((1, x)							)[0] for x in range(800       ,   1400       ,   200							)]
						SCREAMING_SNAKE_CASE__													= feat_extract(
						    UpperCAmelCase_       ,   truncation=UpperCAmelCase_       ,   max_length=1000       ,   padding='longest'       ,   return_tensors='np'							)
						SCREAMING_SNAKE_CASE__													= processed.input_values

						self._check_zero_mean_unit_variance(input_values[0, :800]							)
						self._check_zero_mean_unit_variance(input_values[1, :1000]							)
						self._check_zero_mean_unit_variance(input_values[2]							)

						# make sure that if max_length < longest -> then pad to max_length
						self.assertTrue(input_values.shape == (3, 1000)							)

						SCREAMING_SNAKE_CASE__													= [floats_list((1, x)							)[0] for x in range(800       ,   1400       ,   200							)]
						SCREAMING_SNAKE_CASE__													= feat_extract(
						    UpperCAmelCase_       ,   truncation=UpperCAmelCase_       ,   max_length=2000       ,   padding='longest'       ,   return_tensors='np'							)
						SCREAMING_SNAKE_CASE__													= processed.input_values

						self._check_zero_mean_unit_variance(input_values[0, :800]							)
						self._check_zero_mean_unit_variance(input_values[1, :1000]							)
						self._check_zero_mean_unit_variance(input_values[2]							)

						# make sure that if max_length > longest -> then pad to longest
						self.assertTrue(input_values.shape == (3, 1200)							)
	def      A_				(			self							:   int							):
						SCREAMING_SNAKE_CASE__													= self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()							)
						SCREAMING_SNAKE_CASE__													= np.random.rand(100							).astype(np.floataa							)
						SCREAMING_SNAKE_CASE__													= np_speech_inputs.tolist()

						for inputs in [py_speech_inputs, np_speech_inputs]:
											SCREAMING_SNAKE_CASE__													= feature_extractor.pad([{'input_values': inputs}]       ,   return_tensors='np'							)
											self.assertTrue(np_processed.input_values.dtype == np.floataa							)
											SCREAMING_SNAKE_CASE__													= feature_extractor.pad([{'input_values': inputs}]       ,   return_tensors='pt'							)
											self.assertTrue(pt_processed.input_values.dtype == torch.floataa							)
	def      A_				(			self							:   Union[str, Any]							):
						# Tests that all call wrap to encode_plus and batch_encode_plus
						SCREAMING_SNAKE_CASE__													= self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()							)
						# create three inputs of length 800, 1000, and 1200
						SCREAMING_SNAKE_CASE__													= [floats_list((1, x)							)[0] for x in range(800       ,   1400       ,   200							)]
						SCREAMING_SNAKE_CASE__													= [np.asarray(UpperCAmelCase_							) for speech_input in speech_inputs]

						# Test feature size
						SCREAMING_SNAKE_CASE__													= feature_extractor(audio_target=UpperCAmelCase_       ,   padding=UpperCAmelCase_       ,   return_tensors='np'							).input_values
						self.assertTrue(input_values.ndim == 3							)
						self.assertTrue(input_values.shape[-1] == feature_extractor.num_mel_bins							)

						# Test not batched input
						SCREAMING_SNAKE_CASE__													= feature_extractor(speech_inputs[0]       ,   return_tensors='np'							).input_values
						SCREAMING_SNAKE_CASE__													= feature_extractor(np_speech_inputs[0]       ,   return_tensors='np'							).input_values
						self.assertTrue(np.allclose(UpperCAmelCase_       ,   UpperCAmelCase_       ,   atol=1e-3							)							)

						# Test batched
						SCREAMING_SNAKE_CASE__													= feature_extractor(UpperCAmelCase_       ,   return_tensors='np'							).input_values
						SCREAMING_SNAKE_CASE__													= feature_extractor(UpperCAmelCase_       ,   return_tensors='np'							).input_values
						for enc_seq_a, enc_seq_a in zip(UpperCAmelCase_       ,   UpperCAmelCase_							):
											self.assertTrue(np.allclose(UpperCAmelCase_       ,   UpperCAmelCase_       ,   atol=1e-3							)							)

						# Test 2-D numpy arrays are batched.
						SCREAMING_SNAKE_CASE__													= [floats_list((1, x)							)[0] for x in (800, 800, 800)]
						SCREAMING_SNAKE_CASE__													= np.asarray(UpperCAmelCase_							)
						SCREAMING_SNAKE_CASE__													= feature_extractor(UpperCAmelCase_       ,   return_tensors='np'							).input_values
						SCREAMING_SNAKE_CASE__													= feature_extractor(UpperCAmelCase_       ,   return_tensors='np'							).input_values
						for enc_seq_a, enc_seq_a in zip(UpperCAmelCase_       ,   UpperCAmelCase_							):
											self.assertTrue(np.allclose(UpperCAmelCase_       ,   UpperCAmelCase_       ,   atol=1e-3							)							)
	def      A_				(			self							:   Dict							):
						SCREAMING_SNAKE_CASE__													= self.feat_extract_tester.prepare_inputs_for_target()
						SCREAMING_SNAKE_CASE__													= self.feature_extraction_class(**self.feat_extract_dict							)
						SCREAMING_SNAKE_CASE__													= feat_extract.model_input_names[0]

						SCREAMING_SNAKE_CASE__													= BatchFeature({input_name: speech_inputs}							)

						self.assertTrue(all(len(UpperCAmelCase_							) == len(UpperCAmelCase_							) for x, y in zip(UpperCAmelCase_       ,   processed_features[input_name]							)							)							)

						SCREAMING_SNAKE_CASE__													= self.feat_extract_tester.prepare_inputs_for_target(equal_length=UpperCAmelCase_							)
						SCREAMING_SNAKE_CASE__													= BatchFeature({input_name: speech_inputs}       ,   tensor_type='np'							)

						SCREAMING_SNAKE_CASE__													= processed_features[input_name]

						if len(batch_features_input.shape							) < 3:
											SCREAMING_SNAKE_CASE__													= batch_features_input[:, :, None]

						self.assertTrue(
						    batch_features_input.shape
						    == (self.feat_extract_tester.batch_size, len(speech_inputs[0]							), self.feat_extract_tester.num_mel_bins)							)
	@require_torch
	def      A_				(			self							:   Union[str, Any]							):
						SCREAMING_SNAKE_CASE__													= self.feat_extract_tester.prepare_inputs_for_target(equal_length=UpperCAmelCase_							)
						SCREAMING_SNAKE_CASE__													= self.feature_extraction_class(**self.feat_extract_dict							)
						SCREAMING_SNAKE_CASE__													= feat_extract.model_input_names[0]

						SCREAMING_SNAKE_CASE__													= BatchFeature({input_name: speech_inputs}       ,   tensor_type='pt'							)

						SCREAMING_SNAKE_CASE__													= processed_features[input_name]

						if len(batch_features_input.shape							) < 3:
											SCREAMING_SNAKE_CASE__													= batch_features_input[:, :, None]

						self.assertTrue(
						    batch_features_input.shape
						    == (self.feat_extract_tester.batch_size, len(speech_inputs[0]							), self.feat_extract_tester.num_mel_bins)							)
	@require_torch
	def      A_				(			self							:   Dict							):
						SCREAMING_SNAKE_CASE__													= self.feature_extraction_class(**self.feat_extract_dict							)
						SCREAMING_SNAKE_CASE__													= self.feat_extract_tester.prepare_inputs_for_target()
						SCREAMING_SNAKE_CASE__													= feat_extract.model_input_names[0]

						SCREAMING_SNAKE_CASE__													= BatchFeature({input_name: speech_inputs}							)

						SCREAMING_SNAKE_CASE__													= feat_extract.num_mel_bins  # hack!

						SCREAMING_SNAKE_CASE__													= feat_extract.pad(UpperCAmelCase_       ,   padding='longest'       ,   return_tensors='np'							)[input_name]
						SCREAMING_SNAKE_CASE__													= feat_extract.pad(UpperCAmelCase_       ,   padding='longest'       ,   return_tensors='pt'							)[input_name]

						self.assertTrue(abs(input_np.astype(np.floataa							).sum() - input_pt.numpy().astype(np.floataa							).sum()							) < 1e-2							)
	def      A_				(			self							:   Tuple							):
						SCREAMING_SNAKE_CASE__													= self.feat_extract_dict
						SCREAMING_SNAKE_CASE__													= True
						SCREAMING_SNAKE_CASE__													= self.feature_extraction_class(**UpperCAmelCase_							)
						SCREAMING_SNAKE_CASE__													= self.feat_extract_tester.prepare_inputs_for_target()
						SCREAMING_SNAKE_CASE__													= [len(UpperCAmelCase_							) for x in speech_inputs]
						SCREAMING_SNAKE_CASE__													= feat_extract.model_input_names[0]

						SCREAMING_SNAKE_CASE__													= BatchFeature({input_name: speech_inputs}							)

						SCREAMING_SNAKE_CASE__													= feat_extract.num_mel_bins  # hack!

						SCREAMING_SNAKE_CASE__													= feat_extract.pad(UpperCAmelCase_       ,   padding='longest'       ,   return_tensors='np'							)
						self.assertIn('attention_mask'       ,   UpperCAmelCase_							)
						self.assertListEqual(list(processed.attention_mask.shape							)       ,   list(processed[input_name].shape[:2]							)							)
						self.assertListEqual(processed.attention_mask.sum(-1							).tolist()       ,   UpperCAmelCase_							)
	def      A_				(			self							:   List[Any]							):
						SCREAMING_SNAKE_CASE__													= self.feat_extract_dict
						SCREAMING_SNAKE_CASE__													= True
						SCREAMING_SNAKE_CASE__													= self.feature_extraction_class(**UpperCAmelCase_							)
						SCREAMING_SNAKE_CASE__													= self.feat_extract_tester.prepare_inputs_for_target()
						SCREAMING_SNAKE_CASE__													= [len(UpperCAmelCase_							) for x in speech_inputs]
						SCREAMING_SNAKE_CASE__													= feat_extract.model_input_names[0]

						SCREAMING_SNAKE_CASE__													= BatchFeature({input_name: speech_inputs}							)
						SCREAMING_SNAKE_CASE__													= min(UpperCAmelCase_							)

						SCREAMING_SNAKE_CASE__													= feat_extract.num_mel_bins  # hack!

						SCREAMING_SNAKE_CASE__													= feat_extract.pad(
						    UpperCAmelCase_       ,   padding='max_length'       ,   max_length=UpperCAmelCase_       ,   truncation=UpperCAmelCase_       ,   return_tensors='np'							)
						self.assertIn('attention_mask'       ,   UpperCAmelCase_							)
						self.assertListEqual(
						    list(processed_pad.attention_mask.shape							)       ,   [processed_pad[input_name].shape[0], max_length]							)
						self.assertListEqual(
						    processed_pad.attention_mask[:, :max_length].sum(-1							).tolist()       ,   [max_length for x in speech_inputs]							)
	def      A_				(			self							:   Optional[int]       ,   UpperCAmelCase_							:   Optional[Any]							):
						from datasets import load_dataset

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

						return [x["array"] for x in speech_samples]
	def      A_				(			self							:   List[str]							):
						# fmt: off
						SCREAMING_SNAKE_CASE__													= torch.tensor(
						    [2.3_8_0_4e-0_3, 2.0_7_5_2e-0_3, 1.9_8_3_6e-0_3, 2.1_0_5_7e-0_3, 1.6_1_7_4e-0_3,
						     3.0_5_1_8e-0_4, 9.1_5_5_3e-0_5, 3.3_5_6_9e-0_4, 9.7_6_5_6e-0_4, 1.8_3_1_1e-0_3,
						     2.0_1_4_2e-0_3, 2.1_0_5_7e-0_3, 1.7_3_9_5e-0_3, 4.5_7_7_6e-0_4, -3.9_6_7_3e-0_4,
						     4.5_7_7_6e-0_4, 1.0_0_7_1e-0_3, 9.1_5_5_3e-0_5, 4.8_8_2_8e-0_4, 1.1_5_9_7e-0_3,
						     7.3_2_4_2e-0_4, 9.4_6_0_4e-0_4, 1.8_0_0_5e-0_3, 1.8_3_1_1e-0_3, 8.8_5_0_1e-0_4,
						     4.2_7_2_5e-0_4, 4.8_8_2_8e-0_4, 7.3_2_4_2e-0_4, 1.0_9_8_6e-0_3, 2.1_0_5_7e-0_3]							)
						# fmt: on

						SCREAMING_SNAKE_CASE__													= self._load_datasamples(1							)
						SCREAMING_SNAKE_CASE__													= SpeechTaFeatureExtractor()
						SCREAMING_SNAKE_CASE__													= feature_extractor(UpperCAmelCase_       ,   return_tensors='pt'							).input_values
						self.assertEquals(input_values.shape       ,   (1, 93680)							)
						self.assertTrue(torch.allclose(input_values[0, :30]       ,   UpperCAmelCase_       ,   atol=1e-6							)							)





	def      A_				(			self							:   Optional[int]							):
						# fmt: off
						SCREAMING_SNAKE_CASE__													= torch.tensor(
						    [-2.6_870, -3.0_104, -3.1_356, -3.5_352, -3.0_044, -3.0_353, -3.4_719, -3.6_777,
						     -3.1_520, -2.9_435, -2.6_553, -2.8_795, -2.9_944, -2.5_921, -3.0_279, -3.0_386,
						     -3.0_864, -3.1_291, -3.2_353, -2.7_444, -2.6_831, -2.7_287, -3.1_761, -3.1_571,
						     -3.2_726, -3.0_582, -3.1_007, -3.4_533, -3.4_695, -3.0_998]							)
						# fmt: on

						SCREAMING_SNAKE_CASE__													= self._load_datasamples(1							)
						SCREAMING_SNAKE_CASE__													= SpeechTaFeatureExtractor()
						SCREAMING_SNAKE_CASE__													= feature_extractor(audio_target=UpperCAmelCase_       ,   return_tensors='pt'							).input_values
						self.assertEquals(input_values.shape       ,   (1, 366, 80)							)
						self.assertTrue(torch.allclose(input_values[0, 0, :30]       ,   UpperCAmelCase_       ,   atol=1e-4							)							)







import warnings
from contextlib import contextmanager

from ...processing_utils import ProcessorMixin
from .feature_extraction_wavaveca import WavaVecaFeatureExtractor
from .tokenization_wavaveca import WavaVecaCTCTokenizer




class 						lowercase__  (						_UpperCAmelCase  ):
	A__    :   Union[str, Any]				       ="""Wav2Vec2FeatureExtractor"""
	A__    :   Any				       ="""AutoTokenizer"""
	def __init__(			self							:   List[Any]       ,   UpperCAmelCase_							:   List[str]       ,   UpperCAmelCase_							:   str							):
						super().__init__(UpperCAmelCase_       ,   UpperCAmelCase_							)
						SCREAMING_SNAKE_CASE__													= self.feature_extractor
						SCREAMING_SNAKE_CASE__													= False
	@classmethod
	def      A_				(			cls							:   Union[str, Any]       ,   UpperCAmelCase_							:   Any       ,   **UpperCAmelCase_							:   Optional[Any]							):
						try:
											return super().from_pretrained(UpperCAmelCase_       ,   **UpperCAmelCase_							)
						except OSError:
											warnings.warn(
											    F'Loading a tokenizer inside {cls.__name__} from a config that does not'
											    ' include a `tokenizer_class` attribute is deprecated and will be '
											    'removed in v5. Please add `\'tokenizer_class\': \'Wav2Vec2CTCTokenizer\'`'
											    ' attribute to either your `config.json` or `tokenizer_config.json` '
											    'file to suppress this warning: '       ,   UpperCAmelCase_       ,   )

											SCREAMING_SNAKE_CASE__													= WavaVecaFeatureExtractor.from_pretrained(UpperCAmelCase_       ,   **UpperCAmelCase_							)
											SCREAMING_SNAKE_CASE__													= WavaVecaCTCTokenizer.from_pretrained(UpperCAmelCase_       ,   **UpperCAmelCase_							)

											return cls(feature_extractor=UpperCAmelCase_       ,   tokenizer=UpperCAmelCase_							)
	def __call__(			self							:   Any       ,   *UpperCAmelCase_							:   Dict       ,   **UpperCAmelCase_							:   Any							):
						# For backward compatibility
						if self._in_target_context_manager:
											return self.current_processor(*UpperCAmelCase_       ,   **UpperCAmelCase_							)

						if "raw_speech" in kwargs:
											warnings.warn('Using `raw_speech` as a keyword argument is deprecated. Use `audio` instead.'							)
											SCREAMING_SNAKE_CASE__													= kwargs.pop('raw_speech'							)
						else:
											SCREAMING_SNAKE_CASE__													= kwargs.pop('audio'       ,   UpperCAmelCase_							)
						SCREAMING_SNAKE_CASE__													= kwargs.pop('sampling_rate'       ,   UpperCAmelCase_							)
						SCREAMING_SNAKE_CASE__													= kwargs.pop('text'       ,   UpperCAmelCase_							)
						if len(UpperCAmelCase_							) > 0:
											SCREAMING_SNAKE_CASE__													= args[0]
											SCREAMING_SNAKE_CASE__													= args[1:]

						if audio is None and text is None:
											raise ValueError('You need to specify either an `audio` or `text` input to process.'							)

						if audio is not None:
											SCREAMING_SNAKE_CASE__													= self.feature_extractor(UpperCAmelCase_       ,   *UpperCAmelCase_       ,   sampling_rate=UpperCAmelCase_       ,   **UpperCAmelCase_							)
						if text is not None:
											SCREAMING_SNAKE_CASE__													= self.tokenizer(UpperCAmelCase_       ,   **UpperCAmelCase_							)

						if text is None:
											return inputs
						elif audio is None:
											return encodings
						else:
											SCREAMING_SNAKE_CASE__													= encodings['input_ids']
											return inputs
	def      A_				(			self							:   List[str]       ,   *UpperCAmelCase_							:   List[Any]       ,   **UpperCAmelCase_							:   Optional[int]							):
						# For backward compatibility
						if self._in_target_context_manager:
											return self.current_processor.pad(*UpperCAmelCase_       ,   **UpperCAmelCase_							)

						SCREAMING_SNAKE_CASE__													= kwargs.pop('input_features'       ,   UpperCAmelCase_							)
						SCREAMING_SNAKE_CASE__													= kwargs.pop('labels'       ,   UpperCAmelCase_							)
						if len(UpperCAmelCase_							) > 0:
											SCREAMING_SNAKE_CASE__													= args[0]
											SCREAMING_SNAKE_CASE__													= args[1:]

						if input_features is not None:
											SCREAMING_SNAKE_CASE__													= self.feature_extractor.pad(UpperCAmelCase_       ,   *UpperCAmelCase_       ,   **UpperCAmelCase_							)
						if labels is not None:
											SCREAMING_SNAKE_CASE__													= self.tokenizer.pad(UpperCAmelCase_       ,   **UpperCAmelCase_							)

						if labels is None:
											return input_features
						elif input_features is None:
											return labels
						else:
											SCREAMING_SNAKE_CASE__													= labels['input_ids']
											return input_features
	def      A_				(			self							:   List[Any]       ,   *UpperCAmelCase_							:   List[str]       ,   **UpperCAmelCase_							:   List[str]							):
						return self.tokenizer.batch_decode(*UpperCAmelCase_       ,   **UpperCAmelCase_							)
	def      A_				(			self							:   Tuple       ,   *UpperCAmelCase_							:   int       ,   **UpperCAmelCase_							:   List[str]							):
						return self.tokenizer.decode(*UpperCAmelCase_       ,   **UpperCAmelCase_							)





	@contextmanager
	def      A_				(			self							:   str							):
						warnings.warn(
						    '`as_target_processor` is deprecated and will be removed in v5 of Transformers. You can process your '
						    'labels by using the argument `text` of the regular `__call__` method (either in the same call as '
						    'your audio inputs, or in a separate call.'							)
						SCREAMING_SNAKE_CASE__													= True
						SCREAMING_SNAKE_CASE__													= self.tokenizer
						yield
						SCREAMING_SNAKE_CASE__													= self.feature_extractor
						SCREAMING_SNAKE_CASE__													= False





