





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     SCREAMING_SNAKE_CASE__ (						UpperCamelCase__      ):
 # to overwrite at feature extractactor specific tests
 __SCREAMING_SNAKE_CASE							       =	None
 __SCREAMING_SNAKE_CASE							       =	None



 @property
 def 				UpperCamelCase			(							self ):
        return self.feat_extract_tester.prepare_feat_extract_dict()



 def 				UpperCamelCase			(							self ):
        A__											=						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 				UpperCamelCase			(							self ):
        A__											=						self.feat_extract_tester.prepare_inputs_for_common()
        A__											=						self.feature_extraction_class(**self.feat_extract_dict )
        A__											=						feat_extract.model_input_names[0]

        A__											=						BatchFeature({input_name: speech_inputs} )

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

        A__											=						self.feat_extract_tester.prepare_inputs_for_common(equal_length=__lowerCamelCase )
        A__											=						BatchFeature({input_name: speech_inputs},tensor_type='''np''' )

        A__											=						processed_features[input_name]

        if len(batch_features_input.shape ) < 3:
               A__											=						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 ):
        A__											=						self.feat_extract_tester.prepare_inputs_for_common(equal_length=__lowerCamelCase )
        A__											=						self.feature_extraction_class(**self.feat_extract_dict )
        A__											=						feat_extract.model_input_names[0]

        A__											=						BatchFeature({input_name: speech_inputs},tensor_type='''pt''' )

        A__											=						processed_features[input_name]

        if len(batch_features_input.shape ) < 3:
               A__											=						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 ):
        A__											=						self.feat_extract_tester.prepare_inputs_for_common(equal_length=__lowerCamelCase )
        A__											=						self.feature_extraction_class(**self.feat_extract_dict )
        A__											=						feat_extract.model_input_names[0]

        A__											=						BatchFeature({input_name: speech_inputs},tensor_type='''tf''' )

        A__											=						processed_features[input_name]

        if len(batch_features_input.shape ) < 3:
               A__											=						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 ):
        def _inputs_have_equal_length(__lowerCamelCase ):
               A__											=						len(input[0] )
               for input_slice in input[1:]:
                      if len(__lowerCamelCase ) != length:
                             return False
               return True

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

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

        A__											=						BatchFeature({input_name: speech_inputs} )

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

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

        A__											=						feat_extract.pad(__lowerCamelCase,padding='''longest''' )
        A__											=						input_a[input_name]

        A__											=						feat_extract.pad(__lowerCamelCase,padding='''max_length''',max_length=len(speech_inputs[-1] ) )
        A__											=						input_a[input_name]

        A__											=						feat_extract.pad(__lowerCamelCase,padding='''longest''',return_tensors='''np''' )
        A__											=						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]

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

        A__											=						feat_extract.pad(__lowerCamelCase,padding='''longest''',pad_to_multiple_of=10 )
        A__											=						input_a[input_name]

        A__											=						feat_extract.pad(
            __lowerCamelCase,padding='''max_length''',pad_to_multiple_of=10,max_length=__lowerCamelCase )
        A__											=						input_a[input_name]

        A__											=						feat_extract.pad(
            __lowerCamelCase,padding='''max_length''',pad_to_multiple_of=10,max_length=__lowerCamelCase,return_tensors='''np''',)
        A__											=						input_a[input_name]

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

        A__											=						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
        A__											=						(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 ):
        def _inputs_have_equal_length(__lowerCamelCase ):
               A__											=						len(input[0] )
               for input_slice in input[1:]:
                      if len(__lowerCamelCase ) != length:
                             return False
               return True

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

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

        A__											=						BatchFeature({input_name: speech_inputs} )

        # truncate to smallest
        A__											=						feat_extract.pad(
            __lowerCamelCase,padding='''max_length''',max_length=len(speech_inputs[0] ),truncation=__lowerCamelCase )
        A__											=						input_a[input_name]

        A__											=						feat_extract.pad(__lowerCamelCase,padding='''max_length''',max_length=len(speech_inputs[0] ) )
        A__											=						input_a[input_name]

        self.assertTrue(_inputs_have_equal_length(__lowerCamelCase ) )
        self.assertFalse(_inputs_have_equal_length(__lowerCamelCase ) )

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

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

        A__											=						feat_extract.pad(
            __lowerCamelCase,padding='''max_length''',max_length=len(speech_inputs[1] ),truncation=__lowerCamelCase )
        A__											=						input_a[input_name]

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

        A__											=						feat_extract.pad(
            __lowerCamelCase,padding='''max_length''',max_length=len(speech_inputs[0] ),pad_to_multiple_of=__lowerCamelCase,)
        A__											=						input_a[input_name]

        # retrieve expected_length as multiple of pad_to_multiple_of
        A__											=						len(speech_inputs[0] )
        if expected_length % pad_to_multiple_of != 0:
               A__											=						((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 				UpperCamelCase			(							self ):
        self._check_padding(numpify=__lowerCamelCase )



 def 				UpperCamelCase			(							self ):
        self._check_padding(numpify=__lowerCamelCase )



 def 				UpperCamelCase			(							self ):
        self._check_truncation(numpify=__lowerCamelCase )



 def 				UpperCamelCase			(							self ):
        self._check_truncation(numpify=__lowerCamelCase )



 @require_torch
 def 				UpperCamelCase			(							self ):
        A__											=						self.feature_extraction_class(**self.feat_extract_dict )
        A__											=						self.feat_extract_tester.prepare_inputs_for_common()
        A__											=						feat_extract.model_input_names[0]

        A__											=						BatchFeature({input_name: speech_inputs} )

        A__											=						feat_extract.pad(__lowerCamelCase,padding='''longest''',return_tensors='''np''' )[input_name]
        A__											=						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 				UpperCamelCase			(							self ):
        A__											=						self.feature_extraction_class(**self.feat_extract_dict )
        A__											=						self.feat_extract_tester.prepare_inputs_for_common()
        A__											=						feat_extract.model_input_names[0]

        A__											=						BatchFeature({input_name: speech_inputs} )

        A__											=						feat_extract.pad(__lowerCamelCase,padding='''longest''',return_tensors='''np''' )[input_name]
        A__											=						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 				UpperCamelCase			(							self ):
        A__											=						self.feat_extract_dict
        A__											=						True
        A__											=						self.feature_extraction_class(**__lowerCamelCase )
        A__											=						self.feat_extract_tester.prepare_inputs_for_common()
        A__											=						[len(__lowerCamelCase ) for x in speech_inputs]
        A__											=						feat_extract.model_input_names[0]

        A__											=						BatchFeature({input_name: speech_inputs} )

        A__											=						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 				UpperCamelCase			(							self ):
        A__											=						self.feat_extract_dict
        A__											=						True
        A__											=						self.feature_extraction_class(**__lowerCamelCase )
        A__											=						self.feat_extract_tester.prepare_inputs_for_common()
        A__											=						[len(__lowerCamelCase ) for x in speech_inputs]
        A__											=						feat_extract.model_input_names[0]

        A__											=						BatchFeature({input_name: speech_inputs} )
        A__											=						min(__lowerCamelCase )

        A__											=						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

import math


def 	UpperCamelCase__(       UpperCamelCase__			:       int  )->bool:

       if 1 < number < 4:
              # 2 and 3 are primes
              return True
       elif number < 2 or number % 2 == 0 or number % 3 == 0:
              # Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
              return False

       # All primes number are in format of 6k +/- 1
       for i in range(5 ,     int(math.sqrt(UpperCamelCase__  ) + 1  ) ,     6  ):
              if number % i == 0 or number % (i + 2) == 0:
                     return False
       return True


def 	UpperCamelCase__(       UpperCamelCase__			:       int  )->list[int]:
       A__											=						str(UpperCamelCase__  )
       A__											=						[n]
       for i in range(1 ,     len(UpperCamelCase__  )  ):
              list_nums.append(int(str_num[i:]  )  )
              list_nums.append(int(str_num[:-i]  )  )
       return list_nums


def 	UpperCamelCase__(       UpperCamelCase__			:       int  )->bool:
       if len(str(UpperCamelCase__  )  ) > 3:
              if not is_prime(int(str(UpperCamelCase__  )[-3:]  )  ) or not is_prime(int(str(UpperCamelCase__  )[:3]  )  ):
                     return False
       return True


def 	UpperCamelCase__(       UpperCamelCase__			:       int = 11  )->list[int]:
       A__											=						[]
       A__											=						13
       while len(UpperCamelCase__  ) != count:
              if validate(UpperCamelCase__  ):
                     A__											=						list_truncated_nums(UpperCamelCase__  )
                     if all(is_prime(UpperCamelCase__  ) for i in list_nums  ):
                            list_truncated_primes.append(UpperCamelCase__  )
              num += 2
       return list_truncated_primes


def 	UpperCamelCase__(       )->int:
       return sum(compute_truncated_primes(11  )  )


if __name__ == "__main__":
       print(F"{sum(compute_truncated_primes(11)) = }")





