





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 					__snake_case	(  __SCREAMING_SNAKE_CASE    ):


    '''simple docstring'''







    lowerCamelCase__    :		Union[str, Any]				=	None
    lowerCamelCase__    :		List[Any]				=	None



    @property
    def  lowercase_					(       self     ):





        '''simple docstring'''

        return self.feat_extract_tester.prepare_feat_extract_dict()



    def  lowercase_					(       self     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			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     ):





        '''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(A_     ) == len(A_     ) for x, y in zip(A_   ,				processed_features[input_name]     )     )     )

        SCREAMING_SNAKE_CASE__											=			self.feat_extract_tester.prepare_inputs_for_common(equal_length=A_     )
        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  lowercase_					(       self     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			self.feat_extract_tester.prepare_inputs_for_common(equal_length=A_     )
        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  lowercase_					(       self     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			self.feat_extract_tester.prepare_inputs_for_common(equal_length=A_     )
        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  lowercase_					(       self   ,				A_=False     ):





        '''simple docstring'''

        def _inputs_have_equal_length(A_     ):
            SCREAMING_SNAKE_CASE__											=			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

        SCREAMING_SNAKE_CASE__											=			self.feature_extraction_class(**self.feat_extract_dict     )
        SCREAMING_SNAKE_CASE__											=			self.feat_extract_tester.prepare_inputs_for_common(numpify=A_     )
        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(A_   ,				padding=A_     )
        SCREAMING_SNAKE_CASE__											=			input_a[input_name]

        SCREAMING_SNAKE_CASE__											=			feat_extract.pad(A_   ,				padding='''longest'''     )
        SCREAMING_SNAKE_CASE__											=			input_a[input_name]

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

        SCREAMING_SNAKE_CASE__											=			feat_extract.pad(A_   ,				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(A_     ):
            feat_extract.pad(A_   ,				padding='''max_length'''     )[input_name]

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

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

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

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

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

        SCREAMING_SNAKE_CASE__											=			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
        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  lowercase_					(       self   ,				A_=False     ):





        '''simple docstring'''

        def _inputs_have_equal_length(A_     ):
            SCREAMING_SNAKE_CASE__											=			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

        SCREAMING_SNAKE_CASE__											=			self.feature_extraction_class(**self.feat_extract_dict     )
        SCREAMING_SNAKE_CASE__											=			self.feat_extract_tester.prepare_inputs_for_common(numpify=A_     )
        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(
            A_   ,				padding='''max_length'''   ,				max_length=len(speech_inputs[0]     )   ,				truncation=A_     )
        SCREAMING_SNAKE_CASE__											=			input_a[input_name]

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

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

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

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

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

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

        SCREAMING_SNAKE_CASE__											=			feat_extract.pad(
            A_   ,				padding='''max_length'''   ,				max_length=len(speech_inputs[0]     )   ,				pad_to_multiple_of=A_   ,				)
        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(A_     )     )
        self.assertFalse(_inputs_have_equal_length(A_     )     )



    def  lowercase_					(       self     ):





        '''simple docstring'''

        self._check_padding(numpify=A_     )



    def  lowercase_					(       self     ):





        '''simple docstring'''

        self._check_padding(numpify=A_     )



    def  lowercase_					(       self     ):





        '''simple docstring'''

        self._check_truncation(numpify=A_     )



    def  lowercase_					(       self     ):





        '''simple docstring'''

        self._check_truncation(numpify=A_     )



    @require_torch
    def  lowercase_					(       self     ):





        '''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(A_   ,				padding='''longest'''   ,				return_tensors='''np'''     )[input_name]
        SCREAMING_SNAKE_CASE__											=			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     ):





        '''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(A_   ,				padding='''longest'''   ,				return_tensors='''np'''     )[input_name]
        SCREAMING_SNAKE_CASE__											=			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     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			self.feat_extract_dict
        SCREAMING_SNAKE_CASE__											=			True
        SCREAMING_SNAKE_CASE__											=			self.feature_extraction_class(**A_     )
        SCREAMING_SNAKE_CASE__											=			self.feat_extract_tester.prepare_inputs_for_common()
        SCREAMING_SNAKE_CASE__											=			[len(A_     ) 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(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     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			self.feat_extract_dict
        SCREAMING_SNAKE_CASE__											=			True
        SCREAMING_SNAKE_CASE__											=			self.feature_extraction_class(**A_     )
        SCREAMING_SNAKE_CASE__											=			self.feat_extract_tester.prepare_inputs_for_common()
        SCREAMING_SNAKE_CASE__											=			[len(A_     ) 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(A_     )

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







"""simple docstring"""






from __future__ import annotations






def      lowercase__ (					lowerCAmelCase__   :			int			)    ->			list[int]:



			'''simple docstring'''
			a__  :	Tuple		 =			[True] * limit
			a__  :	Tuple		 =			False
			a__  :	int		 =			False
			a__  :	Tuple		 =			True

			for i in range(3							,			int(limit**0.5 + 1			)							,			2			):
						a__  :	int		 =			i * 2
						while index < limit:
									a__  :	Union[str, Any]		 =			False
									a__  :	int		 =			index + i

			a__  :	str		 =			[2]

			for i in range(3							,			lowerCAmelCase__							,			2			):
						if is_prime[i]:
									primes.append(lowerCAmelCase__			)

			return primes






def      lowercase__ (					lowerCAmelCase__   :			int = 1_0_0_0_0_0_0			)    ->			int:



			'''simple docstring'''
			a__  :	List[Any]		 =			prime_sieve(lowerCAmelCase__			)
			a__  :	int		 =			0
			a__  :	str		 =			0

			for i in range(len(lowerCAmelCase__			)			):
						for j in range(i + length							,			len(lowerCAmelCase__			)			):
									a__  :	List[str]		 =			sum(primes[i:j]			)
									if sol >= ceiling:
												break

									if sol in primes:
												a__  :	Tuple		 =			j - i
												a__  :	Union[str, Any]		 =			sol

			return largest


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