



"""simple docstring"""
import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
   import torch

if is_vision_available():
   from PIL import Image

   from transformers import MobileNetVaImageProcessor
class    a		(					unittest.TestCase    ):



  def __init__(  self	:   List[Any]    ,						lowerCAmelCase	:   Union[str, Any]    ,						lowerCAmelCase	:   List[Any]=7    ,						lowerCAmelCase	:   Optional[int]=3    ,						lowerCAmelCase	:   Dict=18    ,						lowerCAmelCase	:   int=30    ,						lowerCAmelCase	:   List[str]=400    ,						lowerCAmelCase	:   Optional[int]=True    ,						lowerCAmelCase	:   int=None    ,						lowerCAmelCase	:   Any=True    ,						lowerCAmelCase	:   Optional[Any]=None    ,						)       ->   Tuple:


     '''simple docstring'''




     SCREAMING_SNAKE_CASE_:	Any            =size if size is not None else {"""shortest_edge""": 20}
     SCREAMING_SNAKE_CASE_:	Union[str, Any]            =crop_size if crop_size is not None else {"""height""": 18, """width""": 18}
     SCREAMING_SNAKE_CASE_:	Any            =parent
     SCREAMING_SNAKE_CASE_:	Optional[Any]            =batch_size
     SCREAMING_SNAKE_CASE_:	Union[str, Any]            =num_channels
     SCREAMING_SNAKE_CASE_:	int            =image_size
     SCREAMING_SNAKE_CASE_:	Optional[int]            =min_resolution
     SCREAMING_SNAKE_CASE_:	Dict            =max_resolution
     SCREAMING_SNAKE_CASE_:	int            =do_resize
     SCREAMING_SNAKE_CASE_:	List[Any]            =size
     SCREAMING_SNAKE_CASE_:	Optional[int]            =do_center_crop
     SCREAMING_SNAKE_CASE_:	str            =crop_size





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


     '''simple docstring'''




     return {
         "do_resize": self.do_resize,
         "size": self.size,
         "do_center_crop": self.do_center_crop,
         "crop_size": self.crop_size,
     }







