




import json
import os
import shutil
import tempfile
import unittest

from transformers import is_speech_available, is_torch_available
from transformers.models.speechta import SpeechTaTokenizer
from transformers.testing_utils import get_tests_dir, require_torch
from transformers.utils import FEATURE_EXTRACTOR_NAME


if is_speech_available() and is_torch_available():
							from transformers import SpeechTaFeatureExtractor, SpeechTaProcessor

							from .test_feature_extraction_speechta import floats_list


UpperCamelCase__						=		get_tests_dir('fixtures/test_sentencepiece_bpe_char.model')


@require_torch
class 							__SCREAMING_SNAKE_CASE				(						unittest.TestCase    ):

					def       lowercase_				(							self   ):







						'''simple docstring'''




						lowerCamelCase_				:						List[Any]				  =				tempfile.mkdtemp()

						lowerCamelCase_				:						Tuple				  =				SpeechTaTokenizer(__lowercase   )
						tokenizer.save_pretrained(self.tmpdirname   )

						lowerCamelCase_				:						Tuple				  =				{
						    'feature_size': 1,
						    'padding_value': 0.0,
						    'sampling_rate': 16_000,
						    'do_normalize': False,
						    'num_mel_bins': 80,
						    'hop_length': 16,
						    'win_length': 64,
						    'win_function': 'hann_window',
						    'fmin': 80,
						    'fmax': 7_600,
						    'mel_floor': 1E-10,
						    'reduction_factor': 2,
						    'return_attention_mask': True,
						}

						lowerCamelCase_				:						str				  =				os.path.join(self.tmpdirname					,			__lowercase   )
						with open(self.feature_extraction_file					,			'w'					,			encoding='utf-8'   ) as fp:
							fp.write(json.dumps(__lowercase   ) + '\n'   )

					def       lowercase_				(							self					,			**__lowercase   ):







						'''simple docstring'''




						return SpeechTaTokenizer.from_pretrained(self.tmpdirname					,			**__lowercase   )

					def       lowercase_				(							self					,			**__lowercase   ):







						'''simple docstring'''




						return SpeechTaFeatureExtractor.from_pretrained(self.tmpdirname					,			**__lowercase   )

					def       lowercase_				(							self   ):







						'''simple docstring'''




						shutil.rmtree(self.tmpdirname   )

					def       lowercase_				(							self   ):







						'''simple docstring'''




						lowerCamelCase_				:						Optional[Any]				  =				self.get_tokenizer()
						lowerCamelCase_				:						Tuple				  =				self.get_feature_extractor()

						lowerCamelCase_				:						Dict				  =				SpeechTaProcessor(tokenizer=__lowercase					,			feature_extractor=__lowercase   )

						processor.save_pretrained(self.tmpdirname   )
						lowerCamelCase_				:						int				  =				SpeechTaProcessor.from_pretrained(self.tmpdirname   )

						self.assertEqual(processor.tokenizer.get_vocab()					,			tokenizer.get_vocab()   )
						self.assertIsInstance(processor.tokenizer					,			__lowercase   )

						self.assertEqual(processor.feature_extractor.to_json_string()					,			feature_extractor.to_json_string()   )
						self.assertIsInstance(processor.feature_extractor					,			__lowercase   )

					def       lowercase_				(							self   ):







						'''simple docstring'''




						lowerCamelCase_				:						str				  =				SpeechTaProcessor(tokenizer=self.get_tokenizer()					,			feature_extractor=self.get_feature_extractor()   )
						processor.save_pretrained(self.tmpdirname   )

						lowerCamelCase_				:						Any				  =				self.get_tokenizer(bos_token='(BOS)'					,			eos_token='(EOS)'   )
						lowerCamelCase_				:						Optional[Any]				  =				self.get_feature_extractor(do_normalize=__lowercase					,			padding_value=1.0   )

						lowerCamelCase_				:						Tuple				  =				SpeechTaProcessor.from_pretrained(
						    self.tmpdirname					,			bos_token='(BOS)'					,			eos_token='(EOS)'					,			do_normalize=__lowercase					,			padding_value=1.0   )

						self.assertEqual(processor.tokenizer.get_vocab()					,			tokenizer_add_kwargs.get_vocab()   )
						self.assertIsInstance(processor.tokenizer					,			__lowercase   )

						self.assertEqual(processor.feature_extractor.to_json_string()					,			feature_extractor_add_kwargs.to_json_string()   )
						self.assertIsInstance(processor.feature_extractor					,			__lowercase   )

					def       lowercase_				(							self   ):







						'''simple docstring'''




						lowerCamelCase_				:						List[str]				  =				self.get_feature_extractor()
						lowerCamelCase_				:						Optional[Any]				  =				self.get_tokenizer()

						lowerCamelCase_				:						Any				  =				SpeechTaProcessor(tokenizer=__lowercase					,			feature_extractor=__lowercase   )

						lowerCamelCase_				:						Dict				  =				floats_list((3, 1_000)   )

						lowerCamelCase_				:						Optional[Any]				  =				feature_extractor(audio=__lowercase					,			return_tensors='np'   )
						lowerCamelCase_				:						Optional[int]				  =				processor(audio=__lowercase					,			return_tensors='np'   )

						for key in input_feat_extract.keys():
							self.assertAlmostEqual(input_feat_extract[key].sum()					,			input_processor[key].sum()					,			delta=1E-2   )

					def       lowercase_				(							self   ):







						'''simple docstring'''




						lowerCamelCase_				:						List[Any]				  =				self.get_feature_extractor()
						lowerCamelCase_				:						List[str]				  =				self.get_tokenizer()

						lowerCamelCase_				:						Any				  =				SpeechTaProcessor(tokenizer=__lowercase					,			feature_extractor=__lowercase   )

						lowerCamelCase_				:						str				  =				floats_list((3, 1_000)   )

						lowerCamelCase_				:						str				  =				feature_extractor(audio_target=__lowercase					,			return_tensors='np'   )
						lowerCamelCase_				:						Union[str, Any]				  =				processor(audio_target=__lowercase					,			return_tensors='np'   )

						for key in input_feat_extract.keys():
							self.assertAlmostEqual(input_feat_extract[key].sum()					,			input_processor[key].sum()					,			delta=1E-2   )

					def       lowercase_				(							self   ):







						'''simple docstring'''




						lowerCamelCase_				:						Optional[int]				  =				self.get_feature_extractor()
						lowerCamelCase_				:						int				  =				self.get_tokenizer()

						lowerCamelCase_				:						Union[str, Any]				  =				SpeechTaProcessor(tokenizer=__lowercase					,			feature_extractor=__lowercase   )

						lowerCamelCase_				:						Optional[int]				  =				'This is a test string'

						lowerCamelCase_				:						List[Any]				  =				processor(text=__lowercase   )
						lowerCamelCase_				:						int				  =				tokenizer(__lowercase   )

						for key in encoded_tok.keys():
							self.assertListEqual(encoded_tok[key]					,			encoded_processor[key]   )

					def       lowercase_				(							self   ):







						'''simple docstring'''




						lowerCamelCase_				:						Optional[int]				  =				self.get_feature_extractor()
						lowerCamelCase_				:						Optional[Any]				  =				self.get_tokenizer()

						lowerCamelCase_				:						Optional[Any]				  =				SpeechTaProcessor(tokenizer=__lowercase					,			feature_extractor=__lowercase   )

						lowerCamelCase_				:						str				  =				'This is a test string'

						lowerCamelCase_				:						List[Any]				  =				processor(text_target=__lowercase   )
						lowerCamelCase_				:						int				  =				tokenizer(__lowercase   )

						for key in encoded_tok.keys():
							self.assertListEqual(encoded_tok[key]					,			encoded_processor[key]   )

					def       lowercase_				(							self   ):







						'''simple docstring'''




						lowerCamelCase_				:						Dict				  =				self.get_feature_extractor()
						lowerCamelCase_				:						Any				  =				self.get_tokenizer()

						lowerCamelCase_				:						Any				  =				SpeechTaProcessor(tokenizer=__lowercase					,			feature_extractor=__lowercase   )

						lowerCamelCase_				:						Union[str, Any]				  =				[[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

						lowerCamelCase_				:						Dict				  =				processor.batch_decode(__lowercase   )
						lowerCamelCase_				:						List[Any]				  =				tokenizer.batch_decode(__lowercase   )

						self.assertListEqual(__lowercase					,			__lowercase   )





					def       lowercase_				(							self   ):







						'''simple docstring'''




						lowerCamelCase_				:						List[Any]				  =				self.get_feature_extractor()
						lowerCamelCase_				:						str				  =				self.get_tokenizer()

						lowerCamelCase_				:						List[Any]				  =				SpeechTaProcessor(tokenizer=__lowercase					,			feature_extractor=__lowercase   )

						self.assertListEqual(
						    processor.model_input_names					,			feature_extractor.model_input_names					,			msg='`processor` and `feature_extractor` model input names do not match'					,			)






def    snake_case   (				A		,  A     )				->				int:




	'''simple docstring'''


	if a < b:
		return gcd(A		,  A     )
	if a % b == 0:
		return b
	return gcd(A		,  a % b     )






def    snake_case   (				A		,  A		,  A     )				->				int:




	'''simple docstring'''


	if y == 0:
		return 1
	lowerCamelCase_				:						int				  =				power(A		,  y // 2		,  A     ) % mod
	lowerCamelCase_				:						List[Any]				  =				(temp * temp) % mod
	if y % 2 == 1:
		lowerCamelCase_				:						str				  =				(temp * x) % mod
	return temp






def    snake_case   (				A     )				->				bool:




	'''simple docstring'''


	lowerCamelCase_				:						Union[str, Any]				  =				2
	while b < n:
		if gcd(A		,  A     ) == 1 and power(A		,  n - 1		,  A     ) != 1:
			return False
		b += 1
	return True


if __name__ == "__main__":
							UpperCamelCase__						=		int(input('Enter number: ').strip())
							if is_carmichael_number(number):
														print(F'{number} is a Carmichael Number.')
							else:
														print(F'{number} is not a Carmichael Number.')
