
"""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_		(a__						):


				"""simple docstring"""



				__UpperCamelCase   :		List[Any]       =     None
				__UpperCamelCase   :		int       =     None



				@property
				def 			__magic_name__					(self					)      ->	int:



											"""simple docstring"""




											return self.feat_extract_tester.prepare_feat_extract_dict()



				def 			__magic_name__					(self					)      ->	int:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: int     =     self.feature_extraction_class(**self.feat_extract_dict					)
											self.assertTrue(hasattr(SCREAMING_SNAKE_CASE__     , """feature_size"""					)					)
											self.assertTrue(hasattr(SCREAMING_SNAKE_CASE__     , """sampling_rate"""					)					)
											self.assertTrue(hasattr(SCREAMING_SNAKE_CASE__     , """padding_value"""					)					)



				def 			__magic_name__					(self					)      ->	int:



											"""simple docstring"""




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

											SCREAMING_SNAKE_CASE__		: Any     =     BatchFeature({input_name: speech_inputs}					)

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

											SCREAMING_SNAKE_CASE__		: Tuple     =     self.feat_extract_tester.prepare_inputs_for_common(equal_length=SCREAMING_SNAKE_CASE__					)
											SCREAMING_SNAKE_CASE__		: List[Any]     =     BatchFeature({input_name: speech_inputs}     , tensor_type="""np"""					)

											SCREAMING_SNAKE_CASE__		: Tuple     =     processed_features[input_name]

											if len(batch_features_input.shape					) < 3:
																		SCREAMING_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 			__magic_name__					(self					)      ->	Dict:



											"""simple docstring"""




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

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

											SCREAMING_SNAKE_CASE__		: Optional[Any]     =     processed_features[input_name]

											if len(batch_features_input.shape					) < 3:
																		SCREAMING_SNAKE_CASE__		: int     =     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 			__magic_name__					(self					)      ->	Any:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: str     =     self.feat_extract_tester.prepare_inputs_for_common(equal_length=SCREAMING_SNAKE_CASE__					)
											SCREAMING_SNAKE_CASE__		: List[str]     =     self.feature_extraction_class(**self.feat_extract_dict					)
											SCREAMING_SNAKE_CASE__		: Dict     =     feat_extract.model_input_names[0]

											SCREAMING_SNAKE_CASE__		: List[Any]     =     BatchFeature({input_name: speech_inputs}     , tensor_type="""tf"""					)

											SCREAMING_SNAKE_CASE__		: str     =     processed_features[input_name]

											if len(batch_features_input.shape					) < 3:
																		SCREAMING_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)					)



				def 			__magic_name__					(self     , SCREAMING_SNAKE_CASE__=False					)      ->	Union[str, Any]:



											"""simple docstring"""




											def _inputs_have_equal_length(SCREAMING_SNAKE_CASE__					):
																		SCREAMING_SNAKE_CASE__		: int     =     len(input[0]					)
																		for input_slice in input[1:]:
																									if len(SCREAMING_SNAKE_CASE__					) != length:
																																return False
																		return True

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

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

											SCREAMING_SNAKE_CASE__		: Tuple     =     self.feature_extraction_class(**self.feat_extract_dict					)
											SCREAMING_SNAKE_CASE__		: Any     =     self.feat_extract_tester.prepare_inputs_for_common(numpify=SCREAMING_SNAKE_CASE__					)
											SCREAMING_SNAKE_CASE__		: Dict     =     feat_extract.model_input_names[0]

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

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

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

											SCREAMING_SNAKE_CASE__		: Optional[Any]     =     feat_extract.pad(SCREAMING_SNAKE_CASE__     , padding="""longest"""					)
											SCREAMING_SNAKE_CASE__		: Optional[Any]     =     input_a[input_name]

											SCREAMING_SNAKE_CASE__		: Optional[int]     =     feat_extract.pad(SCREAMING_SNAKE_CASE__     , padding="""max_length"""     , max_length=len(speech_inputs[-1]					)					)
											SCREAMING_SNAKE_CASE__		: Tuple     =     input_a[input_name]

											SCREAMING_SNAKE_CASE__		: List[str]     =     feat_extract.pad(SCREAMING_SNAKE_CASE__     , padding="""longest"""     , return_tensors="""np"""					)
											SCREAMING_SNAKE_CASE__		: Dict     =     input_a[input_name]

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

											SCREAMING_SNAKE_CASE__		: Tuple     =     feat_extract.pad(
											    SCREAMING_SNAKE_CASE__     , padding="""max_length"""     , max_length=SCREAMING_SNAKE_CASE__     , return_tensors="""np"""					)
											SCREAMING_SNAKE_CASE__		: int     =     input_a[input_name]

											self.assertFalse(_inputs_have_equal_length(SCREAMING_SNAKE_CASE__					)					)
											self.assertTrue(_inputs_have_equal_length(SCREAMING_SNAKE_CASE__					)					)
											self.assertTrue(_inputs_have_equal_length(SCREAMING_SNAKE_CASE__					)					)
											self.assertTrue(_inputs_are_equal(SCREAMING_SNAKE_CASE__     , SCREAMING_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
											SCREAMING_SNAKE_CASE__		: Any     =     feat_extract.pad(SCREAMING_SNAKE_CASE__     , pad_to_multiple_of=10					)
											SCREAMING_SNAKE_CASE__		: Tuple     =     input_a[input_name]

											SCREAMING_SNAKE_CASE__		: int     =     feat_extract.pad(SCREAMING_SNAKE_CASE__     , padding="""longest"""     , pad_to_multiple_of=10					)
											SCREAMING_SNAKE_CASE__		: List[str]     =     input_a[input_name]

											SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     feat_extract.pad(
											    SCREAMING_SNAKE_CASE__     , padding="""max_length"""     , pad_to_multiple_of=10     , max_length=SCREAMING_SNAKE_CASE__					)
											SCREAMING_SNAKE_CASE__		: Tuple     =     input_a[input_name]

											SCREAMING_SNAKE_CASE__		: Tuple     =     feat_extract.pad(
											    SCREAMING_SNAKE_CASE__     , padding="""max_length"""     , pad_to_multiple_of=10     , max_length=SCREAMING_SNAKE_CASE__     , return_tensors="""np"""     , )
											SCREAMING_SNAKE_CASE__		: str     =     input_a[input_name]

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

											SCREAMING_SNAKE_CASE__		: str     =     pad_max_length if pad_max_length % 10 == 0 else (pad_max_length // 10 + 1) * 10
											self.assertTrue(all(len(SCREAMING_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
											SCREAMING_SNAKE_CASE__		: Optional[Any]     =     (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 			__magic_name__					(self     , SCREAMING_SNAKE_CASE__=False					)      ->	List[str]:



											"""simple docstring"""




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

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

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

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

											SCREAMING_SNAKE_CASE__		: int     =     BatchFeature({input_name: speech_inputs}					)

											# truncate to smallest
											SCREAMING_SNAKE_CASE__		: Optional[Any]     =     feat_extract.pad(
											    SCREAMING_SNAKE_CASE__     , padding="""max_length"""     , max_length=len(speech_inputs[0]					)     , truncation=SCREAMING_SNAKE_CASE__					)
											SCREAMING_SNAKE_CASE__		: Any     =     input_a[input_name]

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

											self.assertTrue(_inputs_have_equal_length(SCREAMING_SNAKE_CASE__					)					)
											self.assertFalse(_inputs_have_equal_length(SCREAMING_SNAKE_CASE__					)					)

											# truncate to smallest with np
											SCREAMING_SNAKE_CASE__		: Dict     =     feat_extract.pad(
											    SCREAMING_SNAKE_CASE__     , padding="""max_length"""     , max_length=len(speech_inputs[0]					)     , return_tensors="""np"""     , truncation=SCREAMING_SNAKE_CASE__     , )
											SCREAMING_SNAKE_CASE__		: List[str]     =     input_a[input_name]

											SCREAMING_SNAKE_CASE__		: Optional[int]     =     feat_extract.pad(
											    SCREAMING_SNAKE_CASE__     , padding="""max_length"""     , max_length=len(speech_inputs[0]					)     , return_tensors="""np"""					)
											SCREAMING_SNAKE_CASE__		: Dict     =     input_a[input_name]

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

											# truncate to middle
											SCREAMING_SNAKE_CASE__		: Optional[int]     =     feat_extract.pad(
											    SCREAMING_SNAKE_CASE__     , padding="""max_length"""     , max_length=len(speech_inputs[1]					)     , truncation=SCREAMING_SNAKE_CASE__     , return_tensors="""np"""     , )
											SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     input_a[input_name]

											SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     feat_extract.pad(
											    SCREAMING_SNAKE_CASE__     , padding="""max_length"""     , max_length=len(speech_inputs[1]					)     , truncation=SCREAMING_SNAKE_CASE__					)
											SCREAMING_SNAKE_CASE__		: Dict     =     input_a[input_name]

											SCREAMING_SNAKE_CASE__		: int     =     feat_extract.pad(
											    SCREAMING_SNAKE_CASE__     , padding="""max_length"""     , max_length=len(speech_inputs[1]					)     , return_tensors="""np"""					)
											SCREAMING_SNAKE_CASE__		: Optional[int]     =     input_a[input_name]

											self.assertTrue(input_a.shape[1] == len(speech_inputs[1]					)					)
											self.assertTrue(_inputs_have_equal_length(SCREAMING_SNAKE_CASE__					)					)
											self.assertTrue(_inputs_have_equal_length(SCREAMING_SNAKE_CASE__					)					)
											self.assertTrue(_inputs_are_equal(SCREAMING_SNAKE_CASE__     , SCREAMING_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(SCREAMING_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(SCREAMING_SNAKE_CASE__					):
																		feat_extract.pad(SCREAMING_SNAKE_CASE__     , truncation=SCREAMING_SNAKE_CASE__					)[input_name]

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

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

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

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

											SCREAMING_SNAKE_CASE__		: Dict     =     feat_extract.pad(
											    SCREAMING_SNAKE_CASE__     , padding="""max_length"""     , max_length=len(speech_inputs[0]					)     , pad_to_multiple_of=SCREAMING_SNAKE_CASE__     , )
											SCREAMING_SNAKE_CASE__		: Optional[int]     =     input_a[input_name]

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



				def 			__magic_name__					(self					)      ->	Optional[int]:



											"""simple docstring"""




											self._check_padding(numpify=SCREAMING_SNAKE_CASE__					)



				def 			__magic_name__					(self					)      ->	str:



											"""simple docstring"""




											self._check_padding(numpify=SCREAMING_SNAKE_CASE__					)



				def 			__magic_name__					(self					)      ->	Any:



											"""simple docstring"""




											self._check_truncation(numpify=SCREAMING_SNAKE_CASE__					)



				def 			__magic_name__					(self					)      ->	int:



											"""simple docstring"""




											self._check_truncation(numpify=SCREAMING_SNAKE_CASE__					)



				@require_torch
				def 			__magic_name__					(self					)      ->	Tuple:



											"""simple docstring"""




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

											SCREAMING_SNAKE_CASE__		: str     =     BatchFeature({input_name: speech_inputs}					)

											SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     feat_extract.pad(SCREAMING_SNAKE_CASE__     , padding="""longest"""     , return_tensors="""np"""					)[input_name]
											SCREAMING_SNAKE_CASE__		: List[str]     =     feat_extract.pad(SCREAMING_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 			__magic_name__					(self					)      ->	List[Any]:



											"""simple docstring"""




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

											SCREAMING_SNAKE_CASE__		: str     =     BatchFeature({input_name: speech_inputs}					)

											SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     feat_extract.pad(SCREAMING_SNAKE_CASE__     , padding="""longest"""     , return_tensors="""np"""					)[input_name]
											SCREAMING_SNAKE_CASE__		: Optional[int]     =     feat_extract.pad(SCREAMING_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 			__magic_name__					(self					)      ->	Optional[int]:



											"""simple docstring"""




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

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

											SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     feat_extract.pad(SCREAMING_SNAKE_CASE__     , padding="""longest"""     , return_tensors="""np"""					)
											self.assertIn("""attention_mask"""     , SCREAMING_SNAKE_CASE__					)
											self.assertListEqual(list(processed.attention_mask.shape					)     , list(processed[input_name].shape[:2]					)					)
											self.assertListEqual(processed.attention_mask.sum(-1					).tolist()     , SCREAMING_SNAKE_CASE__					)



				def 			__magic_name__					(self					)      ->	Any:



											"""simple docstring"""




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

											SCREAMING_SNAKE_CASE__		: int     =     BatchFeature({input_name: speech_inputs}					)
											SCREAMING_SNAKE_CASE__		: Any     =     min(SCREAMING_SNAKE_CASE__					)

											SCREAMING_SNAKE_CASE__		: Dict     =     feat_extract.pad(
											    SCREAMING_SNAKE_CASE__     , padding="""max_length"""     , max_length=SCREAMING_SNAKE_CASE__     , truncation=SCREAMING_SNAKE_CASE__     , return_tensors="""np"""					)
											self.assertIn("""attention_mask"""     , SCREAMING_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"""




