
'''simple docstring'''
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


_SCREAMING_SNAKE_CASE =	get_tests_dir("fixtures/test_sentencepiece_bpe_char.model")
@require_torch
class      __UpperCAmelCase							(    unittest.TestCase							):



					'''simple docstring'''





					def 						__snake_case	(  self    :	List[Any])						->       int:
								A_       		=   tempfile.mkdtemp()

								A_       		=   SpeechTaTokenizer(SCREAMING_SNAKE_CASE_)
								tokenizer.save_pretrained(self.tmpdirname)

								A_       		=   {
								    '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,
								}

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



					def 						__snake_case	(  self    :	Tuple			,					**_lowercase    :	Union[str, Any])						->       str:
								return SpeechTaTokenizer.from_pretrained(self.tmpdirname			,					**SCREAMING_SNAKE_CASE_)



					def 						__snake_case	(  self    :	List[Any]			,					**_lowercase    :	List[str])						->       List[Any]:
								return SpeechTaFeatureExtractor.from_pretrained(self.tmpdirname			,					**SCREAMING_SNAKE_CASE_)



					def 						__snake_case	(  self    :	Optional[Any])						->       int:
								shutil.rmtree(self.tmpdirname)



					def 						__snake_case	(  self    :	Any)						->       Dict:
								A_       		=   self.get_tokenizer()
								A_       		=   self.get_feature_extractor()

								A_       		=   SpeechTaProcessor(tokenizer=SCREAMING_SNAKE_CASE_			,					feature_extractor=SCREAMING_SNAKE_CASE_)

								processor.save_pretrained(self.tmpdirname)
								A_       		=   SpeechTaProcessor.from_pretrained(self.tmpdirname)

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

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



					def 						__snake_case	(  self    :	str)						->       str:
								A_       		=   SpeechTaProcessor(tokenizer=self.get_tokenizer()			,					feature_extractor=self.get_feature_extractor())
								processor.save_pretrained(self.tmpdirname)

								A_       		=   self.get_tokenizer(bos_token='(BOS)'			,					eos_token='(EOS)')
								A_       		=   self.get_feature_extractor(do_normalize=SCREAMING_SNAKE_CASE_			,					padding_value=1.0)

								A_       		=   SpeechTaProcessor.from_pretrained(
								    self.tmpdirname			,					bos_token='(BOS)'			,					eos_token='(EOS)'			,					do_normalize=SCREAMING_SNAKE_CASE_			,					padding_value=1.0)

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

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



					def 						__snake_case	(  self    :	Dict)						->       str:
								A_       		=   self.get_feature_extractor()
								A_       		=   self.get_tokenizer()

								A_       		=   SpeechTaProcessor(tokenizer=SCREAMING_SNAKE_CASE_			,					feature_extractor=SCREAMING_SNAKE_CASE_)

								A_       		=   floats_list((3, 1_000))

								A_       		=   feature_extractor(audio=SCREAMING_SNAKE_CASE_			,					return_tensors='np')
								A_       		=   processor(audio=SCREAMING_SNAKE_CASE_			,					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 						__snake_case	(  self    :	Any)						->       int:
								A_       		=   self.get_feature_extractor()
								A_       		=   self.get_tokenizer()

								A_       		=   SpeechTaProcessor(tokenizer=SCREAMING_SNAKE_CASE_			,					feature_extractor=SCREAMING_SNAKE_CASE_)

								A_       		=   floats_list((3, 1_000))

								A_       		=   feature_extractor(audio_target=SCREAMING_SNAKE_CASE_			,					return_tensors='np')
								A_       		=   processor(audio_target=SCREAMING_SNAKE_CASE_			,					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 						__snake_case	(  self    :	List[str])						->       int:
								A_       		=   self.get_feature_extractor()
								A_       		=   self.get_tokenizer()

								A_       		=   SpeechTaProcessor(tokenizer=SCREAMING_SNAKE_CASE_			,					feature_extractor=SCREAMING_SNAKE_CASE_)

								A_       		=   'This is a test string'

								A_       		=   processor(text=SCREAMING_SNAKE_CASE_)
								A_       		=   tokenizer(SCREAMING_SNAKE_CASE_)

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



					def 						__snake_case	(  self    :	str)						->       Optional[Any]:
								A_       		=   self.get_feature_extractor()
								A_       		=   self.get_tokenizer()

								A_       		=   SpeechTaProcessor(tokenizer=SCREAMING_SNAKE_CASE_			,					feature_extractor=SCREAMING_SNAKE_CASE_)

								A_       		=   'This is a test string'

								A_       		=   processor(text_target=SCREAMING_SNAKE_CASE_)
								A_       		=   tokenizer(SCREAMING_SNAKE_CASE_)

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



					def 						__snake_case	(  self    :	List[Any])						->       Any:
								A_       		=   self.get_feature_extractor()
								A_       		=   self.get_tokenizer()

								A_       		=   SpeechTaProcessor(tokenizer=SCREAMING_SNAKE_CASE_			,					feature_extractor=SCREAMING_SNAKE_CASE_)

								A_       		=   [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

								A_       		=   processor.batch_decode(SCREAMING_SNAKE_CASE_)
								A_       		=   tokenizer.batch_decode(SCREAMING_SNAKE_CASE_)

								self.assertListEqual(SCREAMING_SNAKE_CASE_			,					SCREAMING_SNAKE_CASE_)



					def 						__snake_case	(  self    :	Tuple)						->       Dict:
								A_       		=   self.get_feature_extractor()
								A_       		=   self.get_tokenizer()

								A_       		=   SpeechTaProcessor(tokenizer=SCREAMING_SNAKE_CASE_			,					feature_extractor=SCREAMING_SNAKE_CASE_)

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










'''simple docstring'''
from __future__ import annotations

import sys





def  lowerCamelCase(       SCREAMING_SNAKE_CASE_					,SCREAMING_SNAKE_CASE_    )		->		tuple[int, int]:
			# base cases
			if abs(SCREAMING_SNAKE_CASE_    ) == 1:
						return a, 0
			elif abs(SCREAMING_SNAKE_CASE_    ) == 1:
						return 0, b

			A_		,   A_       		=   a, b
			A_		,   A_       		=   1, 0
			A_		,   A_       		=   0, 1

			while remainder != 0:
						A_       		=   old_remainder // remainder
						A_		,   A_       		=   remainder, old_remainder - quotient * remainder
						A_		,   A_       		=   coeff_a, old_coeff_a - quotient * coeff_a
						A_		,   A_       		=   coeff_b, old_coeff_b - quotient * coeff_b

			# sign correction for negative numbers
			if a < 0:
						A_       		=   -old_coeff_a
			if b < 0:
						A_       		=   -old_coeff_b

			return old_coeff_a, old_coeff_b





def  lowerCamelCase(       )		->		Tuple:
			if len(sys.argv    ) < 3:
						print('2 integer arguments required'    )
						return 1
			A_       		=   int(sys.argv[1]    )
			A_       		=   int(sys.argv[2]    )
			print(extended_euclidean_algorithm(SCREAMING_SNAKE_CASE_					,SCREAMING_SNAKE_CASE_    )    )
			return 0


if __name__ == "__main__":
							raise SystemExit(main())




