





'''simple docstring'''






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 			lowerCamelCase					(						__UpperCAmelCase  ):
					# to overwrite at feature extractactor specific tests
					_SCREAMING_SNAKE_CASE							   =    None
					_SCREAMING_SNAKE_CASE							   =    None


					@property
					def    SCREAMING_SNAKE_CASE_		(					self	:  str       ):





											'''simple docstring'''





											return self.feat_extract_tester.prepare_feat_extract_dict()


					def    SCREAMING_SNAKE_CASE_		(					self	:  List[str]       ):





											'''simple docstring'''





											_snake_case:   Optional[int]  					=		self.feature_extraction_class(**self.feat_extract_dict       )
											self.assertTrue(hasattr(__snake_case       ,     'feature_size'       )       )
											self.assertTrue(hasattr(__snake_case       ,     'sampling_rate'       )       )
											self.assertTrue(hasattr(__snake_case       ,     'padding_value'       )       )


					def    SCREAMING_SNAKE_CASE_		(					self	:  Optional[Any]       ):





											'''simple docstring'''





											_snake_case:   Optional[Any]  					=		self.feat_extract_tester.prepare_inputs_for_common()
											_snake_case:   Optional[Any]  					=		self.feature_extraction_class(**self.feat_extract_dict       )
											_snake_case:   Union[str, Any]  					=		feat_extract.model_input_names[0]

											_snake_case:   Union[str, Any]  					=		BatchFeature({input_name: speech_inputs}       )

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

											_snake_case:   int  					=		self.feat_extract_tester.prepare_inputs_for_common(equal_length=__snake_case       )
											_snake_case:   List[Any]  					=		BatchFeature({input_name: speech_inputs}       ,     tensor_type='np'       )

											_snake_case:   Union[str, Any]  					=		processed_features[input_name]

											if len(batch_features_input.shape       ) < 3:
																	_snake_case:   List[Any]  					=		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    SCREAMING_SNAKE_CASE_		(					self	:  Tuple       ):





											'''simple docstring'''





											_snake_case:   int  					=		self.feat_extract_tester.prepare_inputs_for_common(equal_length=__snake_case       )
											_snake_case:   Any  					=		self.feature_extraction_class(**self.feat_extract_dict       )
											_snake_case:   Union[str, Any]  					=		feat_extract.model_input_names[0]

											_snake_case:   List[str]  					=		BatchFeature({input_name: speech_inputs}       ,     tensor_type='pt'       )

											_snake_case:   Any  					=		processed_features[input_name]

											if len(batch_features_input.shape       ) < 3:
																	_snake_case:   Dict  					=		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    SCREAMING_SNAKE_CASE_		(					self	:  Union[str, Any]       ):





											'''simple docstring'''





											_snake_case:   Optional[Any]  					=		self.feat_extract_tester.prepare_inputs_for_common(equal_length=__snake_case       )
											_snake_case:   List[str]  					=		self.feature_extraction_class(**self.feat_extract_dict       )
											_snake_case:   List[Any]  					=		feat_extract.model_input_names[0]

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

											_snake_case:   Dict  					=		processed_features[input_name]

											if len(batch_features_input.shape       ) < 3:
																	_snake_case:   List[str]  					=		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    SCREAMING_SNAKE_CASE_		(					self	:  Any       ,     __snake_case	:  Any=False       ):





											'''simple docstring'''





											def _inputs_have_equal_length(__snake_case	:  List[Any]       ):
																	_snake_case:   Union[str, Any]  					=		len(input[0]       )
																	for input_slice in input[1:]:
																							if len(__snake_case       ) != length:
																													return False
																	return True

											def _inputs_are_equal(__snake_case	:  Union[str, Any]       ,     __snake_case	:  str       ):
																	if len(__snake_case       ) != len(__snake_case       ):
																							return False

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

											_snake_case:   Optional[Any]  					=		self.feature_extraction_class(**self.feat_extract_dict       )
											_snake_case:   Dict  					=		self.feat_extract_tester.prepare_inputs_for_common(numpify=__snake_case       )
											_snake_case:   Union[str, Any]  					=		feat_extract.model_input_names[0]

											_snake_case:   Dict  					=		BatchFeature({input_name: speech_inputs}       )

											_snake_case:   Optional[int]  					=		self.feat_extract_tester.seq_length_diff
											_snake_case:   Optional[int]  					=		self.feat_extract_tester.max_seq_length + pad_diff
											_snake_case:   Any  					=		self.feat_extract_tester.min_seq_length
											_snake_case:   Dict  					=		self.feat_extract_tester.batch_size
											_snake_case:   int  					=		self.feat_extract_tester.feature_size

											# test padding for List[int] + numpy
											_snake_case:   Optional[int]  					=		feat_extract.pad(__snake_case       ,     padding=__snake_case       )
											_snake_case:   int  					=		input_a[input_name]

											_snake_case:   Tuple  					=		feat_extract.pad(__snake_case       ,     padding='longest'       )
											_snake_case:   Any  					=		input_a[input_name]

											_snake_case:   Union[str, Any]  					=		feat_extract.pad(__snake_case       ,     padding='max_length'       ,     max_length=len(speech_inputs[-1]       )       )
											_snake_case:   Dict  					=		input_a[input_name]

											_snake_case:   Any  					=		feat_extract.pad(__snake_case       ,     padding='longest'       ,     return_tensors='np'       )
											_snake_case:   int  					=		input_a[input_name]

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

											_snake_case:   Optional[int]  					=		feat_extract.pad(
											    __snake_case       ,     padding='max_length'       ,     max_length=__snake_case       ,     return_tensors='np'       )
											_snake_case:   Tuple  					=		input_a[input_name]

											self.assertFalse(_inputs_have_equal_length(__snake_case       )       )
											self.assertTrue(_inputs_have_equal_length(__snake_case       )       )
											self.assertTrue(_inputs_have_equal_length(__snake_case       )       )
											self.assertTrue(_inputs_are_equal(__snake_case       ,     __snake_case       )       )
											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
											_snake_case:   Union[str, Any]  					=		feat_extract.pad(__snake_case       ,     pad_to_multiple_of=10       )
											_snake_case:   Optional[Any]  					=		input_a[input_name]

											_snake_case:   Optional[int]  					=		feat_extract.pad(__snake_case       ,     padding='longest'       ,     pad_to_multiple_of=10       )
											_snake_case:   List[Any]  					=		input_a[input_name]

											_snake_case:   Tuple  					=		feat_extract.pad(
											    __snake_case       ,     padding='max_length'       ,     pad_to_multiple_of=10       ,     max_length=__snake_case       )
											_snake_case:   List[Any]  					=		input_a[input_name]

											_snake_case:   Optional[int]  					=		feat_extract.pad(
											    __snake_case       ,     padding='max_length'       ,     pad_to_multiple_of=10       ,     max_length=__snake_case       ,     return_tensors='np'       ,     )
											_snake_case:   Optional[int]  					=		input_a[input_name]

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

											_snake_case:   str  					=		pad_max_length if pad_max_length % 10 == 0 else (pad_max_length // 10 + 1) * 10
											self.assertTrue(all(len(__snake_case       ) == 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
											_snake_case:   int  					=		(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    SCREAMING_SNAKE_CASE_		(					self	:  int       ,     __snake_case	:  Any=False       ):





											'''simple docstring'''





											def _inputs_have_equal_length(__snake_case	:  Any       ):
																	_snake_case:   Tuple  					=		len(input[0]       )
																	for input_slice in input[1:]:
																							if len(__snake_case       ) != length:
																													return False
																	return True

											def _inputs_are_equal(__snake_case	:  List[str]       ,     __snake_case	:  Union[str, Any]       ):
																	if len(__snake_case       ) != len(__snake_case       ):
																							return False

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

											_snake_case:   List[str]  					=		self.feature_extraction_class(**self.feat_extract_dict       )
											_snake_case:   Dict  					=		self.feat_extract_tester.prepare_inputs_for_common(numpify=__snake_case       )
											_snake_case:   Any  					=		feat_extract.model_input_names[0]

											_snake_case:   Union[str, Any]  					=		BatchFeature({input_name: speech_inputs}       )

											# truncate to smallest
											_snake_case:   int  					=		feat_extract.pad(
											    __snake_case       ,     padding='max_length'       ,     max_length=len(speech_inputs[0]       )       ,     truncation=__snake_case       )
											_snake_case:   List[str]  					=		input_a[input_name]

											_snake_case:   Any  					=		feat_extract.pad(__snake_case       ,     padding='max_length'       ,     max_length=len(speech_inputs[0]       )       )
											_snake_case:   List[str]  					=		input_a[input_name]

											self.assertTrue(_inputs_have_equal_length(__snake_case       )       )
											self.assertFalse(_inputs_have_equal_length(__snake_case       )       )

											# truncate to smallest with np
											_snake_case:   List[str]  					=		feat_extract.pad(
											    __snake_case       ,     padding='max_length'       ,     max_length=len(speech_inputs[0]       )       ,     return_tensors='np'       ,     truncation=__snake_case       ,     )
											_snake_case:   Any  					=		input_a[input_name]

											_snake_case:   List[Any]  					=		feat_extract.pad(
											    __snake_case       ,     padding='max_length'       ,     max_length=len(speech_inputs[0]       )       ,     return_tensors='np'       )
											_snake_case:   Union[str, Any]  					=		input_a[input_name]

											self.assertTrue(_inputs_have_equal_length(__snake_case       )       )
											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(__snake_case       )       )

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

											_snake_case:   Any  					=		feat_extract.pad(
											    __snake_case       ,     padding='max_length'       ,     max_length=len(speech_inputs[1]       )       ,     truncation=__snake_case       )
											_snake_case:   List[str]  					=		input_a[input_name]

											_snake_case:   Union[str, Any]  					=		feat_extract.pad(
											    __snake_case       ,     padding='max_length'       ,     max_length=len(speech_inputs[1]       )       ,     return_tensors='np'       )
											_snake_case:   int  					=		input_a[input_name]

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

											# 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(__snake_case       )       )
											self.assertTrue(len(input_a[-1]       ) == len(speech_inputs[-1]       )       )

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

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

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

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

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

											_snake_case:   Tuple  					=		feat_extract.pad(
											    __snake_case       ,     padding='max_length'       ,     max_length=len(speech_inputs[0]       )       ,     pad_to_multiple_of=__snake_case       ,     )
											_snake_case:   Tuple  					=		input_a[input_name]

											# retrieve expected_length as multiple of pad_to_multiple_of
											_snake_case:   Tuple  					=		len(speech_inputs[0]       )
											if expected_length % pad_to_multiple_of != 0:
																	_snake_case:   Tuple  					=		((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(__snake_case       )       )
											self.assertFalse(_inputs_have_equal_length(__snake_case       )       )


					def    SCREAMING_SNAKE_CASE_		(					self	:  str       ):





											'''simple docstring'''





											self._check_padding(numpify=__snake_case       )


					def    SCREAMING_SNAKE_CASE_		(					self	:  List[Any]       ):





											'''simple docstring'''





											self._check_padding(numpify=__snake_case       )


					def    SCREAMING_SNAKE_CASE_		(					self	:  Optional[int]       ):





											'''simple docstring'''





											self._check_truncation(numpify=__snake_case       )


					def    SCREAMING_SNAKE_CASE_		(					self	:  Optional[int]       ):





											'''simple docstring'''





											self._check_truncation(numpify=__snake_case       )


					@require_torch
					def    SCREAMING_SNAKE_CASE_		(					self	:  Optional[int]       ):





											'''simple docstring'''





											_snake_case:   Tuple  					=		self.feature_extraction_class(**self.feat_extract_dict       )
											_snake_case:   str  					=		self.feat_extract_tester.prepare_inputs_for_common()
											_snake_case:   List[Any]  					=		feat_extract.model_input_names[0]

											_snake_case:   Optional[Any]  					=		BatchFeature({input_name: speech_inputs}       )

											_snake_case:   str  					=		feat_extract.pad(__snake_case       ,     padding='longest'       ,     return_tensors='np'       )[input_name]
											_snake_case:   str  					=		feat_extract.pad(__snake_case       ,     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    SCREAMING_SNAKE_CASE_		(					self	:  List[str]       ):





											'''simple docstring'''





											_snake_case:   Dict  					=		self.feature_extraction_class(**self.feat_extract_dict       )
											_snake_case:   str  					=		self.feat_extract_tester.prepare_inputs_for_common()
											_snake_case:   Union[str, Any]  					=		feat_extract.model_input_names[0]

											_snake_case:   Tuple  					=		BatchFeature({input_name: speech_inputs}       )

											_snake_case:   List[Any]  					=		feat_extract.pad(__snake_case       ,     padding='longest'       ,     return_tensors='np'       )[input_name]
											_snake_case:   int  					=		feat_extract.pad(__snake_case       ,     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    SCREAMING_SNAKE_CASE_		(					self	:  Optional[Any]       ):





											'''simple docstring'''





											_snake_case:   Optional[int]  					=		self.feat_extract_dict
											_snake_case:   Optional[Any]  					=		True
											_snake_case:   Tuple  					=		self.feature_extraction_class(**__snake_case       )
											_snake_case:   Any  					=		self.feat_extract_tester.prepare_inputs_for_common()
											_snake_case:   List[str]  					=		[len(__snake_case       ) for x in speech_inputs]
											_snake_case:   Optional[Any]  					=		feat_extract.model_input_names[0]

											_snake_case:   Optional[int]  					=		BatchFeature({input_name: speech_inputs}       )

											_snake_case:   Optional[Any]  					=		feat_extract.pad(__snake_case       ,     padding='longest'       ,     return_tensors='np'       )
											self.assertIn('attention_mask'       ,     __snake_case       )
											self.assertListEqual(list(processed.attention_mask.shape       )       ,     list(processed[input_name].shape[:2]       )       )
											self.assertListEqual(processed.attention_mask.sum(-1       ).tolist()       ,     __snake_case       )




					def    SCREAMING_SNAKE_CASE_		(					self	:  Optional[int]       ):





											'''simple docstring'''





											_snake_case:   Any  					=		self.feat_extract_dict
											_snake_case:   Any  					=		True
											_snake_case:   str  					=		self.feature_extraction_class(**__snake_case       )
											_snake_case:   Optional[int]  					=		self.feat_extract_tester.prepare_inputs_for_common()
											_snake_case:   int  					=		[len(__snake_case       ) for x in speech_inputs]
											_snake_case:   Optional[Any]  					=		feat_extract.model_input_names[0]

											_snake_case:   Optional[int]  					=		BatchFeature({input_name: speech_inputs}       )
											_snake_case:   Optional[Any]  					=		min(__snake_case       )

											_snake_case:   Union[str, Any]  					=		feat_extract.pad(
											    __snake_case       ,     padding='max_length'       ,     max_length=__snake_case       ,     truncation=__snake_case       ,     return_tensors='np'       )
											self.assertIn('attention_mask'       ,     __snake_case       )
											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]       )












'''simple docstring'''






A   : List[str]             =			'\n# Transformers 설치 방법\n! pip install transformers datasets\n# 마지막 릴리스 대신 소스에서 설치하려면, 위 명령을 주석으로 바꾸고 아래 명령을 해제하세요.\n# ! pip install git+https://github.com/huggingface/transformers.git\n'

A   : List[str]             =			[{'type': 'code', 'content': INSTALL_CONTENT}]
A   : Dict             =			{
    '{processor_class}': 'FakeProcessorClass',
    '{model_class}': 'FakeModelClass',
    '{object_class}': 'FakeObjectClass',
}





