
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


__lowerCamelCase								=					5_0_3_5_8
__lowerCamelCase								=					5_0_3_6_2
@require_torch
@require_torchaudio
@require_sentencepiece
class    _UpperCamelCase(   unittest.TestCase				):

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

						def 						a__ (					self		:			Tuple	,						**_lowerCamelCase		:			List[str]			):
													return WhisperTokenizer.from_pretrained(self.checkpoint	,						**_lowerCamelCase			)

						def 						a__ (					self		:			List[str]	,						**_lowerCamelCase		:			Union[str, Any]			):
													return WhisperFeatureExtractor.from_pretrained(self.checkpoint	,						**_lowerCamelCase			)

						def 						a__ (					self		:			int			):
													shutil.rmtree(self.tmpdirname			)

						def 						a__ (					self		:			int			):
													_UpperCAmelCase  :			Dict	       =		self.get_tokenizer()
													_UpperCAmelCase  :			Any	       =		self.get_feature_extractor()

													_UpperCAmelCase  :			Tuple	       =		WhisperProcessor(tokenizer=_lowerCamelCase	,						feature_extractor=_lowerCamelCase			)

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

													_UpperCAmelCase  :			Dict	       =		self.get_tokenizer(bos_token="(BOS)"	,						eos_token="(EOS)"			)
													_UpperCAmelCase  :			Dict	       =		self.get_feature_extractor(do_normalize=_lowerCamelCase	,						padding_value=1.0			)

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

													_UpperCAmelCase  :			Optional[Any]	       =		WhisperProcessor(tokenizer=_lowerCamelCase	,						feature_extractor=_lowerCamelCase			)

													_UpperCAmelCase  :			List[Any]	       =		floats_list((3, 10_00)			)

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

													_UpperCAmelCase  :			Optional[Any]	       =		WhisperProcessor(tokenizer=_lowerCamelCase	,						feature_extractor=_lowerCamelCase			)

													_UpperCAmelCase  :			Optional[int]	       =		"This is a test string"

													_UpperCAmelCase  :			List[Any]	       =		processor(text=_lowerCamelCase			)

													_UpperCAmelCase  :			Dict	       =		tokenizer(_lowerCamelCase			)

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

						def 						a__ (					self		:			str			):
													_UpperCAmelCase  :			Optional[Any]	       =		self.get_feature_extractor()
													_UpperCAmelCase  :			Dict	       =		self.get_tokenizer()

													_UpperCAmelCase  :			Optional[Any]	       =		WhisperProcessor(tokenizer=_lowerCamelCase	,						feature_extractor=_lowerCamelCase			)

													_UpperCAmelCase  :			Tuple	       =		[[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

													_UpperCAmelCase  :			Optional[int]	       =		processor.batch_decode(_lowerCamelCase			)
													_UpperCAmelCase  :			Union[str, Any]	       =		tokenizer.batch_decode(_lowerCamelCase			)

													self.assertListEqual(_lowerCamelCase	,						_lowerCamelCase			)

						def 						a__ (					self		:			Optional[int]			):
													_UpperCAmelCase  :			Tuple	       =		self.get_feature_extractor()
													_UpperCAmelCase  :			str	       =		self.get_tokenizer()

													_UpperCAmelCase  :			Dict	       =		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 						a__ (					self		:			List[str]			):
													_UpperCAmelCase  :			Optional[Any]	       =		self.get_feature_extractor()
													_UpperCAmelCase  :			Union[str, Any]	       =		self.get_tokenizer()

													_UpperCAmelCase  :			Tuple	       =		WhisperProcessor(tokenizer=_lowerCamelCase	,						feature_extractor=_lowerCamelCase			)
													_UpperCAmelCase  :			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)			)

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

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

													self.assertListEqual(prompt_ids.tolist()	,						[5_03_60, 17_70, 13, 22_64, 3_46, 3_53]			)
													self.assertEqual(_lowerCamelCase	,						"<|startofprev|> Mr. Quilter"			)

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

													self.assertListEqual(prompt_ids.tolist()	,						[5_03_60, 2_20]			)
													self.assertEqual(_lowerCamelCase	,						"<|startofprev|> "			)






						def 						a__ (					self		:			Dict			):
													_UpperCAmelCase  :			Any	       =		WhisperProcessor(tokenizer=self.get_tokenizer()	,						feature_extractor=self.get_feature_extractor()			)

													def _test_prompt_error_raised_helper(_lowerCamelCase		:			List[Any]	,						_lowerCamelCase		:			int			):
																				with pytest.raises(_lowerCamelCase			) as excinfo:
																											processor.get_prompt_ids(_lowerCamelCase			)
																				_UpperCAmelCase  :			Optional[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|>"			)






from typing import Dict, List, Optional, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import center_crop, normalize, rescale, resize, to_channel_dimension_format
from ...image_utils import (
    IMAGENET_STANDARD_MEAN,
    IMAGENET_STANDARD_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_vision_available, logging


if is_vision_available():
				import PIL


__lowerCamelCase								=					logging.get_logger(__name__)
class    _UpperCamelCase(   SCREAMING_SNAKE_CASE				):
						__A:						Union[str, Any]				   =      ["""pixel_values"""]

						def __init__(					self		:			str	,						_lowerCamelCase		:			bool = True	,						_lowerCamelCase		:			Dict[str, int] = None	,						_lowerCamelCase		:			PILImageResampling = PIL.Image.NEAREST	,						_lowerCamelCase		:			bool = False	,						_lowerCamelCase		:			Dict[str, int] = None	,						_lowerCamelCase		:			Union[int, float] = 1 / 2_55	,						_lowerCamelCase		:			bool = False	,						_lowerCamelCase		:			bool = True	,						_lowerCamelCase		:			bool = True	,						_lowerCamelCase		:			Optional[Union[float, List[float]]] = None	,						_lowerCamelCase		:			Optional[Union[float, List[float]]] = None	,						_lowerCamelCase		:			bool = True	,						**_lowerCamelCase		:			Tuple	,						):
													super().__init__(**_lowerCamelCase			)
													_UpperCAmelCase  :			int	       =		size if size is not None else {"height": 3_46, "width": 3_46}
													_UpperCAmelCase  :			Dict	       =		get_size_dict(_lowerCamelCase			)
													_UpperCAmelCase  :			List[str]	       =		crop_size if crop_size is not None else {"height": 2_89, "width": 2_89}
													_UpperCAmelCase  :			int	       =		get_size_dict(_lowerCamelCase	,						param_name="crop_size"			)

													_UpperCAmelCase  :			Dict	       =		do_resize
													_UpperCAmelCase  :			Tuple	       =		size
													_UpperCAmelCase  :			Union[str, Any]	       =		resample
													_UpperCAmelCase  :			List[Any]	       =		do_center_crop
													_UpperCAmelCase  :			List[str]	       =		crop_size
													_UpperCAmelCase  :			int	       =		do_rescale
													_UpperCAmelCase  :			str	       =		rescale_factor
													_UpperCAmelCase  :			int	       =		rescale_offset
													_UpperCAmelCase  :			Any	       =		do_normalize
													_UpperCAmelCase  :			Optional[int]	       =		image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
													_UpperCAmelCase  :			List[str]	       =		image_std if image_std is not None else IMAGENET_STANDARD_STD
													_UpperCAmelCase  :			Dict	       =		include_top

						def 						a__ (					self		:			Optional[Any]	,						_lowerCamelCase		:			np.ndarray	,						_lowerCamelCase		:			Dict[str, int]	,						_lowerCamelCase		:			PILImageResampling = PIL.Image.NEAREST	,						_lowerCamelCase		:			Optional[Union[str, ChannelDimension]] = None	,						**_lowerCamelCase		:			Tuple	,						):
													_UpperCAmelCase  :			Optional[int]	       =		get_size_dict(_lowerCamelCase			)
													if "height" not in size or "width" not in size:
																				raise ValueError(f"""The size dictionary must have keys 'height' and 'width'. Got {size.keys()}"""			)
													return resize(
													    _lowerCamelCase	,						size=(size["height"], size["width"])	,						resample=_lowerCamelCase	,						data_format=_lowerCamelCase	,						**_lowerCamelCase			)

						def 						a__ (					self		:			Optional[Any]	,						_lowerCamelCase		:			np.ndarray	,						_lowerCamelCase		:			Dict[str, int]	,						_lowerCamelCase		:			Optional[Union[str, ChannelDimension]] = None	,						**_lowerCamelCase		:			List[str]	,						):
													_UpperCAmelCase  :			Optional[Any]	       =		get_size_dict(_lowerCamelCase			)
													if "height" not in size or "width" not in size:
																				raise ValueError(f"""The size dictionary must have keys 'height' and 'width'. Got {size.keys()}"""			)
													return center_crop(_lowerCamelCase	,						size=(size["height"], size["width"])	,						data_format=_lowerCamelCase	,						**_lowerCamelCase			)

						def 						a__ (					self		:			Optional[Any]	,						_lowerCamelCase		:			np.ndarray	,						_lowerCamelCase		:			Union[int, float]	,						_lowerCamelCase		:			bool = True	,						_lowerCamelCase		:			Optional[Union[str, ChannelDimension]] = None	,						**_lowerCamelCase		:			Tuple	,						):
													if offset:
																				_UpperCAmelCase  :			Any	       =		(image - 1_27.5) * scale
																				if data_format is not None:
																											_UpperCAmelCase  :			Union[str, Any]	       =		to_channel_dimension_format(_lowerCamelCase	,						_lowerCamelCase			)
																				_UpperCAmelCase  :			Optional[Any]	       =		rescaled_image.astype(np.floataa			)
													else:
																				_UpperCAmelCase  :			List[Any]	       =		rescale(_lowerCamelCase	,						scale=_lowerCamelCase	,						data_format=_lowerCamelCase	,						**_lowerCamelCase			)
													return rescaled_image

						def 						a__ (					self		:			Union[str, Any]	,						_lowerCamelCase		:			np.ndarray	,						_lowerCamelCase		:			Union[float, List[float]]	,						_lowerCamelCase		:			Union[float, List[float]]	,						_lowerCamelCase		:			Optional[Union[str, ChannelDimension]] = None	,						**_lowerCamelCase		:			Union[str, Any]	,						):
													return normalize(_lowerCamelCase	,						mean=_lowerCamelCase	,						std=_lowerCamelCase	,						data_format=_lowerCamelCase	,						**_lowerCamelCase			)






						def 						a__ (					self		:			str	,						_lowerCamelCase		:			ImageInput	,						_lowerCamelCase		:			bool = None	,						_lowerCamelCase		:			Dict[str, int] = None	,						_lowerCamelCase		:			List[Any]=None	,						_lowerCamelCase		:			bool = None	,						_lowerCamelCase		:			Dict[str, int] = None	,						_lowerCamelCase		:			bool = None	,						_lowerCamelCase		:			float = None	,						_lowerCamelCase		:			bool = None	,						_lowerCamelCase		:			bool = None	,						_lowerCamelCase		:			Optional[Union[float, List[float]]] = None	,						_lowerCamelCase		:			Optional[Union[float, List[float]]] = None	,						_lowerCamelCase		:			bool = None	,						_lowerCamelCase		:			Optional[Union[str, TensorType]] = None	,						_lowerCamelCase		:			ChannelDimension = ChannelDimension.FIRST	,						**_lowerCamelCase		:			str	,						):
													_UpperCAmelCase  :			Optional[Any]	       =		do_resize if do_resize is not None else self.do_resize
													_UpperCAmelCase  :			Optional[int]	       =		resample if resample is not None else self.resample
													_UpperCAmelCase  :			Tuple	       =		do_center_crop if do_center_crop is not None else self.do_center_crop
													_UpperCAmelCase  :			str	       =		do_rescale if do_rescale is not None else self.do_rescale
													_UpperCAmelCase  :			str	       =		rescale_factor if rescale_factor is not None else self.rescale_factor
													_UpperCAmelCase  :			Tuple	       =		rescale_offset if rescale_offset is not None else self.rescale_offset
													_UpperCAmelCase  :			str	       =		do_normalize if do_normalize is not None else self.do_normalize
													_UpperCAmelCase  :			Dict	       =		image_mean if image_mean is not None else self.image_mean
													_UpperCAmelCase  :			Tuple	       =		image_std if image_std is not None else self.image_std
													_UpperCAmelCase  :			Tuple	       =		include_top if include_top is not None else self.include_top

													_UpperCAmelCase  :			Optional[int]	       =		size if size is not None else self.size
													_UpperCAmelCase  :			Union[str, Any]	       =		get_size_dict(_lowerCamelCase			)
													_UpperCAmelCase  :			int	       =		crop_size if crop_size is not None else self.crop_size
													_UpperCAmelCase  :			int	       =		get_size_dict(_lowerCamelCase	,						param_name="crop_size"			)

													_UpperCAmelCase  :			Union[str, Any]	       =		make_list_of_images(_lowerCamelCase			)

													if not valid_images(_lowerCamelCase			):
																				raise ValueError(
																				    "Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, "
																				    "torch.Tensor, tf.Tensor or jax.ndarray."			)

													if do_resize and size is None or resample is None:
																				raise ValueError("Size and resample must be specified if do_resize is True."			)

													if do_center_crop and crop_size is None:
																				raise ValueError("Crop size must be specified if do_center_crop is True."			)

													if do_rescale and rescale_factor is None:
																				raise ValueError("Rescale factor must be specified if do_rescale is True."			)

													if do_normalize and (image_mean is None or image_std is None):
																				raise ValueError("Image mean and std must be specified if do_normalize is True."			)

													# All transformations expect numpy arrays.
													_UpperCAmelCase  :			Dict	       =		[to_numpy_array(_lowerCamelCase			) for image in images]

													if do_resize:
																				_UpperCAmelCase  :			Any	       =		[self.resize(image=_lowerCamelCase	,						size=_lowerCamelCase	,						resample=_lowerCamelCase			) for image in images]

													if do_center_crop:
																				_UpperCAmelCase  :			int	       =		[self.center_crop(image=_lowerCamelCase	,						size=_lowerCamelCase			) for image in images]

													if do_rescale:
																				_UpperCAmelCase  :			int	       =		[self.rescale(image=_lowerCamelCase	,						scale=_lowerCamelCase	,						offset=_lowerCamelCase			) for image in images]

													if do_normalize:
																				_UpperCAmelCase  :			str	       =		[self.normalize(image=_lowerCamelCase	,						mean=_lowerCamelCase	,						std=_lowerCamelCase			) for image in images]

													if include_top:
																				_UpperCAmelCase  :			int	       =		[self.normalize(image=_lowerCamelCase	,						mean=[0, 0, 0]	,						std=_lowerCamelCase			) for image in images]

													_UpperCAmelCase  :			str	       =		[to_channel_dimension_format(_lowerCamelCase	,						_lowerCamelCase			) for image in images]

													_UpperCAmelCase  :			Dict	       =		{"pixel_values": images}
													return BatchFeature(data=_lowerCamelCase	,						tensor_type=_lowerCamelCase			)




