



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


A__     				=	5_03_58
A__     				=	5_03_62





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




				def 							snake_case       (							self		):



									"""simple docstring"""





									_lowerCAmelCase      =   """openai/whisper-small.en"""
									_lowerCAmelCase      =   tempfile.mkdtemp()




				def 							snake_case       (							self						,    **_snake_case		):



									"""simple docstring"""





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




				def 							snake_case       (							self						,    **_snake_case		):



									"""simple docstring"""





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




				def 							snake_case       (							self		):



									"""simple docstring"""





									shutil.rmtree(self.tmpdirname		)




				def 							snake_case       (							self		):



									"""simple docstring"""





									_lowerCAmelCase      =   self.get_tokenizer()
									_lowerCAmelCase      =   self.get_feature_extractor()

									_lowerCAmelCase      =   WhisperProcessor(tokenizer=_snake_case						,    feature_extractor=_snake_case		)

									processor.save_pretrained(self.tmpdirname		)
									_lowerCAmelCase      =   WhisperProcessor.from_pretrained(self.tmpdirname		)

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

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




				def 							snake_case       (							self		):



									"""simple docstring"""





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

									_lowerCAmelCase      =   self.get_tokenizer(bos_token="""(BOS)"""						,    eos_token="""(EOS)"""		)
									_lowerCAmelCase      =   self.get_feature_extractor(do_normalize=_snake_case						,    padding_value=1.0		)

									_lowerCAmelCase      =   WhisperProcessor.from_pretrained(
									    self.tmpdirname						,    bos_token="""(BOS)"""						,    eos_token="""(EOS)"""						,    do_normalize=_snake_case						,    padding_value=1.0		)

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

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




				def 							snake_case       (							self		):



									"""simple docstring"""





									_lowerCAmelCase      =   self.get_feature_extractor()
									_lowerCAmelCase      =   self.get_tokenizer()

									_lowerCAmelCase      =   WhisperProcessor(tokenizer=_snake_case						,    feature_extractor=_snake_case		)

									_lowerCAmelCase      =   floats_list((3, 1000)		)

									_lowerCAmelCase      =   feature_extractor(_snake_case						,    return_tensors="""np"""		)
									_lowerCAmelCase      =   processor(_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 							snake_case       (							self		):



									"""simple docstring"""





									_lowerCAmelCase      =   self.get_feature_extractor()
									_lowerCAmelCase      =   self.get_tokenizer()

									_lowerCAmelCase      =   WhisperProcessor(tokenizer=_snake_case						,    feature_extractor=_snake_case		)

									_lowerCAmelCase      =   """This is a test string"""

									_lowerCAmelCase      =   processor(text=_snake_case		)

									_lowerCAmelCase      =   tokenizer(_snake_case		)

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




				def 							snake_case       (							self		):



									"""simple docstring"""





									_lowerCAmelCase      =   self.get_feature_extractor()
									_lowerCAmelCase      =   self.get_tokenizer()

									_lowerCAmelCase      =   WhisperProcessor(tokenizer=_snake_case						,    feature_extractor=_snake_case		)

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

									_lowerCAmelCase      =   processor.batch_decode(_snake_case		)
									_lowerCAmelCase      =   tokenizer.batch_decode(_snake_case		)

									self.assertListEqual(_snake_case						,    _snake_case		)




				def 							snake_case       (							self		):



									"""simple docstring"""





									_lowerCAmelCase      =   self.get_feature_extractor()
									_lowerCAmelCase      =   self.get_tokenizer()

									_lowerCAmelCase      =   WhisperProcessor(tokenizer=_snake_case						,    feature_extractor=_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 							snake_case       (							self		):



									"""simple docstring"""





									_lowerCAmelCase      =   self.get_feature_extractor()
									_lowerCAmelCase      =   self.get_tokenizer()

									_lowerCAmelCase      =   WhisperProcessor(tokenizer=_snake_case						,    feature_extractor=_snake_case		)
									_lowerCAmelCase      =   processor.get_decoder_prompt_ids(task="""transcribe"""						,    no_timestamps=_snake_case		)

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

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




				def 							snake_case       (							self		):



									"""simple docstring"""





									_lowerCAmelCase      =   WhisperProcessor(tokenizer=self.get_tokenizer()						,    feature_extractor=self.get_feature_extractor()		)
									_lowerCAmelCase      =   processor.get_prompt_ids("""Mr. Quilter"""		)
									_lowerCAmelCase      =   processor.tokenizer.decode(_snake_case		)

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




				def 							snake_case       (							self		):



									"""simple docstring"""





									_lowerCAmelCase      =   WhisperProcessor(tokenizer=self.get_tokenizer()						,    feature_extractor=self.get_feature_extractor()		)
									_lowerCAmelCase      =   processor.get_prompt_ids(""""""		)
									_lowerCAmelCase      =   processor.tokenizer.decode(_snake_case		)

									self.assertListEqual(prompt_ids.tolist()						,    [50360, 220]		)
									self.assertEqual(_snake_case						,    """<|startofprev|> """		)




				def 							snake_case       (							self		):



									"""simple docstring"""





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

									def _test_prompt_error_raised_helper(_snake_case						,    _snake_case		):
														with pytest.raises(_snake_case		) as excinfo:
																			processor.get_prompt_ids(_snake_case		)
														_lowerCAmelCase      =   F'Encountered text in the prompt corresponding to disallowed special token: {special_token}.'
														self.assertEqual(_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|>"""		)








import os

from packaging import version

from .. import __version__
from .accelerate_utils import apply_forward_hook
from .constants import (
    CONFIG_NAME,
    DEPRECATED_REVISION_ARGS,
    DIFFUSERS_CACHE,
    DIFFUSERS_DYNAMIC_MODULE_NAME,
    FLAX_WEIGHTS_NAME,
    HF_MODULES_CACHE,
    HUGGINGFACE_CO_RESOLVE_ENDPOINT,
    ONNX_EXTERNAL_WEIGHTS_NAME,
    ONNX_WEIGHTS_NAME,
    SAFETENSORS_WEIGHTS_NAME,
    TEXT_ENCODER_ATTN_MODULE,
    WEIGHTS_NAME,
)
from .deprecation_utils import deprecate
from .doc_utils import replace_example_docstring
from .dynamic_modules_utils import get_class_from_dynamic_module
from .hub_utils import (
    HF_HUB_OFFLINE,
    _add_variant,
    _get_model_file,
    extract_commit_hash,
    http_user_agent,
)
from .import_utils import (
    BACKENDS_MAPPING,
    ENV_VARS_TRUE_AND_AUTO_VALUES,
    ENV_VARS_TRUE_VALUES,
    USE_JAX,
    USE_TF,
    USE_TORCH,
    DummyObject,
    OptionalDependencyNotAvailable,
    is_accelerate_available,
    is_accelerate_version,
    is_bsa_available,
    is_flax_available,
    is_ftfy_available,
    is_inflect_available,
    is_invisible_watermark_available,
    is_k_diffusion_available,
    is_k_diffusion_version,
    is_librosa_available,
    is_note_seq_available,
    is_omegaconf_available,
    is_onnx_available,
    is_safetensors_available,
    is_scipy_available,
    is_tensorboard_available,
    is_tf_available,
    is_torch_available,
    is_torch_version,
    is_torchsde_available,
    is_transformers_available,
    is_transformers_version,
    is_unidecode_available,
    is_wandb_available,
    is_xformers_available,
    requires_backends,
)
from .logging import get_logger
from .outputs import BaseOutput
from .pil_utils import PIL_INTERPOLATION, numpy_to_pil, pt_to_pil
from .torch_utils import is_compiled_module, randn_tensor


if is_torch_available():
	from .testing_utils import (
	    floats_tensor,
	    load_hf_numpy,
	    load_image,
	    load_numpy,
	    load_pt,
	    nightly,
	    parse_flag_from_env,
	    print_tensor_test,
	    require_torch_a,
	    require_torch_gpu,
	    skip_mps,
	    slow,
	    torch_all_close,
	    torch_device,
	)
	from .torch_utils import maybe_allow_in_graph

from .testing_utils import export_to_gif, export_to_video


A__     				=	get_logger(__name__)


def 		_UpperCAmelCase    (				snake_case      ):





					"""simple docstring"""

					if version.parse(snake_case      ) < version.parse(snake_case      ):
										if "dev" in min_version:
															_lowerCAmelCase      =   (
															    """This example requires a source install from HuggingFace diffusers (see """
															    """`https://huggingface.co/docs/diffusers/installation#install-from-source`),"""
															)
										else:
															_lowerCAmelCase      =   F'This example requires a minimum version of {min_version},'
										error_message += F' but the version found is {__version__}.\n'
										raise ImportError(snake_case      )



