






import numpy as np

from transformers import BatchFeature
from transformers.testing_utils import require_tf, require_torch

from .test_feature_extraction_common import FeatureExtractionSavingTestMixin


class     __SCREAMING_SNAKE_CASE					(   __lowercase):
						# to overwrite at feature extractactor specific tests
						_SCREAMING_SNAKE_CASE	:       Optional[int]   =					None
						_SCREAMING_SNAKE_CASE	:       List[str]   =					None






						@property
						def       UpperCamelCase__      (	self   ):






												"""simple docstring"""
												return self.feat_extract_tester.prepare_feat_extract_dict()






						def       UpperCamelCase__      (	self   ):






												"""simple docstring"""
												lowerCAmelCase__    						=						self.feature_extraction_class(**self.feat_extract_dict   )
												self.assertTrue(hasattr(_UpperCamelCase     ,						'feature_size'   )   )
												self.assertTrue(hasattr(_UpperCamelCase     ,						'sampling_rate'   )   )
												self.assertTrue(hasattr(_UpperCamelCase     ,						'padding_value'   )   )






						def       UpperCamelCase__      (	self   ):






												"""simple docstring"""
												lowerCAmelCase__    						=						self.feat_extract_tester.prepare_inputs_for_common()
												lowerCAmelCase__    						=						self.feature_extraction_class(**self.feat_extract_dict   )
												lowerCAmelCase__    						=						feat_extract.model_input_names[0]

												lowerCAmelCase__    						=						BatchFeature({input_name: speech_inputs}   )

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

												lowerCAmelCase__    						=						self.feat_extract_tester.prepare_inputs_for_common(equal_length=_UpperCamelCase   )
												lowerCAmelCase__    						=						BatchFeature({input_name: speech_inputs}     ,						tensor_type='np'   )

												lowerCAmelCase__    						=						processed_features[input_name]

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

												self.assertTrue(
												    batch_features_input.shape
												    == (self.feat_extract_tester.batch_size, len(speech_inputs[0]   ), self.feat_extract_tester.feature_size)   )






						@require_torch
						def       UpperCamelCase__      (	self   ):






												"""simple docstring"""
												lowerCAmelCase__    						=						self.feat_extract_tester.prepare_inputs_for_common(equal_length=_UpperCamelCase   )
												lowerCAmelCase__    						=						self.feature_extraction_class(**self.feat_extract_dict   )
												lowerCAmelCase__    						=						feat_extract.model_input_names[0]

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

												lowerCAmelCase__    						=						processed_features[input_name]

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

												self.assertTrue(
												    batch_features_input.shape
												    == (self.feat_extract_tester.batch_size, len(speech_inputs[0]   ), self.feat_extract_tester.feature_size)   )






						@require_tf
						def       UpperCamelCase__      (	self   ):






												"""simple docstring"""
												lowerCAmelCase__    						=						self.feat_extract_tester.prepare_inputs_for_common(equal_length=_UpperCamelCase   )
												lowerCAmelCase__    						=						self.feature_extraction_class(**self.feat_extract_dict   )
												lowerCAmelCase__    						=						feat_extract.model_input_names[0]

												lowerCAmelCase__    						=						BatchFeature({input_name: speech_inputs}     ,						tensor_type='tf'   )

												lowerCAmelCase__    						=						processed_features[input_name]

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

												self.assertTrue(
												    batch_features_input.shape
												    == (self.feat_extract_tester.batch_size, len(speech_inputs[0]   ), self.feat_extract_tester.feature_size)   )






						def       UpperCamelCase__      (	self     ,						_UpperCamelCase=False   ):






												"""simple docstring"""
												def _inputs_have_equal_length(_UpperCamelCase   ):
																		lowerCAmelCase__    						=						len(input[0]   )
																		for input_slice in input[1:]:
																								if len(_UpperCamelCase   ) != length:
																														return False
																		return True

												def _inputs_are_equal(_UpperCamelCase     ,						_UpperCamelCase   ):
																		if len(_UpperCamelCase   ) != len(_UpperCamelCase   ):
																								return False

																		for input_slice_a, input_slice_a in zip(_UpperCamelCase     ,						_UpperCamelCase   ):
																								if not np.allclose(np.asarray(_UpperCamelCase   )     ,						np.asarray(_UpperCamelCase   )     ,						atol=1E-3   ):
																														return False
																		return True

												lowerCAmelCase__    						=						self.feature_extraction_class(**self.feat_extract_dict   )
												lowerCAmelCase__    						=						self.feat_extract_tester.prepare_inputs_for_common(numpify=_UpperCamelCase   )
												lowerCAmelCase__    						=						feat_extract.model_input_names[0]

												lowerCAmelCase__    						=						BatchFeature({input_name: speech_inputs}   )

												lowerCAmelCase__    						=						self.feat_extract_tester.seq_length_diff
												lowerCAmelCase__    						=						self.feat_extract_tester.max_seq_length + pad_diff
												lowerCAmelCase__    						=						self.feat_extract_tester.min_seq_length
												lowerCAmelCase__    						=						self.feat_extract_tester.batch_size
												lowerCAmelCase__    						=						self.feat_extract_tester.feature_size

												# test padding for List[int] + numpy
												lowerCAmelCase__    						=						feat_extract.pad(_UpperCamelCase     ,						padding=_UpperCamelCase   )
												lowerCAmelCase__    						=						input_a[input_name]

												lowerCAmelCase__    						=						feat_extract.pad(_UpperCamelCase     ,						padding='longest'   )
												lowerCAmelCase__    						=						input_a[input_name]

												lowerCAmelCase__    						=						feat_extract.pad(_UpperCamelCase     ,						padding='max_length'     ,						max_length=len(speech_inputs[-1]   )   )
												lowerCAmelCase__    						=						input_a[input_name]

												lowerCAmelCase__    						=						feat_extract.pad(_UpperCamelCase     ,						padding='longest'     ,						return_tensors='np'   )
												lowerCAmelCase__    						=						input_a[input_name]

												# max_length parameter has to be provided when setting `padding="max_length"`
												with self.assertRaises(_UpperCamelCase   ):
																		feat_extract.pad(_UpperCamelCase     ,						padding='max_length'   )[input_name]

												lowerCAmelCase__    						=						feat_extract.pad(
												    _UpperCamelCase     ,						padding='max_length'     ,						max_length=_UpperCamelCase     ,						return_tensors='np'   )
												lowerCAmelCase__    						=						input_a[input_name]

												self.assertFalse(_inputs_have_equal_length(_UpperCamelCase   )   )
												self.assertTrue(_inputs_have_equal_length(_UpperCamelCase   )   )
												self.assertTrue(_inputs_have_equal_length(_UpperCamelCase   )   )
												self.assertTrue(_inputs_are_equal(_UpperCamelCase     ,						_UpperCamelCase   )   )
												self.assertTrue(len(input_a[0]   ) == pad_min_length   )
												self.assertTrue(len(input_a[1]   ) == pad_min_length + pad_diff   )
												self.assertTrue(input_a.shape[:2] == (batch_size, len(input_a[0]   ))   )
												self.assertTrue(input_a.shape[:2] == (batch_size, pad_max_length)   )

												if feature_size > 1:
																		self.assertTrue(input_a.shape[2] == input_a.shape[2] == feature_size   )

												# test padding for `pad_to_multiple_of` for List[int] + numpy
												lowerCAmelCase__    						=						feat_extract.pad(_UpperCamelCase     ,						pad_to_multiple_of=10   )
												lowerCAmelCase__    						=						input_a[input_name]

												lowerCAmelCase__    						=						feat_extract.pad(_UpperCamelCase     ,						padding='longest'     ,						pad_to_multiple_of=10   )
												lowerCAmelCase__    						=						input_a[input_name]

												lowerCAmelCase__    						=						feat_extract.pad(
												    _UpperCamelCase     ,						padding='max_length'     ,						pad_to_multiple_of=10     ,						max_length=_UpperCamelCase   )
												lowerCAmelCase__    						=						input_a[input_name]

												lowerCAmelCase__    						=						feat_extract.pad(
												    _UpperCamelCase     ,						padding='max_length'     ,						pad_to_multiple_of=10     ,						max_length=_UpperCamelCase     ,						return_tensors='np'     ,						)
												lowerCAmelCase__    						=						input_a[input_name]

												self.assertTrue(all(len(_UpperCamelCase   ) % 10 == 0 for x in input_a   )   )
												self.assertTrue(_inputs_are_equal(_UpperCamelCase     ,						_UpperCamelCase   )   )

												lowerCAmelCase__    						=						pad_max_length if pad_max_length % 10 == 0 else (pad_max_length // 10 + 1) * 10
												self.assertTrue(all(len(_UpperCamelCase   ) == expected_mult_pad_length for x in input_a   )   )
												self.assertEqual(input_a.shape[:2]     ,						(batch_size, expected_mult_pad_length)   )

												if feature_size > 1:
																		self.assertTrue(input_a.shape[2] == feature_size   )

												# Check padding value is correct
												lowerCAmelCase__    						=						(np.ones(self.feat_extract_tester.feature_size   ) * feat_extract.padding_value).sum()
												self.assertTrue(
												    abs(np.asarray(input_a[0]   )[pad_min_length:].sum() - padding_vector_sum * (pad_max_length - pad_min_length)   )
												    < 1E-3   )
												self.assertTrue(
												    abs(
												        np.asarray(input_a[1]   )[pad_min_length + pad_diff :].sum()
												        - padding_vector_sum * (pad_max_length - pad_min_length - pad_diff)   )
												    < 1E-3   )
												self.assertTrue(
												    abs(
												        np.asarray(input_a[2]   )[pad_min_length + 2 * pad_diff :].sum()
												        - padding_vector_sum * (pad_max_length - pad_min_length - 2 * pad_diff)   )
												    < 1E-3   )
												self.assertTrue(
												    abs(input_a[0, pad_min_length:].sum() - padding_vector_sum * (pad_max_length - pad_min_length)   ) < 1E-3   )
												self.assertTrue(
												    abs(input_a[0, pad_min_length:].sum() - padding_vector_sum * (expected_mult_pad_length - pad_min_length)   )
												    < 1E-3   )






						def       UpperCamelCase__      (	self     ,						_UpperCamelCase=False   ):






												"""simple docstring"""
												def _inputs_have_equal_length(_UpperCamelCase   ):
																		lowerCAmelCase__    						=						len(input[0]   )
																		for input_slice in input[1:]:
																								if len(_UpperCamelCase   ) != length:
																														return False
																		return True

												def _inputs_are_equal(_UpperCamelCase     ,						_UpperCamelCase   ):
																		if len(_UpperCamelCase   ) != len(_UpperCamelCase   ):
																								return False

																		for input_slice_a, input_slice_a in zip(_UpperCamelCase     ,						_UpperCamelCase   ):
																								if not np.allclose(np.asarray(_UpperCamelCase   )     ,						np.asarray(_UpperCamelCase   )     ,						atol=1E-3   ):
																														return False
																		return True

												lowerCAmelCase__    						=						self.feature_extraction_class(**self.feat_extract_dict   )
												lowerCAmelCase__    						=						self.feat_extract_tester.prepare_inputs_for_common(numpify=_UpperCamelCase   )
												lowerCAmelCase__    						=						feat_extract.model_input_names[0]

												lowerCAmelCase__    						=						BatchFeature({input_name: speech_inputs}   )

												# truncate to smallest
												lowerCAmelCase__    						=						feat_extract.pad(
												    _UpperCamelCase     ,						padding='max_length'     ,						max_length=len(speech_inputs[0]   )     ,						truncation=_UpperCamelCase   )
												lowerCAmelCase__    						=						input_a[input_name]

												lowerCAmelCase__    						=						feat_extract.pad(_UpperCamelCase     ,						padding='max_length'     ,						max_length=len(speech_inputs[0]   )   )
												lowerCAmelCase__    						=						input_a[input_name]

												self.assertTrue(_inputs_have_equal_length(_UpperCamelCase   )   )
												self.assertFalse(_inputs_have_equal_length(_UpperCamelCase   )   )

												# truncate to smallest with np
												lowerCAmelCase__    						=						feat_extract.pad(
												    _UpperCamelCase     ,						padding='max_length'     ,						max_length=len(speech_inputs[0]   )     ,						return_tensors='np'     ,						truncation=_UpperCamelCase     ,						)
												lowerCAmelCase__    						=						input_a[input_name]

												lowerCAmelCase__    						=						feat_extract.pad(
												    _UpperCamelCase     ,						padding='max_length'     ,						max_length=len(speech_inputs[0]   )     ,						return_tensors='np'   )
												lowerCAmelCase__    						=						input_a[input_name]

												self.assertTrue(_inputs_have_equal_length(_UpperCamelCase   )   )
												self.assertTrue(input_a.shape[1] == len(speech_inputs[0]   )   )

												# since truncation forces padding to be smaller than longest input
												# function can't return `np.ndarray`, but has to return list
												self.assertFalse(_inputs_have_equal_length(_UpperCamelCase   )   )

												# truncate to middle
												lowerCAmelCase__    						=						feat_extract.pad(
												    _UpperCamelCase     ,						padding='max_length'     ,						max_length=len(speech_inputs[1]   )     ,						truncation=_UpperCamelCase     ,						return_tensors='np'     ,						)
												lowerCAmelCase__    						=						input_a[input_name]

												lowerCAmelCase__    						=						feat_extract.pad(
												    _UpperCamelCase     ,						padding='max_length'     ,						max_length=len(speech_inputs[1]   )     ,						truncation=_UpperCamelCase   )
												lowerCAmelCase__    						=						input_a[input_name]

												lowerCAmelCase__    						=						feat_extract.pad(
												    _UpperCamelCase     ,						padding='max_length'     ,						max_length=len(speech_inputs[1]   )     ,						return_tensors='np'   )
												lowerCAmelCase__    						=						input_a[input_name]

												self.assertTrue(input_a.shape[1] == len(speech_inputs[1]   )   )
												self.assertTrue(_inputs_have_equal_length(_UpperCamelCase   )   )
												self.assertTrue(_inputs_have_equal_length(_UpperCamelCase   )   )
												self.assertTrue(_inputs_are_equal(_UpperCamelCase     ,						_UpperCamelCase   )   )

												# since truncation forces padding to be smaller than longest input
												# function can't return `np.ndarray`, but has to return list
												self.assertFalse(_inputs_have_equal_length(_UpperCamelCase   )   )
												self.assertTrue(len(input_a[-1]   ) == len(speech_inputs[-1]   )   )

												# padding has to be max_length when setting `truncation=True`
												with self.assertRaises(_UpperCamelCase   ):
																		feat_extract.pad(_UpperCamelCase     ,						truncation=_UpperCamelCase   )[input_name]

												# padding has to be max_length when setting `truncation=True`
												with self.assertRaises(_UpperCamelCase   ):
																		feat_extract.pad(_UpperCamelCase     ,						padding='longest'     ,						truncation=_UpperCamelCase   )[input_name]

												# padding has to be max_length when setting `truncation=True`
												with self.assertRaises(_UpperCamelCase   ):
																		feat_extract.pad(_UpperCamelCase     ,						padding='longest'     ,						truncation=_UpperCamelCase   )[input_name]

												# max_length parameter has to be provided when setting `truncation=True` and padding="max_length"
												with self.assertRaises(_UpperCamelCase   ):
																		feat_extract.pad(_UpperCamelCase     ,						padding='max_length'     ,						truncation=_UpperCamelCase   )[input_name]

												# test truncation for `pad_to_multiple_of` for List[int] + numpy
												lowerCAmelCase__    						=						12
												lowerCAmelCase__    						=						feat_extract.pad(
												    _UpperCamelCase     ,						padding='max_length'     ,						max_length=len(speech_inputs[0]   )     ,						pad_to_multiple_of=_UpperCamelCase     ,						truncation=_UpperCamelCase     ,						)
												lowerCAmelCase__    						=						input_a[input_name]

												lowerCAmelCase__    						=						feat_extract.pad(
												    _UpperCamelCase     ,						padding='max_length'     ,						max_length=len(speech_inputs[0]   )     ,						pad_to_multiple_of=_UpperCamelCase     ,						)
												lowerCAmelCase__    						=						input_a[input_name]

												# retrieve expected_length as multiple of pad_to_multiple_of
												lowerCAmelCase__    						=						len(speech_inputs[0]   )
												if expected_length % pad_to_multiple_of != 0:
																		lowerCAmelCase__    						=						((len(speech_inputs[0]   ) // pad_to_multiple_of) + 1) * pad_to_multiple_of

												self.assertTrue(len(input_a[0]   ) == expected_length   )
												self.assertTrue(_inputs_have_equal_length(_UpperCamelCase   )   )
												self.assertFalse(_inputs_have_equal_length(_UpperCamelCase   )   )






						def       UpperCamelCase__      (	self   ):






												"""simple docstring"""
												self._check_padding(numpify=_UpperCamelCase   )






						def       UpperCamelCase__      (	self   ):






												"""simple docstring"""
												self._check_padding(numpify=_UpperCamelCase   )






						def       UpperCamelCase__      (	self   ):






												"""simple docstring"""
												self._check_truncation(numpify=_UpperCamelCase   )






						def       UpperCamelCase__      (	self   ):






												"""simple docstring"""
												self._check_truncation(numpify=_UpperCamelCase   )






						@require_torch
						def       UpperCamelCase__      (	self   ):






												"""simple docstring"""
												lowerCAmelCase__    						=						self.feature_extraction_class(**self.feat_extract_dict   )
												lowerCAmelCase__    						=						self.feat_extract_tester.prepare_inputs_for_common()
												lowerCAmelCase__    						=						feat_extract.model_input_names[0]

												lowerCAmelCase__    						=						BatchFeature({input_name: speech_inputs}   )

												lowerCAmelCase__    						=						feat_extract.pad(_UpperCamelCase     ,						padding='longest'     ,						return_tensors='np'   )[input_name]
												lowerCAmelCase__    						=						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   )






						@require_tf
						def       UpperCamelCase__      (	self   ):






												"""simple docstring"""
												lowerCAmelCase__    						=						self.feature_extraction_class(**self.feat_extract_dict   )
												lowerCAmelCase__    						=						self.feat_extract_tester.prepare_inputs_for_common()
												lowerCAmelCase__    						=						feat_extract.model_input_names[0]

												lowerCAmelCase__    						=						BatchFeature({input_name: speech_inputs}   )

												lowerCAmelCase__    						=						feat_extract.pad(_UpperCamelCase     ,						padding='longest'     ,						return_tensors='np'   )[input_name]
												lowerCAmelCase__    						=						feat_extract.pad(_UpperCamelCase     ,						padding='longest'     ,						return_tensors='tf'   )[input_name]

												self.assertTrue(abs(input_np.astype(np.floataa   ).sum() - input_tf.numpy().astype(np.floataa   ).sum()   ) < 1E-2   )






						def       UpperCamelCase__      (	self   ):






												"""simple docstring"""
												lowerCAmelCase__    						=						self.feat_extract_dict
												lowerCAmelCase__    						=						True
												lowerCAmelCase__    						=						self.feature_extraction_class(**_UpperCamelCase   )
												lowerCAmelCase__    						=						self.feat_extract_tester.prepare_inputs_for_common()
												lowerCAmelCase__    						=						[len(_UpperCamelCase   ) for x in speech_inputs]
												lowerCAmelCase__    						=						feat_extract.model_input_names[0]

												lowerCAmelCase__    						=						BatchFeature({input_name: speech_inputs}   )

												lowerCAmelCase__    						=						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       UpperCamelCase__      (	self   ):






												"""simple docstring"""
												lowerCAmelCase__    						=						self.feat_extract_dict
												lowerCAmelCase__    						=						True
												lowerCAmelCase__    						=						self.feature_extraction_class(**_UpperCamelCase   )
												lowerCAmelCase__    						=						self.feat_extract_tester.prepare_inputs_for_common()
												lowerCAmelCase__    						=						[len(_UpperCamelCase   ) for x in speech_inputs]
												lowerCAmelCase__    						=						feat_extract.model_input_names[0]

												lowerCAmelCase__    						=						BatchFeature({input_name: speech_inputs}   )
												lowerCAmelCase__    						=						min(_UpperCamelCase   )

												lowerCAmelCase__    						=						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]   )













from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_torch_available


__snake_case    :    Dict         =     {"""configuration_speech_encoder_decoder""": ["""SpeechEncoderDecoderConfig"""]}

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					__snake_case    :    Union[str, Any]         =     ["""SpeechEncoderDecoderModel"""]

try:
					if not is_flax_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					__snake_case    :    str         =     ["""FlaxSpeechEncoderDecoderModel"""]

if TYPE_CHECKING:
					from .configuration_speech_encoder_decoder import SpeechEncoderDecoderConfig

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_speech_encoder_decoder import SpeechEncoderDecoderModel

					try:
										if not is_flax_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_flax_speech_encoder_decoder import FlaxSpeechEncoderDecoderModel

else:
					import sys

					__snake_case    :    Tuple         =     _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)





