





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     A     (SCREAMING_SNAKE_CASE       ):
			'''simple docstring'''




			__lowerCamelCase      :			Any							     =       None
			__lowerCamelCase      :			Optional[Any]							     =       None






			@property
			def   a_			(     self  :       Optional[Any]  )      ->      int:







					"""simple docstring"""






					return self.feat_extract_tester.prepare_feat_extract_dict()






			def   a_			(     self  :       Optional[int]  )      ->      str:







					"""simple docstring"""






					A__     =  self.feature_extraction_class(**self.feat_extract_dict  )
					self.assertTrue(hasattr(__lowerCAmelCase				,      """feature_size"""  )  )
					self.assertTrue(hasattr(__lowerCAmelCase				,      """sampling_rate"""  )  )
					self.assertTrue(hasattr(__lowerCAmelCase				,      """padding_value"""  )  )






			def   a_			(     self  :       str  )      ->      int:







					"""simple docstring"""






					A__     =  self.feat_extract_tester.prepare_inputs_for_common()
					A__     =  self.feature_extraction_class(**self.feat_extract_dict  )
					A__     =  feat_extract.model_input_names[0]

					A__     =  BatchFeature({input_name: speech_inputs}  )

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

					A__     =  self.feat_extract_tester.prepare_inputs_for_common(equal_length=__lowerCAmelCase  )
					A__     =  BatchFeature({input_name: speech_inputs}				,      tensor_type="""np"""  )

					A__     =  processed_features[input_name]

					if len(batch_features_input.shape  ) < 3:
							A__     =  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   a_			(     self  :       int  )      ->      Tuple:







					"""simple docstring"""






					A__     =  self.feat_extract_tester.prepare_inputs_for_common(equal_length=__lowerCAmelCase  )
					A__     =  self.feature_extraction_class(**self.feat_extract_dict  )
					A__     =  feat_extract.model_input_names[0]

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

					A__     =  processed_features[input_name]

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







					"""simple docstring"""






					A__     =  self.feat_extract_tester.prepare_inputs_for_common(equal_length=__lowerCAmelCase  )
					A__     =  self.feature_extraction_class(**self.feat_extract_dict  )
					A__     =  feat_extract.model_input_names[0]

					A__     =  BatchFeature({input_name: speech_inputs}				,      tensor_type="""tf"""  )

					A__     =  processed_features[input_name]

					if len(batch_features_input.shape  ) < 3:
							A__     =  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   a_			(     self  :       int				,      __lowerCAmelCase  :       List[Any]=False  )      ->      int:







					"""simple docstring"""






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

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

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

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

					A__     =  BatchFeature({input_name: speech_inputs}  )

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

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

					A__     =  feat_extract.pad(__lowerCAmelCase				,      padding="""longest"""  )
					A__     =  input_a[input_name]

					A__     =  feat_extract.pad(__lowerCAmelCase				,      padding="""max_length"""				,      max_length=len(speech_inputs[-1]  )  )
					A__     =  input_a[input_name]

					A__     =  feat_extract.pad(__lowerCAmelCase				,      padding="""longest"""				,      return_tensors="""np"""  )
					A__     =  input_a[input_name]

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

					A__     =  feat_extract.pad(
					    __lowerCAmelCase				,      padding="""max_length"""				,      max_length=__lowerCAmelCase				,      return_tensors="""np"""  )
					A__     =  input_a[input_name]

					self.assertFalse(_inputs_have_equal_length(__lowerCAmelCase  )  )
					self.assertTrue(_inputs_have_equal_length(__lowerCAmelCase  )  )
					self.assertTrue(_inputs_have_equal_length(__lowerCAmelCase  )  )
					self.assertTrue(_inputs_are_equal(__lowerCAmelCase				,      __lowerCAmelCase  )  )
					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
					A__     =  feat_extract.pad(__lowerCAmelCase				,      pad_to_multiple_of=10  )
					A__     =  input_a[input_name]

					A__     =  feat_extract.pad(__lowerCAmelCase				,      padding="""longest"""				,      pad_to_multiple_of=10  )
					A__     =  input_a[input_name]

					A__     =  feat_extract.pad(
					    __lowerCAmelCase				,      padding="""max_length"""				,      pad_to_multiple_of=10				,      max_length=__lowerCAmelCase  )
					A__     =  input_a[input_name]

					A__     =  feat_extract.pad(
					    __lowerCAmelCase				,      padding="""max_length"""				,      pad_to_multiple_of=10				,      max_length=__lowerCAmelCase				,      return_tensors="""np"""				,      )
					A__     =  input_a[input_name]

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

					A__     =  pad_max_length if pad_max_length % 10 == 0 else (pad_max_length // 10 + 1) * 10
					self.assertTrue(all(len(__lowerCAmelCase  ) == 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
					A__     =  (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   a_			(     self  :       Tuple				,      __lowerCAmelCase  :       List[str]=False  )      ->      int:







					"""simple docstring"""






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

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

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

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

					A__     =  BatchFeature({input_name: speech_inputs}  )

					# truncate to smallest
					A__     =  feat_extract.pad(
					    __lowerCAmelCase				,      padding="""max_length"""				,      max_length=len(speech_inputs[0]  )				,      truncation=__lowerCAmelCase  )
					A__     =  input_a[input_name]

					A__     =  feat_extract.pad(__lowerCAmelCase				,      padding="""max_length"""				,      max_length=len(speech_inputs[0]  )  )
					A__     =  input_a[input_name]

					self.assertTrue(_inputs_have_equal_length(__lowerCAmelCase  )  )
					self.assertFalse(_inputs_have_equal_length(__lowerCAmelCase  )  )

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

					A__     =  feat_extract.pad(
					    __lowerCAmelCase				,      padding="""max_length"""				,      max_length=len(speech_inputs[0]  )				,      return_tensors="""np"""  )
					A__     =  input_a[input_name]

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

					# truncate to middle
					A__     =  feat_extract.pad(
					    __lowerCAmelCase				,      padding="""max_length"""				,      max_length=len(speech_inputs[1]  )				,      truncation=__lowerCAmelCase				,      return_tensors="""np"""				,      )
					A__     =  input_a[input_name]

					A__     =  feat_extract.pad(
					    __lowerCAmelCase				,      padding="""max_length"""				,      max_length=len(speech_inputs[1]  )				,      truncation=__lowerCAmelCase  )
					A__     =  input_a[input_name]

					A__     =  feat_extract.pad(
					    __lowerCAmelCase				,      padding="""max_length"""				,      max_length=len(speech_inputs[1]  )				,      return_tensors="""np"""  )
					A__     =  input_a[input_name]

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

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

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

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

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

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

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

					A__     =  feat_extract.pad(
					    __lowerCAmelCase				,      padding="""max_length"""				,      max_length=len(speech_inputs[0]  )				,      pad_to_multiple_of=__lowerCAmelCase				,      )
					A__     =  input_a[input_name]

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






			def   a_			(     self  :       List[str]  )      ->      List[Any]:







					"""simple docstring"""






					self._check_padding(numpify=__lowerCAmelCase  )






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







					"""simple docstring"""






					self._check_padding(numpify=__lowerCAmelCase  )






			def   a_			(     self  :       Optional[Any]  )      ->      List[str]:







					"""simple docstring"""






					self._check_truncation(numpify=__lowerCAmelCase  )






			def   a_			(     self  :       Tuple  )      ->      List[Any]:







					"""simple docstring"""






					self._check_truncation(numpify=__lowerCAmelCase  )






			@require_torch
			def   a_			(     self  :       Optional[Any]  )      ->      Tuple:







					"""simple docstring"""






					A__     =  self.feature_extraction_class(**self.feat_extract_dict  )
					A__     =  self.feat_extract_tester.prepare_inputs_for_common()
					A__     =  feat_extract.model_input_names[0]

					A__     =  BatchFeature({input_name: speech_inputs}  )

					A__     =  feat_extract.pad(__lowerCAmelCase				,      padding="""longest"""				,      return_tensors="""np"""  )[input_name]
					A__     =  feat_extract.pad(__lowerCAmelCase				,      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   a_			(     self  :       str  )      ->      Dict:







					"""simple docstring"""






					A__     =  self.feature_extraction_class(**self.feat_extract_dict  )
					A__     =  self.feat_extract_tester.prepare_inputs_for_common()
					A__     =  feat_extract.model_input_names[0]

					A__     =  BatchFeature({input_name: speech_inputs}  )

					A__     =  feat_extract.pad(__lowerCAmelCase				,      padding="""longest"""				,      return_tensors="""np"""  )[input_name]
					A__     =  feat_extract.pad(__lowerCAmelCase				,      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   a_			(     self  :       Dict  )      ->      Dict:







					"""simple docstring"""






					A__     =  self.feat_extract_dict
					A__     =  True
					A__     =  self.feature_extraction_class(**__lowerCAmelCase  )
					A__     =  self.feat_extract_tester.prepare_inputs_for_common()
					A__     =  [len(__lowerCAmelCase  ) for x in speech_inputs]
					A__     =  feat_extract.model_input_names[0]

					A__     =  BatchFeature({input_name: speech_inputs}  )

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







			def   a_			(     self  :       Any  )      ->      Optional[int]:







					"""simple docstring"""






					A__     =  self.feat_extract_dict
					A__     =  True
					A__     =  self.feature_extraction_class(**__lowerCAmelCase  )
					A__     =  self.feat_extract_tester.prepare_inputs_for_common()
					A__     =  [len(__lowerCAmelCase  ) for x in speech_inputs]
					A__     =  feat_extract.model_input_names[0]

					A__     =  BatchFeature({input_name: speech_inputs}  )
					A__     =  min(__lowerCAmelCase  )

					A__     =  feat_extract.pad(
					    __lowerCAmelCase				,      padding="""max_length"""				,      max_length=__lowerCAmelCase				,      truncation=__lowerCAmelCase				,      return_tensors="""np"""  )
					self.assertIn("""attention_mask"""				,      __lowerCAmelCase  )
					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   __lowerCamelCase   (				__a  :int       ,	__a  :int       )						->							Optional[Any]:






		"""simple docstring"""

		if b == 0:
				return 1
		if (b % 2) == 0:
				return actual_power(__a       ,	int(b / 2       )       ) * actual_power(__a       ,	int(b / 2       )       )
		else:
				return a * actual_power(__a       ,	int(b / 2       )       ) * actual_power(__a       ,	int(b / 2       )       )







def   __lowerCamelCase   (				__a  :int       ,	__a  :int       )						->							float:






		"""simple docstring"""

		if b < 0:
				return 1 / actual_power(__a       ,	__a       )
		return actual_power(__a       ,	__a       )


if __name__ == "__main__":
					print(power(-2, -3))



