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
  
  
  __lowerCamelCase  				=					get_tests_dir("""fixtures/test_sentencepiece.model""")
  
  
  
  @require_torch
  @require_torchaudio
  @require_sentencepiece
  class 		_snake_case      (			unittest.TestCase				):
  
  
  
  
  
  	"""simple docstring"""
  
  
  
  	def lowercase_		(						self					)	->							Optional[Any]:
  
  
  
  
  			"""simple docstring"""
  
  
  
  
  
  
  
  			_A           =    tempfile.mkdtemp()
  
  			_A           =    ['''<s>''', '''<pad>''', '''</s>''', '''<unk>''', '''▁This''', '''▁is''', '''▁a''', '''▁t''', '''est''']
  			_A           =    dict(zip(a	,    range(len(a					)					)					)					)
  			_A           =    Path(self.tmpdirname					)
  			save_json(a	,    save_dir / VOCAB_FILES_NAMES['''vocab_file''']					)
  			if not (save_dir / VOCAB_FILES_NAMES["spm_file"]).exists():
  					copyfile(a	,    save_dir / VOCAB_FILES_NAMES['''spm_file''']					)
  
  			_A           =    SpeechaTextTokenizer.from_pretrained(self.tmpdirname					)
  			tokenizer.save_pretrained(self.tmpdirname					)
  
  			_A           =    {
  			    '''feature_size''': 2_4,
  			    '''num_mel_bins''': 2_4,
  			    '''padding_value''': 0.0,
  			    '''sampling_rate''': 1_6_0_0_0,
  			    '''return_attention_mask''': False,
  			    '''do_normalize''': True,
  			}
  			save_json(a	,    save_dir / FEATURE_EXTRACTOR_NAME					)
  	def lowercase_		(						self	,    **a					)	->							Dict:
  
  
  
  
  			"""simple docstring"""
  
  
  
  
  
  
  
  			return SpeechaTextTokenizer.from_pretrained(self.tmpdirname	,    **a					)
  	def lowercase_		(						self	,    **a					)	->							List[str]:
  
  
  
  
  			"""simple docstring"""
  
  
  
  
  
  
  
  			return SpeechaTextFeatureExtractor.from_pretrained(self.tmpdirname	,    **a					)
  	def lowercase_		(						self					)	->							int:
  
  
  
  
  			"""simple docstring"""
  
  
  
  
  
  
  
  			shutil.rmtree(self.tmpdirname					)
  	def lowercase_		(						self					)	->							Optional[Any]:
  
  
  
  
  			"""simple docstring"""
  
  
  
  
  
  
  
  			_A           =    self.get_tokenizer()
  			_A           =    self.get_feature_extractor()
  
  			_A           =    SpeechaTextProcessor(tokenizer=a	,    feature_extractor=a					)
  
  			processor.save_pretrained(self.tmpdirname					)
  			_A           =    SpeechaTextProcessor.from_pretrained(self.tmpdirname					)
  
  			self.assertEqual(processor.tokenizer.get_vocab()	,    tokenizer.get_vocab()					)
  			self.assertIsInstance(processor.tokenizer	,    a					)
  
  			self.assertEqual(processor.feature_extractor.to_json_string()	,    feature_extractor.to_json_string()					)
  			self.assertIsInstance(processor.feature_extractor	,    a					)
  	def lowercase_		(						self					)	->							List[Any]:
  
  
  
  
  			"""simple docstring"""
  
  
  
  
  
  
  
  			_A           =    SpeechaTextProcessor(
  			    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=a	,    padding_value=1.0					)
  
  			_A           =    SpeechaTextProcessor.from_pretrained(
  			    self.tmpdirname	,    bos_token='''(BOS)'''	,    eos_token='''(EOS)'''	,    do_normalize=a	,    padding_value=1.0					)
  
  			self.assertEqual(processor.tokenizer.get_vocab()	,    tokenizer_add_kwargs.get_vocab()					)
  			self.assertIsInstance(processor.tokenizer	,    a					)
  
  			self.assertEqual(processor.feature_extractor.to_json_string()	,    feature_extractor_add_kwargs.to_json_string()					)
  			self.assertIsInstance(processor.feature_extractor	,    a					)
  	def lowercase_		(						self					)	->							str:
  
  
  
  
  			"""simple docstring"""
  
  
  
  
  
  
  
  			_A           =    self.get_feature_extractor()
  			_A           =    self.get_tokenizer()
  
  			_A           =    SpeechaTextProcessor(tokenizer=a	,    feature_extractor=a					)
  
  			_A           =    floats_list((3, 1_0_0_0)					)
  
  			_A           =    feature_extractor(a	,    return_tensors='''np'''					)
  			_A           =    processor(a	,    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					)	->							List[Any]:
  
  
  
  
  			"""simple docstring"""
  
  
  
  
  
  
  
  			_A           =    self.get_feature_extractor()
  			_A           =    self.get_tokenizer()
  
  			_A           =    SpeechaTextProcessor(tokenizer=a	,    feature_extractor=a					)
  
  			_A           =    '''This is a test string'''
  
  			_A           =    processor(text=a					)
  
  			_A           =    tokenizer(a					)
  
  			for key in encoded_tok.keys():
  					self.assertListEqual(encoded_tok[key]	,    encoded_processor[key]					)
  	def lowercase_		(						self					)	->							Union[str, Any]:
  
  
  
  
  			"""simple docstring"""
  
  
  
  
  
  
  
  			_A           =    self.get_feature_extractor()
  			_A           =    self.get_tokenizer()
  
  			_A           =    SpeechaTextProcessor(tokenizer=a	,    feature_extractor=a					)
  
  			_A           =    [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]
  
  			_A           =    processor.batch_decode(a					)
  			_A           =    tokenizer.batch_decode(a					)
  
  			self.assertListEqual(a	,    a					)
  
  
  
  	def lowercase_		(						self					)	->							Union[str, Any]:
  
  
  
  
  			"""simple docstring"""
  
  
  
  
  
  
  
  			_A           =    self.get_feature_extractor()
  			_A           =    self.get_tokenizer()
  
  			_A           =    SpeechaTextProcessor(tokenizer=a	,    feature_extractor=a					)
  
  			self.assertListEqual(
  			    processor.model_input_names	,    feature_extractor.model_input_names	,    msg='''`processor` and `feature_extractor` model input names do not match'''	,    )
