


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 _lowerCamelCase(		a_  ):
       lowercase_					:      List[Any]       					=     None
       lowercase_					:      List[Any]       					=     None
       @property
       def      UpperCamelCase	(   self)			->  Dict:




           """simple docstring"""

           return self.feat_extract_tester.prepare_feat_extract_dict()
       def      UpperCamelCase	(   self)			->  Union[str, Any]:




           """simple docstring"""

           _lowercase			:				int 						=						self.feature_extraction_class(**self.feat_extract_dict)
           self.assertTrue(hasattr(UpperCamelCase_, 'feature_size'))
           self.assertTrue(hasattr(UpperCamelCase_, 'sampling_rate'))
           self.assertTrue(hasattr(UpperCamelCase_, 'padding_value'))
       def      UpperCamelCase	(   self)			->  Any:




           """simple docstring"""

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

           _lowercase			:				Union[str, Any] 						=						BatchFeature({input_name: speech_inputs})

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

           _lowercase			:				Optional[Any] 						=						self.feat_extract_tester.prepare_inputs_for_common(equal_length=UpperCamelCase_)
           _lowercase			:				Any 						=						BatchFeature({input_name: speech_inputs}, tensor_type='np')

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

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




           """simple docstring"""

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

           _lowercase			:				Union[str, Any] 						=						BatchFeature({input_name: speech_inputs}, tensor_type='pt')

           _lowercase			:				Any 						=						processed_features[input_name]

           if len(batch_features_input.shape) < 3:
               _lowercase			:				Dict 						=						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)			->  str:




           """simple docstring"""

           _lowercase			:				List[Any] 						=						self.feat_extract_tester.prepare_inputs_for_common(equal_length=UpperCamelCase_)
           _lowercase			:				int 						=						self.feature_extraction_class(**self.feat_extract_dict)
           _lowercase			:				Tuple 						=						feat_extract.model_input_names[0]

           _lowercase			:				Optional[int] 						=						BatchFeature({input_name: speech_inputs}, tensor_type='tf')

           _lowercase			:				str 						=						processed_features[input_name]

           if len(batch_features_input.shape) < 3:
               _lowercase			:				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))
       def      UpperCamelCase	(   self, lowerCamelCase=False)			->  Optional[int]:




           """simple docstring"""

           def _inputs_have_equal_length(lowerCamelCase):
               _lowercase			:				List[str] 						=						len(input[0])
               for input_slice in input[1:]:
                   if len(UpperCamelCase_) != length:
                       return False
               return True

           def _inputs_are_equal(lowerCamelCase, lowerCamelCase):
               if len(UpperCamelCase_) != len(UpperCamelCase_):
                   return False

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

           _lowercase			:				Union[str, Any] 						=						self.feature_extraction_class(**self.feat_extract_dict)
           _lowercase			:				str 						=						self.feat_extract_tester.prepare_inputs_for_common(numpify=UpperCamelCase_)
           _lowercase			:				Dict 						=						feat_extract.model_input_names[0]

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

           _lowercase			:				Any 						=						self.feat_extract_tester.seq_length_diff
           _lowercase			:				int 						=						self.feat_extract_tester.max_seq_length + pad_diff
           _lowercase			:				str 						=						self.feat_extract_tester.min_seq_length
           _lowercase			:				Optional[int] 						=						self.feat_extract_tester.batch_size
           _lowercase			:				Dict 						=						self.feat_extract_tester.feature_size

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

           _lowercase			:				Dict 						=						feat_extract.pad(UpperCamelCase_, padding='longest')
           _lowercase			:				Optional[int] 						=						input_a[input_name]

           _lowercase			:				Dict 						=						feat_extract.pad(UpperCamelCase_, padding='max_length', max_length=len(speech_inputs[-1]))
           _lowercase			:				Dict 						=						input_a[input_name]

           _lowercase			:				Dict 						=						feat_extract.pad(UpperCamelCase_, padding='longest', return_tensors='np')
           _lowercase			:				Tuple 						=						input_a[input_name]

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

           _lowercase			:				Optional[Any] 						=						feat_extract.pad(
               UpperCamelCase_, padding='max_length', max_length=UpperCamelCase_, return_tensors='np')
           _lowercase			:				Optional[int] 						=						input_a[input_name]

           self.assertFalse(_inputs_have_equal_length(UpperCamelCase_))
           self.assertTrue(_inputs_have_equal_length(UpperCamelCase_))
           self.assertTrue(_inputs_have_equal_length(UpperCamelCase_))
           self.assertTrue(_inputs_are_equal(UpperCamelCase_, UpperCamelCase_))
           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
           _lowercase			:				Tuple 						=						feat_extract.pad(UpperCamelCase_, pad_to_multiple_of=10)
           _lowercase			:				int 						=						input_a[input_name]

           _lowercase			:				List[Any] 						=						feat_extract.pad(UpperCamelCase_, padding='longest', pad_to_multiple_of=10)
           _lowercase			:				Any 						=						input_a[input_name]

           _lowercase			:				List[str] 						=						feat_extract.pad(
               UpperCamelCase_, padding='max_length', pad_to_multiple_of=10, max_length=UpperCamelCase_)
           _lowercase			:				List[Any] 						=						input_a[input_name]

           _lowercase			:				List[str] 						=						feat_extract.pad(
               UpperCamelCase_, padding='max_length', pad_to_multiple_of=10, max_length=UpperCamelCase_, return_tensors='np', )
           _lowercase			:				Any 						=						input_a[input_name]

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

           _lowercase			:				Optional[Any] 						=						pad_max_length if pad_max_length % 10 == 0 else (pad_max_length // 10 + 1) * 10
           self.assertTrue(all(len(UpperCamelCase_) == 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
           _lowercase			:				Union[str, 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, lowerCamelCase=False)			->  str:




           """simple docstring"""

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

           def _inputs_are_equal(lowerCamelCase, lowerCamelCase):
               if len(UpperCamelCase_) != len(UpperCamelCase_):
                   return False

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

           _lowercase			:				Any 						=						self.feature_extraction_class(**self.feat_extract_dict)
           _lowercase			:				Optional[Any] 						=						self.feat_extract_tester.prepare_inputs_for_common(numpify=UpperCamelCase_)
           _lowercase			:				str 						=						feat_extract.model_input_names[0]

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

           # truncate to smallest
           _lowercase			:				Union[str, Any] 						=						feat_extract.pad(
               UpperCamelCase_, padding='max_length', max_length=len(speech_inputs[0]), truncation=UpperCamelCase_)
           _lowercase			:				Tuple 						=						input_a[input_name]

           _lowercase			:				Tuple 						=						feat_extract.pad(UpperCamelCase_, padding='max_length', max_length=len(speech_inputs[0]))
           _lowercase			:				Optional[int] 						=						input_a[input_name]

           self.assertTrue(_inputs_have_equal_length(UpperCamelCase_))
           self.assertFalse(_inputs_have_equal_length(UpperCamelCase_))

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

           _lowercase			:				Dict 						=						feat_extract.pad(
               UpperCamelCase_, padding='max_length', max_length=len(speech_inputs[0]), return_tensors='np')
           _lowercase			:				Union[str, Any] 						=						input_a[input_name]

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

           # truncate to middle
           _lowercase			:				str 						=						feat_extract.pad(
               UpperCamelCase_, padding='max_length', max_length=len(speech_inputs[1]), truncation=UpperCamelCase_, return_tensors='np', )
           _lowercase			:				str 						=						input_a[input_name]

           _lowercase			:				List[Any] 						=						feat_extract.pad(
               UpperCamelCase_, padding='max_length', max_length=len(speech_inputs[1]), truncation=UpperCamelCase_)
           _lowercase			:				List[Any] 						=						input_a[input_name]

           _lowercase			:				str 						=						feat_extract.pad(
               UpperCamelCase_, padding='max_length', max_length=len(speech_inputs[1]), return_tensors='np')
           _lowercase			:				Union[str, Any] 						=						input_a[input_name]

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

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

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

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

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

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

           # test truncation for `pad_to_multiple_of` for List[int] + numpy
           _lowercase			:				Optional[Any] 						=						12
           _lowercase			:				Tuple 						=						feat_extract.pad(
               UpperCamelCase_, padding='max_length', max_length=len(speech_inputs[0]), pad_to_multiple_of=UpperCamelCase_, truncation=UpperCamelCase_, )
           _lowercase			:				Union[str, Any] 						=						input_a[input_name]

           _lowercase			:				Union[str, Any] 						=						feat_extract.pad(
               UpperCamelCase_, padding='max_length', max_length=len(speech_inputs[0]), pad_to_multiple_of=UpperCamelCase_, )
           _lowercase			:				str 						=						input_a[input_name]

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




           """simple docstring"""

           self._check_padding(numpify=UpperCamelCase_)
       def      UpperCamelCase	(   self)			->  int:




           """simple docstring"""

           self._check_padding(numpify=UpperCamelCase_)
       def      UpperCamelCase	(   self)			->  Dict:




           """simple docstring"""

           self._check_truncation(numpify=UpperCamelCase_)
       def      UpperCamelCase	(   self)			->  Dict:




           """simple docstring"""

           self._check_truncation(numpify=UpperCamelCase_)
       @require_torch
       def      UpperCamelCase	(   self)			->  Optional[Any]:




           """simple docstring"""

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

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

           _lowercase			:				int 						=						feat_extract.pad(UpperCamelCase_, padding='longest', return_tensors='np')[input_name]
           _lowercase			:				Union[str, Any] 						=						feat_extract.pad(UpperCamelCase_, 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)			->  Dict:




           """simple docstring"""

           _lowercase			:				Optional[int] 						=						self.feature_extraction_class(**self.feat_extract_dict)
           _lowercase			:				Tuple 						=						self.feat_extract_tester.prepare_inputs_for_common()
           _lowercase			:				Tuple 						=						feat_extract.model_input_names[0]

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

           _lowercase			:				Union[str, Any] 						=						feat_extract.pad(UpperCamelCase_, padding='longest', return_tensors='np')[input_name]
           _lowercase			:				List[str] 						=						feat_extract.pad(UpperCamelCase_, 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)			->  List[str]:




           """simple docstring"""

           _lowercase			:				List[str] 						=						self.feat_extract_dict
           _lowercase			:				str 						=						True
           _lowercase			:				Any 						=						self.feature_extraction_class(**UpperCamelCase_)
           _lowercase			:				int 						=						self.feat_extract_tester.prepare_inputs_for_common()
           _lowercase			:				Dict 						=						[len(UpperCamelCase_) for x in speech_inputs]
           _lowercase			:				Tuple 						=						feat_extract.model_input_names[0]

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

           _lowercase			:				Union[str, Any] 						=						feat_extract.pad(UpperCamelCase_, padding='longest', return_tensors='np')
           self.assertIn('attention_mask', UpperCamelCase_)
           self.assertListEqual(list(processed.attention_mask.shape), list(processed[input_name].shape[:2]))
           self.assertListEqual(processed.attention_mask.sum(-1).tolist(), UpperCamelCase_)




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




           """simple docstring"""

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

           _lowercase			:				int 						=						BatchFeature({input_name: speech_inputs})
           _lowercase			:				int 						=						min(UpperCamelCase_)

           _lowercase			:				Optional[int] 						=						feat_extract.pad(
               UpperCamelCase_, padding='max_length', max_length=UpperCamelCase_, truncation=UpperCamelCase_, return_tensors='np')
           self.assertIn('attention_mask', UpperCamelCase_)
           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"""
def 							A						(				__snake_case: int = 1_0_0_0_0_0_0  )    ->		int:

       """simple docstring"""





       __magic_name__      				=    limit + 1
       __magic_name__      				=    [0] * limit
       for first_term in range(1 ,     __snake_case  ):
              for n in range(__snake_case ,     __snake_case ,     __snake_case  ):
                     __magic_name__      				=    first_term + n / first_term
                     if common_difference % 4:  # d must be divisble by 4
                            continue
                     else:
                            common_difference /= 4
                            if (
                                first_term > common_difference
                                and first_term < 4 * common_difference
                            ):  # since x,y,z are positive integers
                                   frequency[n] += 1  # so z>0 and a>d ,also 4d<a

       __magic_name__      				=    sum(1 for x in frequency[1:limit] if x == 1_0  )

       return count


if __name__ == "__main__":
 print(f"""{solution() = }""")