





'''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


_a					: List[str]      =    5_0_3_5_8
_a					: Dict      =    5_0_3_6_2





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



					'''simple docstring'''

					__lowerCAmelCase											=				"""openai/whisper-small.en"""
					__lowerCAmelCase											=				tempfile.mkdtemp()
		def   lowerCamelCase__			(  self,**__SCREAMING_SNAKE_CASE			):



					'''simple docstring'''

					return WhisperTokenizer.from_pretrained(self.checkpoint,**__SCREAMING_SNAKE_CASE			)
		def   lowerCamelCase__			(  self,**__SCREAMING_SNAKE_CASE			):



					'''simple docstring'''

					return WhisperFeatureExtractor.from_pretrained(self.checkpoint,**__SCREAMING_SNAKE_CASE			)
		def   lowerCamelCase__			(  self			):



					'''simple docstring'''

					shutil.rmtree(self.tmpdirname			)
		def   lowerCamelCase__			(  self			):



					'''simple docstring'''

					__lowerCAmelCase											=				self.get_tokenizer()
					__lowerCAmelCase											=				self.get_feature_extractor()

					__lowerCAmelCase											=				WhisperProcessor(tokenizer=__SCREAMING_SNAKE_CASE,feature_extractor=__SCREAMING_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,__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			):



					'''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=__SCREAMING_SNAKE_CASE,padding_value=1.0			)

					__lowerCAmelCase											=				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			):



					'''simple docstring'''

					__lowerCAmelCase											=				self.get_feature_extractor()
					__lowerCAmelCase											=				self.get_tokenizer()

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

					__lowerCAmelCase											=				floats_list((3, 10_00)			)

					__lowerCAmelCase											=				feature_extractor(__SCREAMING_SNAKE_CASE,return_tensors="""np"""			)
					__lowerCAmelCase											=				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			):



					'''simple docstring'''

					__lowerCAmelCase											=				self.get_feature_extractor()
					__lowerCAmelCase											=				self.get_tokenizer()

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

					__lowerCAmelCase											=				"""This is a test string"""

					__lowerCAmelCase											=				processor(text=__SCREAMING_SNAKE_CASE			)

					__lowerCAmelCase											=				tokenizer(__SCREAMING_SNAKE_CASE			)

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



					'''simple docstring'''

					__lowerCAmelCase											=				self.get_feature_extractor()
					__lowerCAmelCase											=				self.get_tokenizer()

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

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

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

					self.assertListEqual(__SCREAMING_SNAKE_CASE,__SCREAMING_SNAKE_CASE			)
		def   lowerCamelCase__			(  self			):



					'''simple docstring'''

					__lowerCAmelCase											=				self.get_feature_extractor()
					__lowerCAmelCase											=				self.get_tokenizer()

					__lowerCAmelCase											=				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			):



					'''simple docstring'''

					__lowerCAmelCase											=				self.get_feature_extractor()
					__lowerCAmelCase											=				self.get_tokenizer()

					__lowerCAmelCase											=				WhisperProcessor(tokenizer=__SCREAMING_SNAKE_CASE,feature_extractor=__SCREAMING_SNAKE_CASE			)
					__lowerCAmelCase											=				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)			)

					__lowerCAmelCase											=				[TRANSCRIBE, NOTIMESTAMPS]
					self.assertListEqual([ids[-1] for ids in forced_decoder_ids],__SCREAMING_SNAKE_CASE			)
		def   lowerCamelCase__			(  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(__SCREAMING_SNAKE_CASE			)

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



					'''simple docstring'''

					__lowerCAmelCase											=				WhisperProcessor(tokenizer=self.get_tokenizer(),feature_extractor=self.get_feature_extractor()			)
					__lowerCAmelCase											=				processor.get_prompt_ids(""""""			)
					__lowerCAmelCase											=				processor.tokenizer.decode(__SCREAMING_SNAKE_CASE			)

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







		def   lowerCamelCase__			(  self			):



					'''simple docstring'''

					__lowerCAmelCase											=				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			)
								__lowerCAmelCase											=				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 collections import namedtuple

_a					: Any      =    namedtuple("""from_to""", """from_ to""")

_a					: Dict      =    {
    """millimeter""": """mm""",
    """centimeter""": """cm""",
    """meter""": """m""",
    """kilometer""": """km""",
    """inch""": """in""",
    """inche""": """in""",  # Trailing 's' has been stripped off
    """feet""": """ft""",
    """foot""": """ft""",
    """yard""": """yd""",
    """mile""": """mi""",
}

_a					: Optional[Any]      =    {
    """mm""": from_to(0.001, 1_0_0_0),
    """cm""": from_to(0.01, 1_0_0),
    """m""": from_to(1, 1),
    """km""": from_to(1_0_0_0, 0.001),
    """in""": from_to(0.0254, 39.3701),
    """ft""": from_to(0.3048, 3.28084),
    """yd""": from_to(0.9144, 1.09361),
    """mi""": from_to(1609.34, 0.000621371),
}





def    _lowerCAmelCase						(						lowercase					,	lowercase					,	lowercase	)					->					float:
			__lowerCAmelCase											=				from_type.lower().rstrip("""s"""	)
			__lowerCAmelCase											=				TYPE_CONVERSION.get(lowercase					,	lowercase	)
			__lowerCAmelCase											=				to_type.lower().rstrip("""s"""	)
			__lowerCAmelCase											=				TYPE_CONVERSION.get(lowercase					,	lowercase	)
			if new_from not in METRIC_CONVERSION:
						__lowerCAmelCase											=				(
						    f'Invalid \'from_type\' value: {from_type!r}.\n'
						    f'Conversion abbreviations are: {", ".join(lowercase	)}'
						)
						raise ValueError(lowercase	)
			if new_to not in METRIC_CONVERSION:
						__lowerCAmelCase											=				(
						    f'Invalid \'to_type\' value: {to_type!r}.\n'
						    f'Conversion abbreviations are: {", ".join(lowercase	)}'
						)
						raise ValueError(lowercase	)
			return value * METRIC_CONVERSION[new_from].from_ * METRIC_CONVERSION[new_to].to


if __name__ == "__main__":
	import doctest

	doctest.testmod()