style_context: 
  
  
  
  import copy
  
  from ...configuration_utils import PretrainedConfig
  from ...utils import logging
  
  
  __lowerCamelCase  				=					logging.get_logger(__name__)
  
  __lowerCamelCase  				=					{}
  
  
  
  class 		_snake_case      (			lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			'''fsmt_decoder'''
   def __init__(						self	,    a=0	,    a=0					)	->							str:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     super().__init__()
     _A           =    vocab_size
     _A           =    bos_token_id
  
  
  
  
  
  
  
  class 		_snake_case      (			lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			'''fsmt'''
   lowerCamelCase_          =			{'''num_attention_heads''': '''encoder_attention_heads''', '''hidden_size''': '''d_model'''}
   def __init__(						self	,    a=["en", "de"]	,    a=4_2_0_2_4	,    a=4_2_0_2_4	,    a="relu"	,    a=1_0_2_4	,    a=2_0_0	,    a=1_0_2_4	,    a=4_0_9_6	,    a=1_2	,    a=1_6	,    a=0.0	,    a=4_0_9_6	,    a=1_2	,    a=1_6	,    a=0.0	,    a=0.0	,    a=0.1	,    a=0.0	,    a=0.02	,    a=2	,    a=True	,    a=True	,    a=False	,    a=5	,    a=1.0	,    a=False	,    a=True	,    a=1	,    a=0	,    a=2	,    a=2	,    **a	,    )	->							Union[str, Any]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     _A           =    langs
     _A           =    src_vocab_size
     _A           =    tgt_vocab_size
     _A           =    d_model  # encoder_embed_dim and decoder_embed_dim
  
     _A           =    encoder_ffn_dim
     _A           =    _A           =    encoder_layers
     _A           =    encoder_attention_heads
     _A           =    encoder_layerdrop
     _A           =    decoder_layerdrop
     _A           =    decoder_ffn_dim
     _A           =    decoder_layers
     _A           =    decoder_attention_heads
     _A           =    max_position_embeddings
     _A           =    init_std  # Normal(0, this parameter)
     _A           =    activation_function
  
     _A           =    DecoderConfig(vocab_size=a	,    bos_token_id=a					)
     if "decoder" in common_kwargs:
       del common_kwargs["decoder"]
  
     _A           =    scale_embedding  # scale factor will be sqrt(d_model) if True
  
     # 3 Types of Dropout
     _A           =    attention_dropout
     _A           =    activation_dropout
     _A           =    dropout
  
     _A           =    use_cache
     super().__init__(
         pad_token_id=a	,    bos_token_id=a	,    eos_token_id=a	,    decoder_start_token_id=a	,    is_encoder_decoder=a	,    tie_word_embeddings=a	,    forced_eos_token_id=a	,    max_length=a	,    num_beams=a	,    length_penalty=a	,    early_stopping=a	,    **a	,    )
  
  
  
   def lowercase_		(						self					)	->							Any:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     _A           =    copy.deepcopy(self.__dict__					)
     _A           =    self.decoder.to_dict()
     _A           =    self.__class__.model_type
     return output