



"""simple docstring"""

import unittest

import numpy as np

from transformers import MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING, TF_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING
from transformers.pipelines import AudioClassificationPipeline, pipeline
from transformers.testing_utils import (
    is_pipeline_test,
    nested_simplify,
    require_tf,
    require_torch,
    require_torchaudio,
    slow,
)

from .test_pipelines_common import ANY







@is_pipeline_test
class    __lowercase     (					unittest.TestCase):







						"""simple docstring"""







						_A		:							str							       =		MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING
						_A		:							List[str]							       =		TF_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING







						def 						__UpperCamelCase							(self   ,		lowercase__   ,		lowercase__   ,		lowercase__       ):
											snake_case_					:		Dict 					=					AudioClassificationPipeline(model=_lowerCamelCase   ,		feature_extractor=_lowerCamelCase       )

											# test with a raw waveform
											snake_case_					:		Tuple 					=					np.zeros((3_40_00,)       )
											snake_case_					:		List[Any] 					=					np.zeros((1_40_00,)       )
											return audio_classifier, [audioa, audio]







						def 						__UpperCamelCase							(self   ,		lowercase__   ,		lowercase__       ):
											snake_case_					,			snake_case_					:		Any 					=					examples
											snake_case_					:		Dict 					=					audio_classifier(_lowerCamelCase       )
											# by default a model is initialized with num_labels=2
											self.assertEqual(
											    _lowerCamelCase   ,		[
											        {"""score""": ANY(_lowerCamelCase       ), """label""": ANY(_lowerCamelCase       )},
											        {"""score""": ANY(_lowerCamelCase       ), """label""": ANY(_lowerCamelCase       )},
											    ]   ,		)
											snake_case_					:		Optional[Any] 					=					audio_classifier(_lowerCamelCase   ,		top_k=1       )
											self.assertEqual(
											    _lowerCamelCase   ,		[
											        {"""score""": ANY(_lowerCamelCase       ), """label""": ANY(_lowerCamelCase       )},
											    ]   ,		)

											self.run_torchaudio(_lowerCamelCase       )







						@require_torchaudio
						def 						__UpperCamelCase							(self   ,		lowercase__       ):
											import datasets

											# test with a local file
											snake_case_					:		Tuple 					=					datasets.load_dataset("""hf-internal-testing/librispeech_asr_dummy"""   ,		"""clean"""   ,		split="""validation"""       )
											snake_case_					:		str 					=					dataset[0]["""audio"""]["""array"""]
											snake_case_					:		Optional[Any] 					=					audio_classifier(_lowerCamelCase       )
											self.assertEqual(
											    _lowerCamelCase   ,		[
											        {"""score""": ANY(_lowerCamelCase       ), """label""": ANY(_lowerCamelCase       )},
											        {"""score""": ANY(_lowerCamelCase       ), """label""": ANY(_lowerCamelCase       )},
											    ]   ,		)







						@require_torch
						def 						__UpperCamelCase							(self       ):
											snake_case_					:		Union[str, Any] 					=					"""anton-l/wav2vec2-random-tiny-classifier"""

											snake_case_					:		Optional[Any] 					=					pipeline("""audio-classification"""   ,		model=_lowerCamelCase       )

											snake_case_					:		Dict 					=					np.ones((80_00,)       )
											snake_case_					:		int 					=					audio_classifier(_lowerCamelCase   ,		top_k=4       )

											snake_case_					:		Tuple 					=					[
											    {"""score""": 0.0842, """label""": """no"""},
											    {"""score""": 0.0838, """label""": """up"""},
											    {"""score""": 0.0837, """label""": """go"""},
											    {"""score""": 0.0834, """label""": """right"""},
											]
											snake_case_					:		List[Any] 					=					[
											    {"""score""": 0.0845, """label""": """stop"""},
											    {"""score""": 0.0844, """label""": """on"""},
											    {"""score""": 0.0841, """label""": """right"""},
											    {"""score""": 0.0834, """label""": """left"""},
											]
											self.assertIn(nested_simplify(_lowerCamelCase   ,		decimals=4       )   ,		[EXPECTED_OUTPUT, EXPECTED_OUTPUT_PT_2]       )

											snake_case_					:		str 					=					{"""array""": np.ones((80_00,)       ), """sampling_rate""": audio_classifier.feature_extractor.sampling_rate}
											snake_case_					:		Optional[int] 					=					audio_classifier(_lowerCamelCase   ,		top_k=4       )
											self.assertIn(nested_simplify(_lowerCamelCase   ,		decimals=4       )   ,		[EXPECTED_OUTPUT, EXPECTED_OUTPUT_PT_2]       )







						@require_torch
						@slow
						def 						__UpperCamelCase							(self       ):
											import datasets

											snake_case_					:		Optional[int] 					=					"""superb/wav2vec2-base-superb-ks"""

											snake_case_					:		Optional[Any] 					=					pipeline("""audio-classification"""   ,		model=_lowerCamelCase       )
											snake_case_					:		Tuple 					=					datasets.load_dataset("""anton-l/superb_dummy"""   ,		"""ks"""   ,		split="""test"""       )

											snake_case_					:		Optional[Any] 					=					np.array(dataset[3]["""speech"""]   ,		dtype=np.floataa       )
											snake_case_					:		Tuple 					=					audio_classifier(_lowerCamelCase   ,		top_k=4       )
											self.assertEqual(
											    nested_simplify(_lowerCamelCase   ,		decimals=3       )   ,		[
											        {"""score""": 0.981, """label""": """go"""},
											        {"""score""": 0.007, """label""": """up"""},
											        {"""score""": 0.006, """label""": """_unknown_"""},
											        {"""score""": 0.001, """label""": """down"""},
											    ]   ,		)







						@require_tf
						@unittest.skip("""Audio classification is not implemented for TF"""       )
						def 						__UpperCamelCase							(self       ):
											pass










