code: 
  
  
  
  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',    )
  
  
  
  
style_context: 
  
  
  
  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())
  
  
  
  