@require_torch
@require_vision
class    a		(					UpperCAmelCase__		, unittest.TestCase    ):
  UpperCamelCase		:			Tuple         =   MobileNetVaImageProcessor if is_vision_available() else None



  def 		lowerCamelCase__    (  self	:   Any						)       ->   List[str]:


     '''simple docstring'''




     SCREAMING_SNAKE_CASE_:	Optional[Any]            =MobileNetVaImageProcessingTester(self						)



  @property
  def 		lowerCamelCase__    (  self	:   List[Any]						)       ->   List[str]:


     '''simple docstring'''




     return self.image_processor_tester.prepare_image_processor_dict()



  def 		lowerCamelCase__    (  self	:   Tuple						)       ->   str:


     '''simple docstring'''




     SCREAMING_SNAKE_CASE_:	List[Any]            =self.image_processing_class(**self.image_processor_dict						)
     self.assertTrue(hasattr(lowerCAmelCase    ,						"""do_resize"""						)						)
     self.assertTrue(hasattr(lowerCAmelCase    ,						"""size"""						)						)
     self.assertTrue(hasattr(lowerCAmelCase    ,						"""do_center_crop"""						)						)
     self.assertTrue(hasattr(lowerCAmelCase    ,						"""center_crop"""						)						)



  def 		lowerCamelCase__    (  self	:   Optional[Any]						)       ->   str:


     '''simple docstring'''




     SCREAMING_SNAKE_CASE_:	Optional[Any]            =self.image_processing_class.from_dict(self.image_processor_dict						)
     self.assertEqual(image_processor.size    ,						{"""shortest_edge""": 20}						)
     self.assertEqual(image_processor.crop_size    ,						{"""height""": 18, """width""": 18}						)

     SCREAMING_SNAKE_CASE_:	Optional[Any]            =self.image_processing_class.from_dict(self.image_processor_dict    ,						size=42    ,						crop_size=84						)
     self.assertEqual(image_processor.size    ,						{"""shortest_edge""": 42}						)
     self.assertEqual(image_processor.crop_size    ,						{"""height""": 84, """width""": 84}						)



  def 		lowerCamelCase__    (  self	:   Optional[Any]						)       ->   Optional[int]:


     '''simple docstring'''




     pass



  def 		lowerCamelCase__    (  self	:   int						)       ->   Any:


     '''simple docstring'''




     SCREAMING_SNAKE_CASE_:	Tuple            =self.image_processing_class(**self.image_processor_dict						)
     # create random PIL images
     SCREAMING_SNAKE_CASE_:	List[Any]            =prepare_image_inputs(self.image_processor_tester    ,						equal_resolution=lowerCAmelCase						)
     for image in image_inputs:
        self.assertIsInstance(lowerCAmelCase    ,						Image.Image						)

     # Test not batched input
     SCREAMING_SNAKE_CASE_:	Tuple            =image_processing(image_inputs[0]    ,						return_tensors="""pt"""						).pixel_values
     self.assertEqual(
         encoded_images.shape    ,						(
             1,
             self.image_processor_tester.num_channels,
             self.image_processor_tester.crop_size["""height"""],
             self.image_processor_tester.crop_size["""width"""],
         )    ,						)

     # Test batched
     SCREAMING_SNAKE_CASE_:	Union[str, Any]            =image_processing(lowerCAmelCase    ,						return_tensors="""pt"""						).pixel_values
     self.assertEqual(
         encoded_images.shape    ,						(
             self.image_processor_tester.batch_size,
             self.image_processor_tester.num_channels,
             self.image_processor_tester.crop_size["""height"""],
             self.image_processor_tester.crop_size["""width"""],
         )    ,						)



  def 		lowerCamelCase__    (  self	:   Dict						)       ->   List[Any]:


     '''simple docstring'''




     SCREAMING_SNAKE_CASE_:	Any            =self.image_processing_class(**self.image_processor_dict						)
     # create random numpy tensors
     SCREAMING_SNAKE_CASE_:	Optional[int]            =prepare_image_inputs(self.image_processor_tester    ,						equal_resolution=lowerCAmelCase    ,						numpify=lowerCAmelCase						)
     for image in image_inputs:
        self.assertIsInstance(lowerCAmelCase    ,						np.ndarray						)

     # Test not batched input
     SCREAMING_SNAKE_CASE_:	List[str]            =image_processing(image_inputs[0]    ,						return_tensors="""pt"""						).pixel_values
     self.assertEqual(
         encoded_images.shape    ,						(
             1,
             self.image_processor_tester.num_channels,
             self.image_processor_tester.crop_size["""height"""],
             self.image_processor_tester.crop_size["""width"""],
         )    ,						)

     # Test batched
     SCREAMING_SNAKE_CASE_:	Tuple            =image_processing(lowerCAmelCase    ,						return_tensors="""pt"""						).pixel_values
     self.assertEqual(
         encoded_images.shape    ,						(
             self.image_processor_tester.batch_size,
             self.image_processor_tester.num_channels,
             self.image_processor_tester.crop_size["""height"""],
             self.image_processor_tester.crop_size["""width"""],
         )    ,						)





  def 		lowerCamelCase__    (  self	:   List[str]						)       ->   Dict:


     '''simple docstring'''




     SCREAMING_SNAKE_CASE_:	Any            =self.image_processing_class(**self.image_processor_dict						)
     # create random PyTorch tensors
     SCREAMING_SNAKE_CASE_:	Any            =prepare_image_inputs(self.image_processor_tester    ,						equal_resolution=lowerCAmelCase    ,						torchify=lowerCAmelCase						)
     for image in image_inputs:
        self.assertIsInstance(lowerCAmelCase    ,						torch.Tensor						)

     # Test not batched input
     SCREAMING_SNAKE_CASE_:	Optional[int]            =image_processing(image_inputs[0]    ,						return_tensors="""pt"""						).pixel_values
     self.assertEqual(
         encoded_images.shape    ,						(
             1,
             self.image_processor_tester.num_channels,
             self.image_processor_tester.crop_size["""height"""],
             self.image_processor_tester.crop_size["""width"""],
         )    ,						)

     # Test batched
     SCREAMING_SNAKE_CASE_:	str            =image_processing(lowerCAmelCase    ,						return_tensors="""pt"""						).pixel_values
     self.assertEqual(
         encoded_images.shape    ,						(
             self.image_processor_tester.batch_size,
             self.image_processor_tester.num_channels,
             self.image_processor_tester.crop_size["""height"""],
             self.image_processor_tester.crop_size["""width"""],
         )    ,						)