import doctest
import logging
import os
import unittest
from pathlib import Path
from typing import List, Union

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


UpperCAmelCase__   :					Any												=				logging.getLogger()



@unittest.skip('''Temporarily disable the doc tests.'''						)
@require_torch
@require_tf
@slow
class 			lowerCAmelCase_		(unittest.TestCase						):


				"""simple docstring"""



				def 			__magic_name__					(self     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__ = None     , SCREAMING_SNAKE_CASE__ = None     , SCREAMING_SNAKE_CASE__ = None     , SCREAMING_SNAKE_CASE__ = True     , )      ->	int:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: Tuple     =     [file for file in os.listdir(SCREAMING_SNAKE_CASE__					) if os.path.isfile(os.path.join(SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					)					)]

											if identifier is not None:
																		SCREAMING_SNAKE_CASE__		: int     =     [file for file in files if identifier in file]

											if n_identifier is not None:
																		if isinstance(SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					):
																									for n_ in n_identifier:
																																SCREAMING_SNAKE_CASE__		: Optional[Any]     =     [file for file in files if n_ not in file]
																		else:
																									SCREAMING_SNAKE_CASE__		: List[Any]     =     [file for file in files if n_identifier not in file]

											SCREAMING_SNAKE_CASE__		: int     =     ignore_files or []
											ignore_files.append("""__init__.py"""					)
											SCREAMING_SNAKE_CASE__		: Optional[int]     =     [file for file in files if file not in ignore_files]

											for file in files:
																		# Open all files
																		print("""Testing"""     , SCREAMING_SNAKE_CASE__					)

																		if only_modules:
																									SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     file.split("""."""					)[0]
																									try:
																																SCREAMING_SNAKE_CASE__		: Optional[Any]     =     getattr(SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					)
																																SCREAMING_SNAKE_CASE__		: Optional[int]     =     doctest.DocTestSuite(SCREAMING_SNAKE_CASE__					)
																																SCREAMING_SNAKE_CASE__		: int     =     unittest.TextTestRunner().run(SCREAMING_SNAKE_CASE__					)
																																self.assertIs(len(result.failures					)     , 0					)
																									except AttributeError:
																																logger.info(F'''{module_identifier} is not a module.'''					)
																		else:
																									SCREAMING_SNAKE_CASE__		: Optional[int]     =     doctest.testfile(str("""..""" / directory / file					)     , optionflags=doctest.ELLIPSIS					)
																									self.assertIs(result.failed     , 0					)



				def 			__magic_name__					(self					)      ->	Any:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: Optional[int]     =     Path("""src/transformers"""					)
											SCREAMING_SNAKE_CASE__		: Optional[int]     =     """modeling"""
											SCREAMING_SNAKE_CASE__		: int     =     [
											    """modeling_ctrl.py""",
											    """modeling_tf_ctrl.py""",
											]
											self.analyze_directory(SCREAMING_SNAKE_CASE__     , identifier=SCREAMING_SNAKE_CASE__     , ignore_files=SCREAMING_SNAKE_CASE__					)



				def 			__magic_name__					(self					)      ->	str:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: str     =     Path("""src/transformers"""					)
											SCREAMING_SNAKE_CASE__		: List[str]     =     """tokenization"""
											self.analyze_directory(SCREAMING_SNAKE_CASE__     , identifier=SCREAMING_SNAKE_CASE__					)



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



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: List[Any]     =     Path("""src/transformers"""					)
											SCREAMING_SNAKE_CASE__		: List[str]     =     """configuration"""
											self.analyze_directory(SCREAMING_SNAKE_CASE__     , identifier=SCREAMING_SNAKE_CASE__					)



				def 			__magic_name__					(self					)      ->	Optional[int]:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     Path("""src/transformers"""					)
											SCREAMING_SNAKE_CASE__		: Dict     =     ["""configuration""", """modeling""", """tokenization"""]
											self.analyze_directory(SCREAMING_SNAKE_CASE__     , n_identifier=SCREAMING_SNAKE_CASE__					)



				def 			__magic_name__					(self					)      ->	Optional[int]:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: Optional[int]     =     Path("""docs/source"""					)
											SCREAMING_SNAKE_CASE__		: Any     =     ["""favicon.ico"""]
											self.analyze_directory(SCREAMING_SNAKE_CASE__     , ignore_files=SCREAMING_SNAKE_CASE__     , only_modules=SCREAMING_SNAKE_CASE__					)




