

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


if is_torch_available():
      import torch

if is_vision_available():
      from PIL import Image

      from transformers import CLIPImageProcessor






class     __magic_name__     (							unittest.TestCase     ):


 def __init__(    self		:			List[Any]      ,    lowerCAmelCase__		:			List[Any]      ,    lowerCAmelCase__		:			Optional[Any]=7      ,    lowerCAmelCase__		:			Union[str, Any]=3      ,    lowerCAmelCase__		:			Any=1_8      ,    lowerCAmelCase__		:			str=3_0      ,    lowerCAmelCase__		:			Optional[int]=4_0_0      ,    lowerCAmelCase__		:			Any=True      ,    lowerCAmelCase__		:			str=None      ,    lowerCAmelCase__		:			Union[str, Any]=True      ,    lowerCAmelCase__		:			Optional[int]=None      ,    lowerCAmelCase__		:			int=True      ,    lowerCAmelCase__		:			str=[0.48_145_466, 0.4_578_275, 0.40_821_073]      ,    lowerCAmelCase__		:			Optional[Any]=[0.26_862_954, 0.26_130_258, 0.27_577_711]      ,    lowerCAmelCase__		:			Dict=True      ,    )     ->   Union[str, Any]:
   UpperCAmelCase          =	size if size is not None else {"shortest_edge": 2_0}
   UpperCAmelCase          =	crop_size if crop_size is not None else {"height": 1_8, "width": 1_8}
   UpperCAmelCase          =	parent
   UpperCAmelCase          =	batch_size
   UpperCAmelCase          =	num_channels
   UpperCAmelCase          =	image_size
   UpperCAmelCase          =	min_resolution
   UpperCAmelCase          =	max_resolution
   UpperCAmelCase          =	do_resize
   UpperCAmelCase          =	size
   UpperCAmelCase          =	do_center_crop
   UpperCAmelCase          =	crop_size
   UpperCAmelCase          =	do_normalize
   UpperCAmelCase          =	image_mean
   UpperCAmelCase          =	image_std
   UpperCAmelCase          =	do_convert_rgb


 def _UpperCamelCase						(    self		:			int     )     ->   Any:
   return {
       "do_resize": self.do_resize,
       "size": self.size,
       "do_center_crop": self.do_center_crop,
       "crop_size": self.crop_size,
       "do_normalize": self.do_normalize,
       "image_mean": self.image_mean,
       "image_std": self.image_std,
       "do_convert_rgb": self.do_convert_rgb,
   }


 def _UpperCamelCase						(    self		:			Optional[int]      ,    lowerCAmelCase__		:			List[Any]=False      ,    lowerCAmelCase__		:			Any=False      ,    lowerCAmelCase__		:			str=False     )     ->   int:
   assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"

   if equal_resolution:
     UpperCAmelCase          =	[]
     for i in range(self.batch_size     ):
       image_inputs.append(
           np.random.randint(
               2_5_5      ,    size=(self.num_channels, self.max_resolution, self.max_resolution)      ,    dtype=np.uinta     )     )
   else:
     UpperCAmelCase          =	[]
     for i in range(self.batch_size     ):
       UpperCAmelCase          =	np.random.choice(np.arange(self.min_resolution      ,    self.max_resolution     )      ,    2     )
       image_inputs.append(np.random.randint(2_5_5      ,    size=(self.num_channels, width, height)      ,    dtype=np.uinta     )     )

   if not numpify and not torchify:
     # PIL expects the channel dimension as last dimension
     UpperCAmelCase          =	[Image.fromarray(np.moveaxis(_a      ,    0      ,    -1     )     ) for x in image_inputs]

   if torchify:
     UpperCAmelCase          =	[torch.from_numpy(_a     ) for x in image_inputs]

   return image_inputs






