






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	):
 # to overwrite at feature extractactor specific tests
 _lowerCAmelCase	:	Tuple				=			None
 _lowerCAmelCase	:	List[str]				=			None







 @property
 def  __lowercase   (		self :       List[Any]						):


      '''simple docstring'''






      return self.feat_extract_tester.prepare_feat_extract_dict()







 def  __lowercase   (		self :       List[Any]						):


      '''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  __lowercase   (		self :       List[Any]						):


      '''simple docstring'''






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

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

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

      UpperCamelCase__      :       Any	    =  self.feat_extract_tester.prepare_inputs_for_common(equal_length=_a						)
      UpperCamelCase__      :       Optional[Any]	    =  BatchFeature({input_name: speech_inputs}							,       tensor_type="np"						)

      UpperCamelCase__      :       List[str]	    =  processed_features[input_name]

      if len(batch_features_input.shape						) < 3:
           UpperCamelCase__      :       Optional[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  __lowercase   (		self :       Tuple						):


      '''simple docstring'''






      UpperCamelCase__      :       Optional[Any]	    =  self.feat_extract_tester.prepare_inputs_for_common(equal_length=_a						)
      UpperCamelCase__      :       Optional[int]	    =  self.feature_extraction_class(**self.feat_extract_dict						)
      UpperCamelCase__      :       Optional[int]	    =  feat_extract.model_input_names[0]

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

      UpperCamelCase__      :       Any	    =  processed_features[input_name]

      if len(batch_features_input.shape						) < 3:
           UpperCamelCase__      :       Union[str, 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_tf
 def  __lowercase   (		self :       Optional[Any]						):


      '''simple docstring'''






      UpperCamelCase__      :       str	    =  self.feat_extract_tester.prepare_inputs_for_common(equal_length=_a						)
      UpperCamelCase__      :       Dict	    =  self.feature_extraction_class(**self.feat_extract_dict						)
      UpperCamelCase__      :       Optional[int]	    =  feat_extract.model_input_names[0]

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

      UpperCamelCase__      :       Dict	    =  processed_features[input_name]

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


      '''simple docstring'''






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

      def _inputs_are_equal(SCREAMING_SNAKE_CASE :       Tuple							,       SCREAMING_SNAKE_CASE :       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

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

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

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

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

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

      UpperCamelCase__      :       Any	    =  feat_extract.pad(_a							,       padding="max_length"							,       max_length=len(speech_inputs[-1]						)						)
      UpperCamelCase__      :       Dict	    =  input_a[input_name]

      UpperCamelCase__      :       Any	    =  feat_extract.pad(_a							,       padding="longest"							,       return_tensors="np"						)
      UpperCamelCase__      :       Union[str, Any]	    =  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__      :       List[Any]	    =  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__      :       Union[str, Any]	    =  feat_extract.pad(_a							,       pad_to_multiple_of=10						)
      UpperCamelCase__      :       Any	    =  input_a[input_name]

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

      UpperCamelCase__      :       int	    =  feat_extract.pad(
          _a							,       padding="max_length"							,       pad_to_multiple_of=10							,       max_length=_a						)
      UpperCamelCase__      :       Dict	    =  input_a[input_name]

      UpperCamelCase__      :       str	    =  feat_extract.pad(
          _a							,       padding="max_length"							,       pad_to_multiple_of=10							,       max_length=_a							,       return_tensors="np"							,       )
      UpperCamelCase__      :       Optional[Any]	    =  input_a[input_name]

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

      UpperCamelCase__      :       Union[str, Any]	    =  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  __lowercase   (		self :       Optional[int]							,       SCREAMING_SNAKE_CASE :       List[str]=False						):


      '''simple docstring'''






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

      def _inputs_are_equal(SCREAMING_SNAKE_CASE :       Optional[Any]							,       SCREAMING_SNAKE_CASE :       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

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

      UpperCamelCase__      :       List[str]	    =  BatchFeature({input_name: speech_inputs}						)

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

      UpperCamelCase__      :       Union[str, Any]	    =  feat_extract.pad(_a							,       padding="max_length"							,       max_length=len(speech_inputs[0]						)						)
      UpperCamelCase__      :       Optional[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__      :       int	    =  feat_extract.pad(
          _a							,       padding="max_length"							,       max_length=len(speech_inputs[0]						)							,       return_tensors="np"							,       truncation=_a							,       )
      UpperCamelCase__      :       Optional[Any]	    =  input_a[input_name]

      UpperCamelCase__      :       Dict	    =  feat_extract.pad(
          _a							,       padding="max_length"							,       max_length=len(speech_inputs[0]						)							,       return_tensors="np"						)
      UpperCamelCase__      :       Optional[Any]	    =  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__      :       int	    =  feat_extract.pad(
          _a							,       padding="max_length"							,       max_length=len(speech_inputs[1]						)							,       truncation=_a							,       return_tensors="np"							,       )
      UpperCamelCase__      :       Tuple	    =  input_a[input_name]

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

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

      # retrieve expected_length as multiple of pad_to_multiple_of
      UpperCamelCase__      :       List[Any]	    =  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  __lowercase   (		self :       str						):


      '''simple docstring'''






      self._check_padding(numpify=_a						)







 def  __lowercase   (		self :       Union[str, Any]						):


      '''simple docstring'''






      self._check_padding(numpify=_a						)







 def  __lowercase   (		self :       List[Any]						):


      '''simple docstring'''






      self._check_truncation(numpify=_a						)







 def  __lowercase   (		self :       Optional[Any]						):


      '''simple docstring'''






      self._check_truncation(numpify=_a						)







 @require_torch
 def  __lowercase   (		self :       Union[str, Any]						):


      '''simple docstring'''






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

      UpperCamelCase__      :       List[Any]	    =  BatchFeature({input_name: speech_inputs}						)

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


      '''simple docstring'''






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

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

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


      '''simple docstring'''






      UpperCamelCase__      :       Any	    =  self.feat_extract_dict
      UpperCamelCase__      :       List[str]	    =  True
      UpperCamelCase__      :       int	    =  self.feature_extraction_class(**_a						)
      UpperCamelCase__      :       str	    =  self.feat_extract_tester.prepare_inputs_for_common()
      UpperCamelCase__      :       str	    =  [len(_a						) for x in speech_inputs]
      UpperCamelCase__      :       Optional[Any]	    =  feat_extract.model_input_names[0]

      UpperCamelCase__      :       Dict	    =  BatchFeature({input_name: speech_inputs}						)

      UpperCamelCase__      :       Optional[Any]	    =  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  __lowercase   (		self :       Tuple						):


      '''simple docstring'''






      UpperCamelCase__      :       List[Any]	    =  self.feat_extract_dict
      UpperCamelCase__      :       List[Any]	    =  True
      UpperCamelCase__      :       Optional[int]	    =  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__      :       Dict	    =  feat_extract.model_input_names[0]

      UpperCamelCase__      :       int	    =  BatchFeature({input_name: speech_inputs}						)
      UpperCamelCase__      :       str	    =  min(_a						)

      UpperCamelCase__      :       Optional[Any]	    =  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]						)







from __future__ import annotations







def 		SCREAMING_SNAKE_CASE							( __lowerCAmelCase ,   __lowerCAmelCase      )			->     list[int]:
     UpperCamelCase__      :       Optional[Any]	    =  0
     UpperCamelCase__      :       Any	    =  len(__lowerCAmelCase      ) - 1

     while i < j:
          if nums[i] + nums[j] == target:
               return [i, j]
          elif nums[i] + nums[j] < target:
               UpperCamelCase__      :       Optional[int]	    =  i + 1
          else:
               UpperCamelCase__      :       Dict	    =  j - 1

     return []


if __name__ == "__main__":
 import doctest

 doctest.testmod()
 print(F"""{two_pointer([2, 7, 11, 15], 9) = }""")