



import shutil
import tempfile
import unittest
from pathlib import Path
from shutil import copyfile

from transformers import SpeechaTextTokenizer, is_speech_available
from transformers.models.speech_to_text.tokenization_speech_to_text import VOCAB_FILES_NAMES, save_json
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_torch, require_torchaudio
from transformers.utils import FEATURE_EXTRACTOR_NAME

from .test_feature_extraction_speech_to_text import floats_list


if is_speech_available():
				from transformers import SpeechaTextFeatureExtractor, SpeechaTextProcessor


__UpperCAmelCase      = get_tests_dir('''fixtures/test_sentencepiece.model''')



@require_torch
@require_torchaudio
@require_sentencepiece
class        lowerCAmelCase_	(						unittest.TestCase							):
							def       snake_case_ (    self )  ->	Optional[Any]:
										UpperCamelCase					:						List[Any]					=			tempfile.mkdtemp()

										UpperCamelCase					:						Dict					=			['<s>', '<pad>', '</s>', '<unk>', '▁This', '▁is', '▁a', '▁t', 'est']
										UpperCamelCase					:						Dict					=			dict(zip(SCREAMING_SNAKE_CASE_,    range(len(SCREAMING_SNAKE_CASE_ ) ) ) )
										UpperCamelCase					:						int					=			Path(self.tmpdirname )
										save_json(SCREAMING_SNAKE_CASE_,    save_dir / VOCAB_FILES_NAMES['vocab_file'] )
										if not (save_dir / VOCAB_FILES_NAMES["spm_file"]).exists():
													copyfile(SCREAMING_SNAKE_CASE_,    save_dir / VOCAB_FILES_NAMES['spm_file'] )

										UpperCamelCase					:						Any					=			SpeechaTextTokenizer.from_pretrained(self.tmpdirname )
										tokenizer.save_pretrained(self.tmpdirname )

										UpperCamelCase					:						Union[str, Any]					=			{
										    'feature_size': 24,
										    'num_mel_bins': 24,
										    'padding_value': 0.0,
										    'sampling_rate': 1_6000,
										    'return_attention_mask': False,
										    'do_normalize': True,
										}
										save_json(SCREAMING_SNAKE_CASE_,    save_dir / FEATURE_EXTRACTOR_NAME )
							def       snake_case_ (    self,    **SCREAMING_SNAKE_CASE_ )  ->	Dict:
										return SpeechaTextTokenizer.from_pretrained(self.tmpdirname,    **SCREAMING_SNAKE_CASE_ )
							def       snake_case_ (    self,    **SCREAMING_SNAKE_CASE_ )  ->	List[str]:
										return SpeechaTextFeatureExtractor.from_pretrained(self.tmpdirname,    **SCREAMING_SNAKE_CASE_ )
							def       snake_case_ (    self )  ->	int:
										shutil.rmtree(self.tmpdirname )
							def       snake_case_ (    self )  ->	Optional[Any]:
										UpperCamelCase					:						Any					=			self.get_tokenizer()
										UpperCamelCase					:						Dict					=			self.get_feature_extractor()

										UpperCamelCase					:						Optional[int]					=			SpeechaTextProcessor(tokenizer=SCREAMING_SNAKE_CASE_,    feature_extractor=SCREAMING_SNAKE_CASE_ )

										processor.save_pretrained(self.tmpdirname )
										UpperCamelCase					:						List[str]					=			SpeechaTextProcessor.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 )  ->	List[Any]:
										UpperCamelCase					:						Optional[int]					=			SpeechaTextProcessor(
										    tokenizer=self.get_tokenizer(),    feature_extractor=self.get_feature_extractor() )
										processor.save_pretrained(self.tmpdirname )

										UpperCamelCase					:						List[Any]					=			self.get_tokenizer(bos_token='(BOS)',    eos_token='(EOS)' )
										UpperCamelCase					:						Any					=			self.get_feature_extractor(do_normalize=SCREAMING_SNAKE_CASE_,    padding_value=1.0 )

										UpperCamelCase					:						List[str]					=			SpeechaTextProcessor.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 )  ->	str:
										UpperCamelCase					:						Dict					=			self.get_feature_extractor()
										UpperCamelCase					:						Optional[int]					=			self.get_tokenizer()

										UpperCamelCase					:						Any					=			SpeechaTextProcessor(tokenizer=SCREAMING_SNAKE_CASE_,    feature_extractor=SCREAMING_SNAKE_CASE_ )

										UpperCamelCase					:						int					=			floats_list((3, 1000) )

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

										UpperCamelCase					:						Tuple					=			SpeechaTextProcessor(tokenizer=SCREAMING_SNAKE_CASE_,    feature_extractor=SCREAMING_SNAKE_CASE_ )

										UpperCamelCase					:						List[Any]					=			'This is a test string'

										UpperCamelCase					:						int					=			processor(text=SCREAMING_SNAKE_CASE_ )

										UpperCamelCase					:						List[Any]					=			tokenizer(SCREAMING_SNAKE_CASE_ )

										for key in encoded_tok.keys():
													self.assertListEqual(encoded_tok[key],    encoded_processor[key] )
							def       snake_case_ (    self )  ->	Union[str, Any]:
										UpperCamelCase					:						Dict					=			self.get_feature_extractor()
										UpperCamelCase					:						Union[str, Any]					=			self.get_tokenizer()

										UpperCamelCase					:						int					=			SpeechaTextProcessor(tokenizer=SCREAMING_SNAKE_CASE_,    feature_extractor=SCREAMING_SNAKE_CASE_ )

										UpperCamelCase					:						Tuple					=			[[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

										UpperCamelCase					:						List[Any]					=			processor.batch_decode(SCREAMING_SNAKE_CASE_ )
										UpperCamelCase					:						int					=			tokenizer.batch_decode(SCREAMING_SNAKE_CASE_ )

										self.assertListEqual(SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_ )






							def       snake_case_ (    self )  ->	Union[str, Any]:
										UpperCamelCase					:						Tuple					=			self.get_feature_extractor()
										UpperCamelCase					:						Union[str, Any]					=			self.get_tokenizer()

										UpperCamelCase					:						Any					=			SpeechaTextProcessor(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',    )








from __future__ import annotations

import sys
def 	UpperCamelCase			(     snake_case__ :					int ,  snake_case__ :					int			)			->  tuple[int, int]:
   # base cases
   if abs(snake_case__			) == 1:
      return a, 0
   elif abs(snake_case__			) == 1:
      return 0, b

   UpperCamelCase			,  UpperCamelCase					:						Dict					=			a, b
   UpperCamelCase			,  UpperCamelCase					:						int					=			1, 0
   UpperCamelCase			,  UpperCamelCase					:						Union[str, Any]					=			0, 1

   while remainder != 0:
      UpperCamelCase					:						str					=			old_remainder // remainder
      UpperCamelCase			,  UpperCamelCase					:						Union[str, Any]					=			remainder, old_remainder - quotient * remainder
      UpperCamelCase			,  UpperCamelCase					:						List[Any]					=			coeff_a, old_coeff_a - quotient * coeff_a
      UpperCamelCase			,  UpperCamelCase					:						Optional[Any]					=			coeff_b, old_coeff_b - quotient * coeff_b

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

   return old_coeff_a, old_coeff_b
def 	UpperCamelCase			(     )			->  Tuple:
   if len(sys.argv			) < 3:
      print('2 integer arguments required'			)
      return 1
   UpperCamelCase					:						Union[str, Any]					=			int(sys.argv[1]			)
   UpperCamelCase					:						Optional[int]					=			int(sys.argv[2]			)
   print(extended_euclidean_algorithm(snake_case__ ,  snake_case__			)			)
   return 0


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