@require_torch
@require_vision
class     __magic_name__     (							_a						,    unittest.TestCase     ):
 UpperCAmelCase				     =    CLIPImageProcessor if is_vision_available() else None


 def _UpperCamelCase						(    self		:			Any     )     ->   List[str]:
   UpperCAmelCase          =	CLIPImageProcessingTester(self     )


 @property
 def _UpperCamelCase						(    self		:			List[Any]     )     ->   Optional[Any]:
   return self.image_processor_tester.prepare_image_processor_dict()


 def _UpperCamelCase						(    self		:			int     )     ->   Dict:
   UpperCAmelCase          =	self.image_processing_class(**self.image_processor_dict     )
   self.assertTrue(hasattr(_a      ,    "do_resize"     )     )
   self.assertTrue(hasattr(_a      ,    "size"     )     )
   self.assertTrue(hasattr(_a      ,    "do_center_crop"     )     )
   self.assertTrue(hasattr(_a      ,    "center_crop"     )     )
   self.assertTrue(hasattr(_a      ,    "do_normalize"     )     )
   self.assertTrue(hasattr(_a      ,    "image_mean"     )     )
   self.assertTrue(hasattr(_a      ,    "image_std"     )     )
   self.assertTrue(hasattr(_a      ,    "do_convert_rgb"     )     )


 def _UpperCamelCase						(    self		:			List[Any]     )     ->   int:
   UpperCAmelCase          =	self.image_processing_class.from_dict(self.image_processor_dict     )
   self.assertEqual(image_processor.size      ,    {"shortest_edge": 2_0}     )
   self.assertEqual(image_processor.crop_size      ,    {"height": 1_8, "width": 1_8}     )

   UpperCAmelCase          =	self.image_processing_class.from_dict(self.image_processor_dict      ,    size=4_2      ,    crop_size=8_4     )
   self.assertEqual(image_processor.size      ,    {"shortest_edge": 4_2}     )
   self.assertEqual(image_processor.crop_size      ,    {"height": 8_4, "width": 8_4}     )


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


 def _UpperCamelCase						(    self		:			Optional[Any]     )     ->   Optional[Any]:
   # Initialize image_processing
   UpperCAmelCase          =	self.image_processing_class(**self.image_processor_dict     )
   # create random PIL images
   UpperCAmelCase          =	self.image_processor_tester.prepare_inputs(equal_resolution=_a     )
   for image in image_inputs:
     self.assertIsInstance(_a      ,    Image.Image     )

   # Test not batched input
   UpperCAmelCase          =	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
   UpperCAmelCase          =	image_processing(_a      ,    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 _UpperCamelCase						(    self		:			List[str]     )     ->   List[Any]:
   # Initialize image_processing
   UpperCAmelCase          =	self.image_processing_class(**self.image_processor_dict     )
   # create random numpy tensors
   UpperCAmelCase          =	self.image_processor_tester.prepare_inputs(equal_resolution=_a      ,    numpify=_a     )
   for image in image_inputs:
     self.assertIsInstance(_a      ,    np.ndarray     )

   # Test not batched input
   UpperCAmelCase          =	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
   UpperCAmelCase          =	image_processing(_a      ,    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 _UpperCamelCase						(    self		:			int     )     ->   Optional[int]:
   # Initialize image_processing
   UpperCAmelCase          =	self.image_processing_class(**self.image_processor_dict     )
   # create random PyTorch tensors
   UpperCAmelCase          =	self.image_processor_tester.prepare_inputs(equal_resolution=_a      ,    torchify=_a     )
   for image in image_inputs:
     self.assertIsInstance(_a      ,    torch.Tensor     )

   # Test not batched input
   UpperCAmelCase          =	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
   UpperCAmelCase          =	image_processing(_a      ,    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"],
       )      ,    )






@require_torch
@require_vision
class     __magic_name__     (							_a						,    unittest.TestCase     ):
 UpperCAmelCase				     =    CLIPImageProcessor if is_vision_available() else None


 def _UpperCamelCase						(    self		:			Tuple     )     ->   Dict:
   UpperCAmelCase          =	CLIPImageProcessingTester(self      ,    num_channels=4     )
   UpperCAmelCase          =	3


 @property
 def _UpperCamelCase						(    self		:			List[str]     )     ->   Dict:
   return self.image_processor_tester.prepare_image_processor_dict()


 def _UpperCamelCase						(    self		:			Optional[int]     )     ->   Dict:
   UpperCAmelCase          =	self.image_processing_class(**self.image_processor_dict     )
   self.assertTrue(hasattr(_a      ,    "do_resize"     )     )
   self.assertTrue(hasattr(_a      ,    "size"     )     )
   self.assertTrue(hasattr(_a      ,    "do_center_crop"     )     )
   self.assertTrue(hasattr(_a      ,    "center_crop"     )     )
   self.assertTrue(hasattr(_a      ,    "do_normalize"     )     )
   self.assertTrue(hasattr(_a      ,    "image_mean"     )     )
   self.assertTrue(hasattr(_a      ,    "image_std"     )     )
   self.assertTrue(hasattr(_a      ,    "do_convert_rgb"     )     )


 def _UpperCamelCase						(    self		:			Dict     )     ->   int:
   pass


 def _UpperCamelCase						(    self		:			int     )     ->   Optional[Any]:
   # Initialize image_processing
   UpperCAmelCase          =	self.image_processing_class(**self.image_processor_dict     )
   # create random PIL images
   UpperCAmelCase          =	self.image_processor_tester.prepare_inputs(equal_resolution=_a     )
   for image in image_inputs:
     self.assertIsInstance(_a      ,    Image.Image     )

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

   # Test batched
   UpperCAmelCase          =	image_processing(_a      ,    return_tensors="pt"     ).pixel_values
   self.assertEqual(
       encoded_images.shape      ,    (
           self.image_processor_tester.batch_size,
           self.expected_encoded_image_num_channels,
           self.image_processor_tester.crop_size["height"],
           self.image_processor_tester.crop_size["width"],
       )      ,    )








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_03_58
__UpperCAmelCase    	=  5_03_62


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


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


						def 	_lowerCamelCase      (			self    :	Optional[Any]   ,							**_a    :	Optional[int]      ):
													return WhisperTokenizer.from_pretrained(self.checkpoint   ,							**_a      )


						def 	_lowerCamelCase      (			self    :	str   ,							**_a    :	Tuple      ):
													return WhisperFeatureExtractor.from_pretrained(self.checkpoint   ,							**_a      )


						def 	_lowerCamelCase      (			self    :	Union[str, Any]      ):
													shutil.rmtree(self.tmpdirname      )


						def 	_lowerCamelCase      (			self    :	int      ):
													a__:							str									=self.get_tokenizer()
													a__:							Union[str, Any]									=self.get_feature_extractor()

													a__:							int									=WhisperProcessor(tokenizer=_a   ,							feature_extractor=_a      )

													processor.save_pretrained(self.tmpdirname      )
													a__:							List[Any]									=WhisperProcessor.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 	_lowerCamelCase      (			self    :	Dict      ):
													a__:							str									=WhisperProcessor(tokenizer=self.get_tokenizer()   ,							feature_extractor=self.get_feature_extractor()      )
													processor.save_pretrained(self.tmpdirname      )

													a__:							Tuple									=self.get_tokenizer(bos_token="(BOS)"   ,							eos_token="(EOS)"      )
													a__:							Optional[int]									=self.get_feature_extractor(do_normalize=_a   ,							padding_value=1.0      )

													a__:							Any									=WhisperProcessor.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 	_lowerCamelCase      (			self    :	Tuple      ):
													a__:							Optional[int]									=self.get_feature_extractor()
													a__:							str									=self.get_tokenizer()

													a__:							int									=WhisperProcessor(tokenizer=_a   ,							feature_extractor=_a      )

													a__:							List[str]									=floats_list((3, 1_0_0_0)      )

													a__:							Optional[int]									=feature_extractor(_a   ,							return_tensors="np"      )
													a__:							Optional[int]									=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 	_lowerCamelCase      (			self    :	Optional[Any]      ):
													a__:							Dict									=self.get_feature_extractor()
													a__:							int									=self.get_tokenizer()

													a__:							List[Any]									=WhisperProcessor(tokenizer=_a   ,							feature_extractor=_a      )

													a__:							List[Any]									="This is a test string"

													a__:							Tuple									=processor(text=_a      )

													a__:							int									=tokenizer(_a      )

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


						def 	_lowerCamelCase      (			self    :	Any      ):
													a__:							int									=self.get_feature_extractor()
													a__:							List[str]									=self.get_tokenizer()

													a__:							List[str]									=WhisperProcessor(tokenizer=_a   ,							feature_extractor=_a      )

													a__:							List[Any]									=[[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

													a__:							List[Any]									=processor.batch_decode(_a      )
													a__:							int									=tokenizer.batch_decode(_a      )

													self.assertListEqual(_a   ,							_a      )


						def 	_lowerCamelCase      (			self    :	List[str]      ):
													a__:							List[Any]									=self.get_feature_extractor()
													a__:							Any									=self.get_tokenizer()

													a__:							Optional[int]									=WhisperProcessor(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"   ,							)


						def 	_lowerCamelCase      (			self    :	List[Any]      ):
													a__:							Any									=self.get_feature_extractor()
													a__:							str									=self.get_tokenizer()

													a__:							Dict									=WhisperProcessor(tokenizer=_a   ,							feature_extractor=_a      )
													a__:							List[Any]									=processor.get_decoder_prompt_ids(task="transcribe"   ,							no_timestamps=_a      )

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

													a__:							Any									=[TRANSCRIBE, NOTIMESTAMPS]
													self.assertListEqual([ids[-1] for ids in forced_decoder_ids]   ,							_a      )


						def 	_lowerCamelCase      (			self    :	str      ):
													a__:							Tuple									=WhisperProcessor(tokenizer=self.get_tokenizer()   ,							feature_extractor=self.get_feature_extractor()      )
													a__:							List[Any]									=processor.get_prompt_ids("Mr. Quilter"      )
													a__:							Optional[Any]									=processor.tokenizer.decode(_a      )

													self.assertListEqual(prompt_ids.tolist()   ,							[5_0_3_6_0, 1_7_7_0, 1_3, 2_2_6_4, 3_4_6, 3_5_3]      )
													self.assertEqual(_a   ,							"<|startofprev|> Mr. Quilter"      )


						def 	_lowerCamelCase      (			self    :	List[str]      ):
													a__:							int									=WhisperProcessor(tokenizer=self.get_tokenizer()   ,							feature_extractor=self.get_feature_extractor()      )
													a__:							List[str]									=processor.get_prompt_ids(""      )
													a__:							Any									=processor.tokenizer.decode(_a      )

													self.assertListEqual(prompt_ids.tolist()   ,							[5_0_3_6_0, 2_2_0]      )
													self.assertEqual(_a   ,							"<|startofprev|> "      )







						def 	_lowerCamelCase      (			self    :	Any      ):
													a__:							Tuple									=WhisperProcessor(tokenizer=self.get_tokenizer()   ,							feature_extractor=self.get_feature_extractor()      )

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





