


"""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        __A       (_a):





							'''simple docstring'''

							__lowercase:						Any							 =      None
							__lowercase:						List[Any]							 =      None



							@property
							def 						lowerCAmelCase    (			self							: List[Any]    )   ->Optional[Any]:



														"""simple docstring"""



														return self.feat_extract_tester.prepare_feat_extract_dict()



							def 						lowerCAmelCase    (			self							: List[Any]    )   ->int:



														"""simple docstring"""



														snake_case_          =						self.feature_extraction_class(**self.feat_extract_dict    )
														self.assertTrue(hasattr(_a						,    """feature_size"""    )    )
														self.assertTrue(hasattr(_a						,    """sampling_rate"""    )    )
														self.assertTrue(hasattr(_a						,    """padding_value"""    )    )



							def 						lowerCAmelCase    (			self							: List[Any]    )   ->int:



														"""simple docstring"""



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

														snake_case_          =						BatchFeature({input_name: speech_inputs}    )

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

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

														snake_case_          =						processed_features[input_name]

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

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



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



														"""simple docstring"""



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

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

														snake_case_          =						processed_features[input_name]

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

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



							@require_tf
							def 						lowerCAmelCase    (			self							: Optional[Any]    )   ->List[Any]:



														"""simple docstring"""



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

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

														snake_case_          =						processed_features[input_name]

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

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



							def 						lowerCAmelCase    (			self							: List[Any]						,    UpperCAmelCase_							: int=False    )   ->Dict:



														"""simple docstring"""



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

														def _inputs_are_equal(UpperCAmelCase_							: Tuple						,    UpperCAmelCase_							: List[str]    ):
																					if len(_a    ) != len(_a    ):
																												return False

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

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

														snake_case_          =						BatchFeature({input_name: speech_inputs}    )

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

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

														snake_case_          =						feat_extract.pad(_a						,    padding="""longest"""    )
														snake_case_          =						input_a[input_name]

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

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

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

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

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

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

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

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

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

														snake_case_          =						pad_max_length if pad_max_length % 10 == 0 else (pad_max_length // 10 + 1) * 10
														self.assertTrue(all(len(_a    ) == 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_          =						(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 						lowerCAmelCase    (			self							: Optional[int]						,    UpperCAmelCase_							: List[str]=False    )   ->Any:



														"""simple docstring"""



														def _inputs_have_equal_length(UpperCAmelCase_							: Dict    ):
																					snake_case_          =						len(input[0]    )
																					for input_slice in input[1:]:
																												if len(_a    ) != length:
																																			return False
																					return True

														def _inputs_are_equal(UpperCAmelCase_							: Optional[Any]						,    UpperCAmelCase_							: str    ):
																					if len(_a    ) != len(_a    ):
																												return False

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

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

														snake_case_          =						BatchFeature({input_name: speech_inputs}    )

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

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

														self.assertTrue(_inputs_have_equal_length(_a    )    )
														self.assertFalse(_inputs_have_equal_length(_a    )    )

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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



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



														"""simple docstring"""



														self._check_padding(numpify=_a    )



							def 						lowerCAmelCase    (			self							: Union[str, Any]    )   ->Optional[Any]:



														"""simple docstring"""



														self._check_padding(numpify=_a    )



							def 						lowerCAmelCase    (			self							: List[Any]    )   ->Dict:



														"""simple docstring"""



														self._check_truncation(numpify=_a    )



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



														"""simple docstring"""



														self._check_truncation(numpify=_a    )



							@require_torch
							def 						lowerCAmelCase    (			self							: Union[str, Any]    )   ->Optional[int]:



														"""simple docstring"""



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

														snake_case_          =						BatchFeature({input_name: speech_inputs}    )

														snake_case_          =						feat_extract.pad(_a						,    padding="""longest"""						,    return_tensors="""np"""    )[input_name]
														snake_case_          =						feat_extract.pad(_a						,    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 						lowerCAmelCase    (			self							: List[Any]    )   ->Optional[Any]:



														"""simple docstring"""



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

														snake_case_          =						BatchFeature({input_name: speech_inputs}    )

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



														"""simple docstring"""



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

														snake_case_          =						BatchFeature({input_name: speech_inputs}    )

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



							def 						lowerCAmelCase    (			self							: Tuple    )   ->Optional[int]:



														"""simple docstring"""



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

														snake_case_          =						BatchFeature({input_name: speech_inputs}    )
														snake_case_          =						min(_a    )

														snake_case_          =						feat_extract.pad(
														    _a						,    padding="""max_length"""						,    max_length=_a						,    truncation=_a						,    return_tensors="""np"""    )
														self.assertIn("""attention_mask"""						,    _a    )
														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 math





class        __A       :





							'''simple docstring'''

							def __init__(			self							: List[str]						,    UpperCAmelCase_							: Tuple=0    )   ->Optional[int]:  # a graph with Node 0,1,...,N-1



														"""simple docstring"""



														snake_case_          =						n
														snake_case_          =						[
														    [math.inf for j in range(0						,    UpperCAmelCase_    )] for i in range(0						,    UpperCAmelCase_    )
														]  # adjacency matrix for weight
														snake_case_          =						[
														    [math.inf for j in range(0						,    UpperCAmelCase_    )] for i in range(0						,    UpperCAmelCase_    )
														]  # dp[i][j] stores minimum distance from i to j



							def 						lowerCAmelCase    (			self							: List[str]						,    UpperCAmelCase_							: Any						,    UpperCAmelCase_							: List[str]						,    UpperCAmelCase_							: Optional[Any]    )   ->Optional[int]:



														"""simple docstring"""



														snake_case_          =						w



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



														"""simple docstring"""



														for k in range(0						,    self.n    ):
																					for i in range(0						,    self.n    ):
																												for j in range(0						,    self.n    ):
																																			snake_case_          =						min(self.dp[i][j]						,    self.dp[i][k] + self.dp[k][j]    )



							def 						lowerCAmelCase    (			self							: Optional[int]						,    UpperCAmelCase_							: Dict						,    UpperCAmelCase_							: Optional[Any]    )   ->Union[str, Any]:



														"""simple docstring"""



														return self.dp[u][v]


if __name__ == "__main__":
				__SCREAMING_SNAKE_CASE							:      Optional[int]						=      Graph(5)
				graph.add_edge(0, 2, 9)
				graph.add_edge(0, 4, 10)
				graph.add_edge(1, 3, 5)
				graph.add_edge(2, 3, 7)
				graph.add_edge(3, 0, 10)
				graph.add_edge(3, 1, 2)
				graph.add_edge(3, 2, 1)
				graph.add_edge(3, 4, 6)
				graph.add_edge(4, 1, 3)
				graph.add_edge(4, 2, 4)
				graph.add_edge(4, 3, 9)
				graph.floyd_warshall()
				graph.show_min(1, 4)
				graph.show_min(0, 3)



