




'''simple docstring'''



import shutil
import tempfile
import unittest

import pytest

from transformers import WhisperTokenizer, is_speech_available
from transformers.testing_utils import require_sentencepiece, require_torch, require_torchaudio

from .test_feature_extraction_whisper import floats_list


if is_speech_available():
     from transformers import WhisperFeatureExtractor, WhisperProcessor


UpperCAmelCase_       :  Optional[int]      =		5_0_3_5_8
UpperCAmelCase_       :  List[Any]      =		5_0_3_6_2





@require_torch
@require_torchaudio
@require_sentencepiece
class     lowerCAmelCase   ( unittest.TestCase):


       def       lowerCAmelCase      (   self  )      ->  str:



            '''simple docstring'''




            __snake_case    					=  '''openai/whisper-small.en'''
            __snake_case    					=  tempfile.mkdtemp()


       def       lowerCAmelCase      (   self    ,  **__SCREAMING_SNAKE_CASE  )      ->  Dict:



            '''simple docstring'''




            return WhisperTokenizer.from_pretrained(self.checkpoint    ,  **__SCREAMING_SNAKE_CASE  )


       def       lowerCAmelCase      (   self    ,  **__SCREAMING_SNAKE_CASE  )      ->  int:



            '''simple docstring'''




            return WhisperFeatureExtractor.from_pretrained(self.checkpoint    ,  **__SCREAMING_SNAKE_CASE  )


       def       lowerCAmelCase      (   self  )      ->  int:



            '''simple docstring'''




            shutil.rmtree(self.tmpdirname  )


       def       lowerCAmelCase      (   self  )      ->  int:



            '''simple docstring'''




            __snake_case    					=  self.get_tokenizer()
            __snake_case    					=  self.get_feature_extractor()

            __snake_case    					=  WhisperProcessor(tokenizer=__SCREAMING_SNAKE_CASE    ,  feature_extractor=__SCREAMING_SNAKE_CASE  )

            processor.save_pretrained(self.tmpdirname  )
            __snake_case    					=  WhisperProcessor.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       lowerCAmelCase      (   self  )      ->  List[str]:



            '''simple docstring'''




            __snake_case    					=  WhisperProcessor(tokenizer=self.get_tokenizer()    ,  feature_extractor=self.get_feature_extractor()  )
            processor.save_pretrained(self.tmpdirname  )

            __snake_case    					=  self.get_tokenizer(bos_token='''(BOS)'''    ,  eos_token='''(EOS)'''  )
            __snake_case    					=  self.get_feature_extractor(do_normalize=__SCREAMING_SNAKE_CASE    ,  padding_value=1.0  )

            __snake_case    					=  WhisperProcessor.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       lowerCAmelCase      (   self  )      ->  Union[str, Any]:



            '''simple docstring'''




            __snake_case    					=  self.get_feature_extractor()
            __snake_case    					=  self.get_tokenizer()

            __snake_case    					=  WhisperProcessor(tokenizer=__SCREAMING_SNAKE_CASE    ,  feature_extractor=__SCREAMING_SNAKE_CASE  )

            __snake_case    					=  floats_list((3, 1000)  )

            __snake_case    					=  feature_extractor(__SCREAMING_SNAKE_CASE    ,  return_tensors='''np'''  )
            __snake_case    					=  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       lowerCAmelCase      (   self  )      ->  Tuple:



            '''simple docstring'''




            __snake_case    					=  self.get_feature_extractor()
            __snake_case    					=  self.get_tokenizer()

            __snake_case    					=  WhisperProcessor(tokenizer=__SCREAMING_SNAKE_CASE    ,  feature_extractor=__SCREAMING_SNAKE_CASE  )

            __snake_case    					=  '''This is a test string'''

            __snake_case    					=  processor(text=__SCREAMING_SNAKE_CASE  )

            __snake_case    					=  tokenizer(__SCREAMING_SNAKE_CASE  )

            for key in encoded_tok.keys():
                 self.assertListEqual(encoded_tok[key]    ,  encoded_processor[key]  )


       def       lowerCAmelCase      (   self  )      ->  Any:



            '''simple docstring'''




            __snake_case    					=  self.get_feature_extractor()
            __snake_case    					=  self.get_tokenizer()

            __snake_case    					=  WhisperProcessor(tokenizer=__SCREAMING_SNAKE_CASE    ,  feature_extractor=__SCREAMING_SNAKE_CASE  )

            __snake_case    					=  [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

            __snake_case    					=  processor.batch_decode(__SCREAMING_SNAKE_CASE  )
            __snake_case    					=  tokenizer.batch_decode(__SCREAMING_SNAKE_CASE  )

            self.assertListEqual(__SCREAMING_SNAKE_CASE    ,  __SCREAMING_SNAKE_CASE  )


       def       lowerCAmelCase      (   self  )      ->  int:



            '''simple docstring'''




            __snake_case    					=  self.get_feature_extractor()
            __snake_case    					=  self.get_tokenizer()

            __snake_case    					=  WhisperProcessor(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'''    ,  )


       def       lowerCAmelCase      (   self  )      ->  Any:



            '''simple docstring'''




            __snake_case    					=  self.get_feature_extractor()
            __snake_case    					=  self.get_tokenizer()

            __snake_case    					=  WhisperProcessor(tokenizer=__SCREAMING_SNAKE_CASE    ,  feature_extractor=__SCREAMING_SNAKE_CASE  )
            __snake_case    					=  processor.get_decoder_prompt_ids(task='''transcribe'''    ,  no_timestamps=__SCREAMING_SNAKE_CASE  )

            self.assertIsInstance(__SCREAMING_SNAKE_CASE    ,  __SCREAMING_SNAKE_CASE  )
            for ids in forced_decoder_ids:
                 self.assertIsInstance(__SCREAMING_SNAKE_CASE    ,  (list, tuple)  )

            __snake_case    					=  [TRANSCRIBE, NOTIMESTAMPS]
            self.assertListEqual([ids[-1] for ids in forced_decoder_ids]    ,  __SCREAMING_SNAKE_CASE  )


       def       lowerCAmelCase      (   self  )      ->  Optional[int]:



            '''simple docstring'''




            __snake_case    					=  WhisperProcessor(tokenizer=self.get_tokenizer()    ,  feature_extractor=self.get_feature_extractor()  )
            __snake_case    					=  processor.get_prompt_ids('''Mr. Quilter'''  )
            __snake_case    					=  processor.tokenizer.decode(__SCREAMING_SNAKE_CASE  )

            self.assertListEqual(prompt_ids.tolist()    ,  [5_0360, 1770, 13, 2264, 346, 353]  )
            self.assertEqual(__SCREAMING_SNAKE_CASE    ,  '''<|startofprev|> Mr. Quilter'''  )


       def       lowerCAmelCase      (   self  )      ->  Union[str, Any]:



            '''simple docstring'''




            __snake_case    					=  WhisperProcessor(tokenizer=self.get_tokenizer()    ,  feature_extractor=self.get_feature_extractor()  )
            __snake_case    					=  processor.get_prompt_ids(''''''  )
            __snake_case    					=  processor.tokenizer.decode(__SCREAMING_SNAKE_CASE  )

            self.assertListEqual(prompt_ids.tolist()    ,  [5_0360, 220]  )
            self.assertEqual(__SCREAMING_SNAKE_CASE    ,  '''<|startofprev|> '''  )




       def       lowerCAmelCase      (   self  )      ->  str:



            '''simple docstring'''




            __snake_case    					=  WhisperProcessor(tokenizer=self.get_tokenizer()    ,  feature_extractor=self.get_feature_extractor()  )

            def _test_prompt_error_raised_helper(__SCREAMING_SNAKE_CASE    ,  __SCREAMING_SNAKE_CASE  ):
                 with pytest.raises(__SCREAMING_SNAKE_CASE  ) as excinfo:
                      processor.get_prompt_ids(__SCREAMING_SNAKE_CASE  )
                 __snake_case    					=  F'''Encountered text in the prompt corresponding to disallowed special token: {special_token}.'''
                 self.assertEqual(__SCREAMING_SNAKE_CASE    ,  str(excinfo.value  )  )

            _test_prompt_error_raised_helper('''<|startofprev|> test'''    ,  '''<|startofprev|>'''  )
            _test_prompt_error_raised_helper('''test <|notimestamps|>'''    ,  '''<|notimestamps|>'''  )
            _test_prompt_error_raised_helper('''test <|zh|> test <|transcribe|>'''    ,  '''<|zh|>'''  )












'''simple docstring'''



from transformers import ProcessorMixin





class     lowerCAmelCase   ( __lowerCAmelCase):
       __lowercase  :      Union[str, Any]        =			'''AutoFeatureExtractor'''
       __lowercase  :      List[Any]        =			'''AutoTokenizer'''






