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    SCREAMING_SNAKE_CASE__      (unittest.TestCase  ):
  
  
  
  
  
      def    snake_case_       (   self):
           lowercase__					:     Optional[Any]   = tempfile.mkdtemp()
  
           lowercase__					:     Any   = ['<s>', '<pad>', '</s>', '<unk>', '▁This', '▁is', '▁a', '▁t', 'est']
           lowercase__					:     List[Any]   = dict(zip(a		,     range(len(a))))
           lowercase__					:     List[str]   = 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'])
  
           lowercase__					:     Dict   = SpeechaTextTokenizer.from_pretrained(self.tmpdirname)
           tokenizer.save_pretrained(self.tmpdirname)
  
           lowercase__					:     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(a		,     save_dir / FEATURE_EXTRACTOR_NAME)
  
  
  
  
  
      def    snake_case_       (   self		,     **a):
           return SpeechaTextTokenizer.from_pretrained(self.tmpdirname		,     **a)
  
  
  
  
  
      def    snake_case_       (   self		,     **a):
           return SpeechaTextFeatureExtractor.from_pretrained(self.tmpdirname		,     **a)
  
  
  
  
  
      def    snake_case_       (   self):
           shutil.rmtree(self.tmpdirname)
  
  
  
  
  
      def    snake_case_       (   self):
           lowercase__					:     Union[str, Any]   = self.get_tokenizer()
           lowercase__					:     Any   = self.get_feature_extractor()
  
           lowercase__					:     Dict   = SpeechaTextProcessor(tokenizer=a		,     feature_extractor=a)
  
           processor.save_pretrained(self.tmpdirname)
           lowercase__					:     Any   = 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):
           lowercase__					:     Tuple   = SpeechaTextProcessor(
               tokenizer=self.get_tokenizer()		,     feature_extractor=self.get_feature_extractor())
           processor.save_pretrained(self.tmpdirname)
  
           lowercase__					:     int   = self.get_tokenizer(bos_token='(BOS)'		,     eos_token='(EOS)')
           lowercase__					:     Optional[int]   = self.get_feature_extractor(do_normalize=a		,     padding_value=1.0)
  
           lowercase__					:     Any   = 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):
           lowercase__					:     Tuple   = self.get_feature_extractor()
           lowercase__					:     List[Any]   = self.get_tokenizer()
  
           lowercase__					:     Tuple   = SpeechaTextProcessor(tokenizer=a		,     feature_extractor=a)
  
           lowercase__					:     Dict   = floats_list((3, 1000))
  
           lowercase__					:     List[str]   = feature_extractor(a		,     return_tensors='np')
           lowercase__					:     Union[str, Any]   = 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):
           lowercase__					:     int   = self.get_feature_extractor()
           lowercase__					:     str   = self.get_tokenizer()
  
           lowercase__					:     int   = SpeechaTextProcessor(tokenizer=a		,     feature_extractor=a)
  
           lowercase__					:     str   = 'This is a test string'
  
           lowercase__					:     Tuple   = processor(text=a)
  
           lowercase__					:     List[str]   = tokenizer(a)
  
           for key in encoded_tok.keys():
                self.assertListEqual(encoded_tok[key]		,     encoded_processor[key])
  
  
  
  
  
      def    snake_case_       (   self):
           lowercase__					:     Tuple   = self.get_feature_extractor()
           lowercase__					:     Tuple   = self.get_tokenizer()
  
           lowercase__					:     List[str]   = SpeechaTextProcessor(tokenizer=a		,     feature_extractor=a)
  
           lowercase__					:     Any   = [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]
  
           lowercase__					:     Dict   = processor.batch_decode(a)
           lowercase__					:     int   = tokenizer.batch_decode(a)
  
           self.assertListEqual(a		,     a)
  
  
  
  
  
      def    snake_case_       (   self):
           lowercase__					:     Optional[Any]   = self.get_feature_extractor()
           lowercase__					:     Optional[Any]   = self.get_tokenizer()
  
           lowercase__					:     Union[str, Any]   = 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: 
  
  from cva import destroyAllWindows, imread, imshow, waitKey
  
  def 			snake_case__    (					SCREAMING_SNAKE_CASE_	:					int			,  SCREAMING_SNAKE_CASE_	:					int    ):
  
  
  
       '''simple docstring'''
  
  
  
  
  
       lowercase__   ,				lowercase__					:     Optional[int]   = img.shape[0], img.shape[1]
  
       def to_grayscale(SCREAMING_SNAKE_CASE_	:					Union[str, Any]			,  SCREAMING_SNAKE_CASE_	:					List[Any]			,  SCREAMING_SNAKE_CASE_	:					Union[str, Any]    ):
            return 0.2126 * red + 0.587 * green + 0.114 * blue
  
       def normalize(SCREAMING_SNAKE_CASE_	:					int    ):
            return min(SCREAMING_SNAKE_CASE_			,  255    )
  
       for i in range(SCREAMING_SNAKE_CASE_    ):
            for j in range(SCREAMING_SNAKE_CASE_    ):
                 lowercase__					:     str   = int(to_grayscale(*img[i][j]    )    )
                 lowercase__					:     Dict   = [
                     normalize(SCREAMING_SNAKE_CASE_    ),
                     normalize(greyscale + factor    ),
                     normalize(greyscale + 2 * factor    ),
                 ]
  
       return img
  
  
  if __name__ == "__main__":
         # read original image
         snake_case_    						=				{
             percentage: imread('''image_data/lena.jpg''', 1) for percentage in (10, 20, 30, 40)
         }
  
         for percentage, img in images.items():
                make_sepia(img, percentage)
  
         for percentage, img in images.items():
                imshow(F'''Original image with sepia (factor: {percentage})''', img)
  
         waitKey(0)
         destroyAllWindows()
  
  