"""simple docstring"""

import random







def 							SCREAMING_SNAKE_CASE__      (		SCREAMING_SNAKE_CASE__ :  int			):



					"""simple docstring"""





					snake_case_					:		Union[str, Any] 					=					num - 1
					snake_case_					:		List[str] 					=					0

					while s % 2 == 0:
										snake_case_					:		str 					=					s // 2
										t += 1

					for _ in range(5			):
										snake_case_					:		List[Any] 					=					random.randrange(2				,    num - 1			)
										snake_case_					:		Dict 					=					pow(SCREAMING_SNAKE_CASE__				,    SCREAMING_SNAKE_CASE__				,    SCREAMING_SNAKE_CASE__			)
										if v != 1:
															snake_case_					:		int 					=					0
															while v != (num - 1):
																				if i == t - 1:
																									return False
																				else:
																									snake_case_					:		str 					=					i + 1
																									snake_case_					:		int 					=					(v**2) % num
					return True







def 							SCREAMING_SNAKE_CASE__      (		SCREAMING_SNAKE_CASE__ :  int			):



					"""simple docstring"""





					if num < 2:
										return False

					snake_case_					:		Dict 					=					[
					    2,
					    3,
					    5,
					    7,
					    1_1,
					    1_3,
					    1_7,
					    1_9,
					    2_3,
					    2_9,
					    3_1,
					    3_7,
					    4_1,
					    4_3,
					    4_7,
					    5_3,
					    5_9,
					    6_1,
					    6_7,
					    7_1,
					    7_3,
					    7_9,
					    8_3,
					    8_9,
					    9_7,
					    1_0_1,
					    1_0_3,
					    1_0_7,
					    1_0_9,
					    1_1_3,
					    1_2_7,
					    1_3_1,
					    1_3_7,
					    1_3_9,
					    1_4_9,
					    1_5_1,
					    1_5_7,
					    1_6_3,
					    1_6_7,
					    1_7_3,
					    1_7_9,
					    1_8_1,
					    1_9_1,
					    1_9_3,
					    1_9_7,
					    1_9_9,
					    2_1_1,
					    2_2_3,
					    2_2_7,
					    2_2_9,
					    2_3_3,
					    2_3_9,
					    2_4_1,
					    2_5_1,
					    2_5_7,
					    2_6_3,
					    2_6_9,
					    2_7_1,
					    2_7_7,
					    2_8_1,
					    2_8_3,
					    2_9_3,
					    3_0_7,
					    3_1_1,
					    3_1_3,
					    3_1_7,
					    3_3_1,
					    3_3_7,
					    3_4_7,
					    3_4_9,
					    3_5_3,
					    3_5_9,
					    3_6_7,
					    3_7_3,
					    3_7_9,
					    3_8_3,
					    3_8_9,
					    3_9_7,
					    4_0_1,
					    4_0_9,
					    4_1_9,
					    4_2_1,
					    4_3_1,
					    4_3_3,
					    4_3_9,
					    4_4_3,
					    4_4_9,
					    4_5_7,
					    4_6_1,
					    4_6_3,
					    4_6_7,
					    4_7_9,
					    4_8_7,
					    4_9_1,
					    4_9_9,
					    5_0_3,
					    5_0_9,
					    5_2_1,
					    5_2_3,
					    5_4_1,
					    5_4_7,
					    5_5_7,
					    5_6_3,
					    5_6_9,
					    5_7_1,
					    5_7_7,
					    5_8_7,
					    5_9_3,
					    5_9_9,
					    6_0_1,
					    6_0_7,
					    6_1_3,
					    6_1_7,
					    6_1_9,
					    6_3_1,
					    6_4_1,
					    6_4_3,
					    6_4_7,
					    6_5_3,
					    6_5_9,
					    6_6_1,
					    6_7_3,
					    6_7_7,
					    6_8_3,
					    6_9_1,
					    7_0_1,
					    7_0_9,
					    7_1_9,
					    7_2_7,
					    7_3_3,
					    7_3_9,
					    7_4_3,
					    7_5_1,
					    7_5_7,
					    7_6_1,
					    7_6_9,
					    7_7_3,
					    7_8_7,
					    7_9_7,
					    8_0_9,
					    8_1_1,
					    8_2_1,
					    8_2_3,
					    8_2_7,
					    8_2_9,
					    8_3_9,
					    8_5_3,
					    8_5_7,
					    8_5_9,
					    8_6_3,
					    8_7_7,
					    8_8_1,
					    8_8_3,
					    8_8_7,
					    9_0_7,
					    9_1_1,
					    9_1_9,
					    9_2_9,
					    9_3_7,
					    9_4_1,
					    9_4_7,
					    9_5_3,
					    9_6_7,
					    9_7_1,
					    9_7_7,
					    9_8_3,
					    9_9_1,
					    9_9_7,
					]

					if num in low_primes:
										return True

					for prime in low_primes:
										if (num % prime) == 0:
															return False

					return rabin_miller(SCREAMING_SNAKE_CASE__			)







def 							SCREAMING_SNAKE_CASE__      (		SCREAMING_SNAKE_CASE__ :  int = 1_0_2_4			):



					"""simple docstring"""





					while True:
										snake_case_					:		Tuple 					=					random.randrange(2 ** (keysize - 1)				,    2 ** (keysize)			)
										if is_prime_low_num(SCREAMING_SNAKE_CASE__			):
															return num


if __name__ == "__main__":
			a_			   =					generate_large_prime()
			print(('''Prime number:''', num))
			print(('''is_prime_low_num:''', is_prime_low_num(num)))




