





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__   (       __snake_case			):
      # to overwrite at feature extractactor specific tests
      _UpperCAmelCase	:Any						    =   None
      _UpperCAmelCase	:Optional[Any]						    =   None





      @property
      def        __UpperCamelCase( self   ):
       '''simple docstring'''




       return self.feat_extract_tester.prepare_feat_extract_dict()





      def        __UpperCamelCase( self   ):
       '''simple docstring'''




       UpperCamelCase	:					List[Any]       	=   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        __UpperCamelCase( self   ):
       '''simple docstring'''




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

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

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

       UpperCamelCase	:					List[str]       	=   self.feat_extract_tester.prepare_inputs_for_common(equal_length=A_   )
       UpperCamelCase	:					int       	=   BatchFeature({input_name: speech_inputs}       ,							tensor_type="np"   )

       UpperCamelCase	:					Optional[int]       	=   processed_features[input_name]

       if len(batch_features_input.shape   ) < 3:
        UpperCamelCase	:					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_torch
      def        __UpperCamelCase( self   ):
       '''simple docstring'''




       UpperCamelCase	:					List[str]       	=   self.feat_extract_tester.prepare_inputs_for_common(equal_length=A_   )
       UpperCamelCase	:					int       	=   self.feature_extraction_class(**self.feat_extract_dict   )
       UpperCamelCase	:					Tuple       	=   feat_extract.model_input_names[0]

       UpperCamelCase	:					Optional[Any]       	=   BatchFeature({input_name: speech_inputs}       ,							tensor_type="pt"   )

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

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





      @require_tf
      def        __UpperCamelCase( self   ):
       '''simple docstring'''




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

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

       UpperCamelCase	:					Dict       	=   processed_features[input_name]

       if len(batch_features_input.shape   ) < 3:
        UpperCamelCase	:					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        __UpperCamelCase( self       ,							A_=False   ):
       '''simple docstring'''




       def _inputs_have_equal_length(A_   ):
        UpperCamelCase	:					List[Any]       	=   len(input[0]   )
        for input_slice in input[1:]:
         if len(A_   ) != length:
          return False
        return True

       def _inputs_are_equal(A_       ,							A_   ):
        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

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

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

       UpperCamelCase	:					str       	=   self.feat_extract_tester.seq_length_diff
       UpperCamelCase	:					List[Any]       	=   self.feat_extract_tester.max_seq_length + pad_diff
       UpperCamelCase	:					Optional[Any]       	=   self.feat_extract_tester.min_seq_length
       UpperCamelCase	:					List[str]       	=   self.feat_extract_tester.batch_size
       UpperCamelCase	:					Tuple       	=   self.feat_extract_tester.feature_size

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

       UpperCamelCase	:					Dict       	=   feat_extract.pad(A_       ,							padding="longest"   )
       UpperCamelCase	:					Any       	=   input_a[input_name]

       UpperCamelCase	:					List[Any]       	=   feat_extract.pad(A_       ,							padding="max_length"       ,							max_length=len(speech_inputs[-1]   )   )
       UpperCamelCase	:					Optional[int]       	=   input_a[input_name]

       UpperCamelCase	:					Optional[Any]       	=   feat_extract.pad(A_       ,							padding="longest"       ,							return_tensors="np"   )
       UpperCamelCase	:					int       	=   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]

       UpperCamelCase	:					str       	=   feat_extract.pad(
           A_       ,							padding="max_length"       ,							max_length=A_       ,							return_tensors="np"   )
       UpperCamelCase	:					Optional[int]       	=   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
       UpperCamelCase	:					Dict       	=   feat_extract.pad(A_       ,							pad_to_multiple_of=10   )
       UpperCamelCase	:					Optional[Any]       	=   input_a[input_name]

       UpperCamelCase	:					Optional[int]       	=   feat_extract.pad(A_       ,							padding="longest"       ,							pad_to_multiple_of=10   )
       UpperCamelCase	:					str       	=   input_a[input_name]

       UpperCamelCase	:					List[str]       	=   feat_extract.pad(
           A_       ,							padding="max_length"       ,							pad_to_multiple_of=10       ,							max_length=A_   )
       UpperCamelCase	:					str       	=   input_a[input_name]

       UpperCamelCase	:					List[Any]       	=   feat_extract.pad(
           A_       ,							padding="max_length"       ,							pad_to_multiple_of=10       ,							max_length=A_       ,							return_tensors="np"       ,							)
       UpperCamelCase	:					Tuple       	=   input_a[input_name]

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

       UpperCamelCase	:					Dict       	=   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
       UpperCamelCase	:					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        __UpperCamelCase( self       ,							A_=False   ):
       '''simple docstring'''




       def _inputs_have_equal_length(A_   ):
        UpperCamelCase	:					List[Any]       	=   len(input[0]   )
        for input_slice in input[1:]:
         if len(A_   ) != length:
          return False
        return True

       def _inputs_are_equal(A_       ,							A_   ):
        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

       UpperCamelCase	:					Union[str, Any]       	=   self.feature_extraction_class(**self.feat_extract_dict   )
       UpperCamelCase	:					Tuple       	=   self.feat_extract_tester.prepare_inputs_for_common(numpify=A_   )
       UpperCamelCase	:					Tuple       	=   feat_extract.model_input_names[0]

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

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

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

       self.assertTrue(_inputs_have_equal_length(A_   )   )
       self.assertFalse(_inputs_have_equal_length(A_   )   )

       # truncate to smallest with np
       UpperCamelCase	:					Union[str, Any]       	=   feat_extract.pad(
           A_       ,							padding="max_length"       ,							max_length=len(speech_inputs[0]   )       ,							return_tensors="np"       ,							truncation=A_       ,							)
       UpperCamelCase	:					str       	=   input_a[input_name]

       UpperCamelCase	:					Dict       	=   feat_extract.pad(
           A_       ,							padding="max_length"       ,							max_length=len(speech_inputs[0]   )       ,							return_tensors="np"   )
       UpperCamelCase	:					str       	=   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
       UpperCamelCase	:					Dict       	=   feat_extract.pad(
           A_       ,							padding="max_length"       ,							max_length=len(speech_inputs[1]   )       ,							truncation=A_       ,							return_tensors="np"       ,							)
       UpperCamelCase	:					Union[str, Any]       	=   input_a[input_name]

       UpperCamelCase	:					Tuple       	=   feat_extract.pad(
           A_       ,							padding="max_length"       ,							max_length=len(speech_inputs[1]   )       ,							truncation=A_   )
       UpperCamelCase	:					List[str]       	=   input_a[input_name]

       UpperCamelCase	:					int       	=   feat_extract.pad(
           A_       ,							padding="max_length"       ,							max_length=len(speech_inputs[1]   )       ,							return_tensors="np"   )
       UpperCamelCase	:					Optional[Any]       	=   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
       UpperCamelCase	:					Any       	=   12
       UpperCamelCase	:					str       	=   feat_extract.pad(
           A_       ,							padding="max_length"       ,							max_length=len(speech_inputs[0]   )       ,							pad_to_multiple_of=A_       ,							truncation=A_       ,							)
       UpperCamelCase	:					Tuple       	=   input_a[input_name]

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

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





      def        __UpperCamelCase( self   ):
       '''simple docstring'''




       self._check_padding(numpify=A_   )





      def        __UpperCamelCase( self   ):
       '''simple docstring'''




       self._check_padding(numpify=A_   )





      def        __UpperCamelCase( self   ):
       '''simple docstring'''




       self._check_truncation(numpify=A_   )





      def        __UpperCamelCase( self   ):
       '''simple docstring'''




       self._check_truncation(numpify=A_   )





      @require_torch
      def        __UpperCamelCase( self   ):
       '''simple docstring'''




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

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

       UpperCamelCase	:					Optional[int]       	=   feat_extract.pad(A_       ,							padding="longest"       ,							return_tensors="np"   )[input_name]
       UpperCamelCase	:					List[Any]       	=   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        __UpperCamelCase( self   ):
       '''simple docstring'''




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

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

       UpperCamelCase	:					int       	=   feat_extract.pad(A_       ,							padding="longest"       ,							return_tensors="np"   )[input_name]
       UpperCamelCase	:					Union[str, Any]       	=   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        __UpperCamelCase( self   ):
       '''simple docstring'''




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

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

       UpperCamelCase	:					Tuple       	=   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        __UpperCamelCase( self   ):
       '''simple docstring'''




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

       UpperCamelCase	:					Union[str, Any]       	=   BatchFeature({input_name: speech_inputs}   )
       UpperCamelCase	:					Dict       	=   min(A_   )

       UpperCamelCase	:					str       	=   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]   )


def 				a						(							snake_case__:					list					):


				'''simple docstring'''

				if len(snake_case__					) <= 1:
								return [tuple(snake_case__					)]

				lowercase_       =					[]

				def generate(snake_case__:					int						,   snake_case__:					list					):
								if k == 1:
												res.append(tuple(arr[:]					)					)
												return

								generate(k - 1						,   snake_case__					)

								for i in range(k - 1					):
												if k % 2 == 0:  # k is even
																lowercase_  ,	lowercase_       =					arr[k - 1], arr[i]
												else:  # k is odd
																lowercase_  ,	lowercase_       =					arr[k - 1], arr[0]
												generate(k - 1						,   snake_case__					)

				generate(len(snake_case__					)						,   snake_case__					)
				return res


if __name__ == "__main__":
						__a  			=					input('Enter numbers separated by a comma:\n').strip()
						__a  			=					[int(item) for item in user_input.split(',')]
						print(heaps(arr))




