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
  
  
  __snake_case             =	get_tests_dir('''fixtures/test_sentencepiece.model''')
  
  
  
  @require_torch
  @require_torchaudio
  @require_sentencepiece
  class   __lowerCamelCase (unittest.TestCase	):
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   List[str]				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              __UpperCamelCase   = tempfile.mkdtemp()
  
              __UpperCamelCase   = ['<s>', '<pad>', '</s>', '<unk>', '▁This', '▁is', '▁a', '▁t', 'est']
              __UpperCamelCase   = dict(zip(A_,range(len(A_				)				)				)				)
              __UpperCamelCase   = 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']				)
  
              __UpperCamelCase   = SpeechaTextTokenizer.from_pretrained(self.tmpdirname				)
              tokenizer.save_pretrained(self.tmpdirname				)
  
              __UpperCamelCase   = {
                  'feature_size': 24,
                  'num_mel_bins': 24,
                  'padding_value': 0.0,
                  'sampling_rate': 1_6000,
                  'return_attention_mask': False,
                  'do_normalize': True,
              }
              save_json(A_,save_dir / FEATURE_EXTRACTOR_NAME				)
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   Tuple,**A_:   Optional[int]				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              return SpeechaTextTokenizer.from_pretrained(self.tmpdirname,**A_				)
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   Union[str, Any],**A_:   List[Any]				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              return SpeechaTextFeatureExtractor.from_pretrained(self.tmpdirname,**A_				)
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   List[Any]				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              shutil.rmtree(self.tmpdirname				)
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   Dict				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              __UpperCamelCase   = self.get_tokenizer()
              __UpperCamelCase   = self.get_feature_extractor()
  
              __UpperCamelCase   = SpeechaTextProcessor(tokenizer=A_,feature_extractor=A_				)
  
              processor.save_pretrained(self.tmpdirname				)
              __UpperCamelCase   = 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 		snake_case_  ( self:   Tuple				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              __UpperCamelCase   = SpeechaTextProcessor(
                  tokenizer=self.get_tokenizer(),feature_extractor=self.get_feature_extractor()				)
              processor.save_pretrained(self.tmpdirname				)
  
              __UpperCamelCase   = self.get_tokenizer(bos_token='(BOS)',eos_token='(EOS)'				)
              __UpperCamelCase   = self.get_feature_extractor(do_normalize=A_,padding_value=1.0				)
  
              __UpperCamelCase   = 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 		snake_case_  ( self:   str				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              __UpperCamelCase   = self.get_feature_extractor()
              __UpperCamelCase   = self.get_tokenizer()
  
              __UpperCamelCase   = SpeechaTextProcessor(tokenizer=A_,feature_extractor=A_				)
  
              __UpperCamelCase   = floats_list((3, 1000)				)
  
              __UpperCamelCase   = feature_extractor(A_,return_tensors='np'				)
              __UpperCamelCase   = 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 		snake_case_  ( self:   str				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              __UpperCamelCase   = self.get_feature_extractor()
              __UpperCamelCase   = self.get_tokenizer()
  
              __UpperCamelCase   = SpeechaTextProcessor(tokenizer=A_,feature_extractor=A_				)
  
              __UpperCamelCase   = 'This is a test string'
  
              __UpperCamelCase   = processor(text=A_				)
  
              __UpperCamelCase   = tokenizer(A_				)
  
              for key in encoded_tok.keys():
                   self.assertListEqual(encoded_tok[key],encoded_processor[key]				)
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   Union[str, Any]				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              __UpperCamelCase   = self.get_feature_extractor()
              __UpperCamelCase   = self.get_tokenizer()
  
              __UpperCamelCase   = SpeechaTextProcessor(tokenizer=A_,feature_extractor=A_				)
  
              __UpperCamelCase   = [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]
  
              __UpperCamelCase   = processor.batch_decode(A_				)
              __UpperCamelCase   = tokenizer.batch_decode(A_				)
  
              self.assertListEqual(A_,A_				)
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   List[str]				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              __UpperCamelCase   = self.get_feature_extractor()
              __UpperCamelCase   = self.get_tokenizer()
  
              __UpperCamelCase   = 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: 
  
  
  def 		_A		(		_lowercase   )				->   bool:
  
  
       """simple docstring"""
  
  
       if not isinstance(_lowercase				,     _lowercase   ):
            raise ValueError('Input series is not valid, valid series - [1, 2/3, 2]'   )
       if len(_lowercase   ) == 0:
            raise ValueError('Input list must be a non empty list'   )
       if len(_lowercase   ) == 1 and series[0] != 0:
            return True
       __UpperCamelCase   = []
       __UpperCamelCase   = len(_lowercase   )
       for i in range(0				,     _lowercase   ):
            if series[i] == 0:
                 raise ValueError('Input series cannot have 0 as an element'   )
            rec_series.append(1 / series[i]   )
       __UpperCamelCase   = rec_series[1] - rec_series[0]
       for index in range(2				,     _lowercase   ):
            if rec_series[index] - rec_series[index - 1] != common_diff:
                 return False
       return True
  
  
  
  
  
  
  def 		_A		(		_lowercase   )				->   float:
  
  
       """simple docstring"""
  
  
       if not isinstance(_lowercase				,     _lowercase   ):
            raise ValueError('Input series is not valid, valid series - [2, 4, 6]'   )
       if len(_lowercase   ) == 0:
            raise ValueError('Input list must be a non empty list'   )
       __UpperCamelCase   = 0
       for val in series:
            answer += 1 / val
       return len(_lowercase   ) / answer
  
  
  if __name__ == "__main__":
      import doctest
  
      doctest.testmod()
  
  
  