





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 		UpperCamelCase__			(				lowerCAmelCase_       ):



     '''simple docstring'''

     __snake_case   :     int		     =      None
     __snake_case   :     List[str]		     =      None






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




           '''simple docstring'''


           return self.feat_extract_tester.prepare_feat_extract_dict()






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




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						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     SCREAMING_SNAKE_CASE__  (							self						:   Dict	)					->		Tuple:




           '''simple docstring'''


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

           SCREAMING_SNAKE_CASE		=						BatchFeature({input_name: speech_inputs}	)

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

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

           SCREAMING_SNAKE_CASE		=						processed_features[input_name]

           if len(batch_features_input.shape	) < 3:
                 SCREAMING_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     SCREAMING_SNAKE_CASE__  (							self						:   str	)					->		List[Any]:




           '''simple docstring'''


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

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

           SCREAMING_SNAKE_CASE		=						processed_features[input_name]

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




           '''simple docstring'''


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

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

           SCREAMING_SNAKE_CASE		=						processed_features[input_name]

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




           '''simple docstring'''


           def _inputs_have_equal_length(lowerCamelCase__						:   List[str]	):
                 SCREAMING_SNAKE_CASE		=						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__						:   List[Any]	):
                 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

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

           SCREAMING_SNAKE_CASE		=						BatchFeature({input_name: speech_inputs}	)

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

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

           SCREAMING_SNAKE_CASE		=						feat_extract.pad(lowerCamelCase__						,padding="""longest"""	)
           SCREAMING_SNAKE_CASE		=						input_a[input_name]

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

           SCREAMING_SNAKE_CASE		=						feat_extract.pad(lowerCamelCase__						,padding="""longest"""						,return_tensors="""np"""	)
           SCREAMING_SNAKE_CASE		=						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]

           SCREAMING_SNAKE_CASE		=						feat_extract.pad(
               lowerCamelCase__						,padding="""max_length"""						,max_length=lowerCamelCase__						,return_tensors="""np"""	)
           SCREAMING_SNAKE_CASE		=						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
           SCREAMING_SNAKE_CASE		=						feat_extract.pad(lowerCamelCase__						,pad_to_multiple_of=10	)
           SCREAMING_SNAKE_CASE		=						input_a[input_name]

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

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

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

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

           SCREAMING_SNAKE_CASE		=						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
           SCREAMING_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     SCREAMING_SNAKE_CASE__  (							self						:   Any						,lowerCamelCase__						:   Any=False	)					->		Optional[Any]:




           '''simple docstring'''


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

           def _inputs_are_equal(lowerCamelCase__						:   List[str]						,lowerCamelCase__						:   Dict	):
                 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

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

           SCREAMING_SNAKE_CASE		=						BatchFeature({input_name: speech_inputs}	)

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

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

           self.assertTrue(_inputs_have_equal_length(lowerCamelCase__	)	)
           self.assertFalse(_inputs_have_equal_length(lowerCamelCase__	)	)

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

           SCREAMING_SNAKE_CASE		=						feat_extract.pad(
               lowerCamelCase__						,padding="""max_length"""						,max_length=len(speech_inputs[0]	)						,return_tensors="""np"""	)
           SCREAMING_SNAKE_CASE		=						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
           SCREAMING_SNAKE_CASE		=						feat_extract.pad(
               lowerCamelCase__						,padding="""max_length"""						,max_length=len(speech_inputs[1]	)						,truncation=lowerCamelCase__						,return_tensors="""np"""						,)
           SCREAMING_SNAKE_CASE		=						input_a[input_name]

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

           SCREAMING_SNAKE_CASE		=						feat_extract.pad(
               lowerCamelCase__						,padding="""max_length"""						,max_length=len(speech_inputs[1]	)						,return_tensors="""np"""	)
           SCREAMING_SNAKE_CASE		=						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
           SCREAMING_SNAKE_CASE		=						12
           SCREAMING_SNAKE_CASE		=						feat_extract.pad(
               lowerCamelCase__						,padding="""max_length"""						,max_length=len(speech_inputs[0]	)						,pad_to_multiple_of=lowerCamelCase__						,truncation=lowerCamelCase__						,)
           SCREAMING_SNAKE_CASE		=						input_a[input_name]

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

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






     def     SCREAMING_SNAKE_CASE__  (							self						:   Tuple	)					->		List[str]:




           '''simple docstring'''


           self._check_padding(numpify=lowerCamelCase__	)






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




           '''simple docstring'''


           self._check_padding(numpify=lowerCamelCase__	)






     def     SCREAMING_SNAKE_CASE__  (							self						:   Any	)					->		Dict:




           '''simple docstring'''


           self._check_truncation(numpify=lowerCamelCase__	)






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




           '''simple docstring'''


           self._check_truncation(numpify=lowerCamelCase__	)






     @require_torch
     def     SCREAMING_SNAKE_CASE__  (							self						:   str	)					->		Any:




           '''simple docstring'''


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

           SCREAMING_SNAKE_CASE		=						BatchFeature({input_name: speech_inputs}	)

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




           '''simple docstring'''


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

           SCREAMING_SNAKE_CASE		=						BatchFeature({input_name: speech_inputs}	)

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




           '''simple docstring'''


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

           SCREAMING_SNAKE_CASE		=						BatchFeature({input_name: speech_inputs}	)

           SCREAMING_SNAKE_CASE		=						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     SCREAMING_SNAKE_CASE__  (							self						:   List[Any]	)					->		str:




           '''simple docstring'''


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

           SCREAMING_SNAKE_CASE		=						BatchFeature({input_name: speech_inputs}	)
           SCREAMING_SNAKE_CASE		=						min(lowerCamelCase__	)

           SCREAMING_SNAKE_CASE		=						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]	)









from __future__ import annotations



def        __lowercase       (				_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE     )			->       list[int]:


      '''simple docstring'''


      SCREAMING_SNAKE_CASE		=						0
      SCREAMING_SNAKE_CASE		=						len(_SCREAMING_SNAKE_CASE     ) - 1

      while i < j:
            if nums[i] + nums[j] == target:
                  return [i, j]
            elif nums[i] + nums[j] < target:
                  SCREAMING_SNAKE_CASE		=						i + 1
            else:
                  SCREAMING_SNAKE_CASE		=						j - 1

      return []


if __name__ == "__main__":
      import doctest

      doctest.testmod()
      print(F'''{two_pointer([2, 7, 1_1, 1_5], 9) = }''')