"""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       =     5_0_3_5_8
_UpperCAmelCase       =     5_0_3_6_2
@require_torch
@require_torchaudio
@require_sentencepiece
class    a		(					unittest.TestCase    ):



  def 		lowerCamelCase__    (  self	:   Dict						)       ->   Tuple:


     '''simple docstring'''




     SCREAMING_SNAKE_CASE_:	List[Any]            ="""openai/whisper-small.en"""
     SCREAMING_SNAKE_CASE_:	Union[str, Any]            =tempfile.mkdtemp()



  def 		lowerCamelCase__    (  self	:   Any    ,						**lowerCAmelCase	:   str						)       ->   str:


     '''simple docstring'''




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



  def 		lowerCamelCase__    (  self	:   str    ,						**lowerCAmelCase	:   Optional[Any]						)       ->   Optional[Any]:


     '''simple docstring'''




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



  def 		lowerCamelCase__    (  self	:   Tuple						)       ->   Optional[Any]:


     '''simple docstring'''




     shutil.rmtree(self.tmpdirname						)



  def 		lowerCamelCase__    (  self	:   int						)       ->   str:


     '''simple docstring'''




     SCREAMING_SNAKE_CASE_:	Optional[int]            =self.get_tokenizer()
     SCREAMING_SNAKE_CASE_:	Optional[int]            =self.get_feature_extractor()

     SCREAMING_SNAKE_CASE_:	Optional[Any]            =WhisperProcessor(tokenizer=lowerCAmelCase    ,						feature_extractor=lowerCAmelCase						)

     processor.save_pretrained(self.tmpdirname						)
     SCREAMING_SNAKE_CASE_:	Dict            =WhisperProcessor.from_pretrained(self.tmpdirname						)

     self.assertEqual(processor.tokenizer.get_vocab()    ,						tokenizer.get_vocab()						)
     self.assertIsInstance(processor.tokenizer    ,						lowerCAmelCase						)

     self.assertEqual(processor.feature_extractor.to_json_string()    ,						feature_extractor.to_json_string()						)
     self.assertIsInstance(processor.feature_extractor    ,						lowerCAmelCase						)



  def 		lowerCamelCase__    (  self	:   str						)       ->   Optional[Any]:


     '''simple docstring'''




     SCREAMING_SNAKE_CASE_:	Union[str, Any]            =WhisperProcessor(tokenizer=self.get_tokenizer()    ,						feature_extractor=self.get_feature_extractor()						)
     processor.save_pretrained(self.tmpdirname						)

     SCREAMING_SNAKE_CASE_:	int            =self.get_tokenizer(bos_token="""(BOS)"""    ,						eos_token="""(EOS)"""						)
     SCREAMING_SNAKE_CASE_:	Dict            =self.get_feature_extractor(do_normalize=lowerCAmelCase    ,						padding_value=1.0						)

     SCREAMING_SNAKE_CASE_:	Optional[int]            =WhisperProcessor.from_pretrained(
         self.tmpdirname    ,						bos_token="""(BOS)"""    ,						eos_token="""(EOS)"""    ,						do_normalize=lowerCAmelCase    ,						padding_value=1.0						)

     self.assertEqual(processor.tokenizer.get_vocab()    ,						tokenizer_add_kwargs.get_vocab()						)
     self.assertIsInstance(processor.tokenizer    ,						lowerCAmelCase						)

     self.assertEqual(processor.feature_extractor.to_json_string()    ,						feature_extractor_add_kwargs.to_json_string()						)
     self.assertIsInstance(processor.feature_extractor    ,						lowerCAmelCase						)



  def 		lowerCamelCase__    (  self	:   Tuple						)       ->   Optional[int]:


     '''simple docstring'''




     SCREAMING_SNAKE_CASE_:	Tuple            =self.get_feature_extractor()
     SCREAMING_SNAKE_CASE_:	Union[str, Any]            =self.get_tokenizer()

     SCREAMING_SNAKE_CASE_:	Dict            =WhisperProcessor(tokenizer=lowerCAmelCase    ,						feature_extractor=lowerCAmelCase						)

     SCREAMING_SNAKE_CASE_:	Dict            =floats_list((3, 1000)						)

     SCREAMING_SNAKE_CASE_:	Optional[Any]            =feature_extractor(lowerCAmelCase    ,						return_tensors="""np"""						)
     SCREAMING_SNAKE_CASE_:	str            =processor(lowerCAmelCase    ,						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						)       ->   Any:


     '''simple docstring'''




     SCREAMING_SNAKE_CASE_:	List[str]            =self.get_feature_extractor()
     SCREAMING_SNAKE_CASE_:	str            =self.get_tokenizer()

     SCREAMING_SNAKE_CASE_:	List[Any]            =WhisperProcessor(tokenizer=lowerCAmelCase    ,						feature_extractor=lowerCAmelCase						)

     SCREAMING_SNAKE_CASE_:	List[str]            ="""This is a test string"""

     SCREAMING_SNAKE_CASE_:	Tuple            =processor(text=lowerCAmelCase						)

     SCREAMING_SNAKE_CASE_:	List[Any]            =tokenizer(lowerCAmelCase						)

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



  def 		lowerCamelCase__    (  self	:   Optional[Any]						)       ->   Any:


     '''simple docstring'''




     SCREAMING_SNAKE_CASE_:	Optional[int]            =self.get_feature_extractor()
     SCREAMING_SNAKE_CASE_:	str            =self.get_tokenizer()

     SCREAMING_SNAKE_CASE_:	Union[str, Any]            =WhisperProcessor(tokenizer=lowerCAmelCase    ,						feature_extractor=lowerCAmelCase						)

     SCREAMING_SNAKE_CASE_:	List[str]            =[[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

     SCREAMING_SNAKE_CASE_:	Optional[int]            =processor.batch_decode(lowerCAmelCase						)
     SCREAMING_SNAKE_CASE_:	Dict            =tokenizer.batch_decode(lowerCAmelCase						)

     self.assertListEqual(lowerCAmelCase    ,						lowerCAmelCase						)



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


     '''simple docstring'''




     SCREAMING_SNAKE_CASE_:	str            =self.get_feature_extractor()
     SCREAMING_SNAKE_CASE_:	List[Any]            =self.get_tokenizer()

     SCREAMING_SNAKE_CASE_:	Optional[Any]            =WhisperProcessor(tokenizer=lowerCAmelCase    ,						feature_extractor=lowerCAmelCase						)

     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	:   Optional[int]						)       ->   Union[str, Any]:


     '''simple docstring'''




     SCREAMING_SNAKE_CASE_:	Optional[Any]            =self.get_feature_extractor()
     SCREAMING_SNAKE_CASE_:	Any            =self.get_tokenizer()

     SCREAMING_SNAKE_CASE_:	List[Any]            =WhisperProcessor(tokenizer=lowerCAmelCase    ,						feature_extractor=lowerCAmelCase						)
     SCREAMING_SNAKE_CASE_:	Any            =processor.get_decoder_prompt_ids(task="""transcribe"""    ,						no_timestamps=lowerCAmelCase						)

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

     SCREAMING_SNAKE_CASE_:	Tuple            =[TRANSCRIBE, NOTIMESTAMPS]
     self.assertListEqual([ids[-1] for ids in forced_decoder_ids]    ,						lowerCAmelCase						)



  def 		lowerCamelCase__    (  self	:   List[str]						)       ->   List[str]:


     '''simple docstring'''




     SCREAMING_SNAKE_CASE_:	Union[str, Any]            =WhisperProcessor(tokenizer=self.get_tokenizer()    ,						feature_extractor=self.get_feature_extractor()						)
     SCREAMING_SNAKE_CASE_:	Optional[int]            =processor.get_prompt_ids("""Mr. Quilter"""						)
     SCREAMING_SNAKE_CASE_:	List[str]            =processor.tokenizer.decode(lowerCAmelCase						)

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



  def 		lowerCamelCase__    (  self	:   Dict						)       ->   Tuple:


     '''simple docstring'''




     SCREAMING_SNAKE_CASE_:	Optional[Any]            =WhisperProcessor(tokenizer=self.get_tokenizer()    ,						feature_extractor=self.get_feature_extractor()						)
     SCREAMING_SNAKE_CASE_:	int            =processor.get_prompt_ids(""""""						)
     SCREAMING_SNAKE_CASE_:	Union[str, Any]            =processor.tokenizer.decode(lowerCAmelCase						)

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





  def 		lowerCamelCase__    (  self	:   Optional[int]						)       ->   Any:


     '''simple docstring'''




     SCREAMING_SNAKE_CASE_:	Dict            =WhisperProcessor(tokenizer=self.get_tokenizer()    ,						feature_extractor=self.get_feature_extractor()						)

     def _test_prompt_error_raised_helper(lowerCAmelCase	:   List[str]    ,						lowerCAmelCase	:   int						):
        with pytest.raises(lowerCAmelCase						) as excinfo:
           processor.get_prompt_ids(lowerCAmelCase						)
        SCREAMING_SNAKE_CASE_:	List[Any]            =f'''Encountered text in the prompt corresponding to disallowed special token: {special_token}.'''
        self.assertEqual(lowerCAmelCase    ,						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|>"""						)



