



from __future__ import annotations

from abc import abstractmethod
from collections.abc import Iterable
from typing import Generic, Protocol, TypeVar


class 						lowerCamelCase__			(		_a ):


						@abstractmethod
						def __lt__(			self    :	T   ,							_a    :	T      ):
													pass


						@abstractmethod
						def __gt__(			self    :	T   ,							_a    :	T      ):
													pass







						@abstractmethod
						def __eq__(			self    :	T   ,							_a    :	object      ):
													pass


__UpperCAmelCase    	=  TypeVar('''T''', bound=Comparable)


class 						lowerCamelCase__			(		Generic[T] ):


						def __init__(			self    :	Optional[Any]      ):
													a__:							list[T]									=[]
													a__:							int									=0


						def __repr__(			self    :	List[Any]      ):
													return str(self.h      )


						def 	_lowerCamelCase      (			self    :	str   ,							_a    :	int      ):
													if child_idx > 0:
																				return (child_idx - 1) // 2
													return None


						def 	_lowerCamelCase      (			self    :	Optional[Any]   ,							_a    :	int      ):
													a__:							List[str]									=2 * parent_idx + 1
													if left_child_index < self.heap_size:
																				return left_child_index
													return None


						def 	_lowerCamelCase      (			self    :	List[Any]   ,							_a    :	int      ):
													a__:							List[str]									=2 * parent_idx + 2
													if right_child_index < self.heap_size:
																				return right_child_index
													return None


						def 	_lowerCamelCase      (			self    :	Dict   ,							_a    :	int      ):
													if index < self.heap_size:
																				a__:							int									=index
																				a__:							Optional[int]									=self.left_child_idx(_a      )
																				a__:							Optional[Any]									=self.right_child_idx(_a      )
																				# check which child is larger than its parent
																				if left_child is not None and self.h[left_child] > self.h[violation]:
																											a__:							Any									=left_child
																				if right_child is not None and self.h[right_child] > self.h[violation]:
																											a__:							List[Any]									=right_child
																				# if violation indeed exists
																				if violation != index:
																											# swap to fix the violation
																											a__				,      a__:							Dict									=self.h[index], self.h[violation]
																											# fix the subsequent violation recursively if any
																											self.max_heapify(_a      )


						def 	_lowerCamelCase      (			self    :	Union[str, Any]   ,							_a    :	Iterable[T]      ):
													a__:							Tuple									=list(_a      )
													a__:							Optional[int]									=len(self.h      )
													if self.heap_size > 1:
																				# max_heapify from right to left but exclude leaves (last level)
																				for i in range(self.heap_size // 2 - 1   ,							-1   ,							-1      ):
																											self.max_heapify(_a      )


						def 	_lowerCamelCase      (			self    :	List[str]      ):
													if self.heap_size >= 2:
																				a__:							str									=self.h[0]
																				a__:							str									=self.h.pop(-1      )
																				self.heap_size -= 1
																				self.max_heapify(0      )
																				return me
													elif self.heap_size == 1:
																				self.heap_size -= 1
																				return self.h.pop(-1      )
													else:
																				raise Exception("Empty heap"      )


						def 	_lowerCamelCase      (			self    :	Any   ,							_a    :	T      ):
													self.h.append(_a      )
													a__:							Optional[Any]									=(self.heap_size - 1) // 2
													self.heap_size += 1
													while idx >= 0:
																				self.max_heapify(_a      )
																				a__:							Any									=(idx - 1) // 2







						def 	_lowerCamelCase      (			self    :	Optional[int]      ):
													a__:							int									=self.heap_size
													for j in range(size - 1   ,							0   ,							-1      ):
																				a__				,      a__:							int									=self.h[j], self.h[0]
																				self.heap_size -= 1
																				self.max_heapify(0      )
													a__:							Optional[Any]									=size


if __name__ == "__main__":
		import doctest

		# run doc test
		doctest.testmod()

		# demo
		for unsorted in [
		    [0],
		    [2],
		    [3, 5],
		    [5, 3],
		    [5, 5],
		    [0, 0, 0, 0],
		    [1, 1, 1, 1],
		    [2, 2, 3, 5],
		    [0, 2, 2, 3, 5],
		    [2, 5, 3, 0, 2, 3, 0, 3],
		    [6, 1, 2, 7, 9, 3, 4, 5, 10, 8],
		    [1_03, 9, 1, 7, 11, 15, 25, 2_01, 2_09, 1_07, 5],
		    [-45, -2, -5],
		]:
				print(f"""unsorted array: {unsorted}""")

				__UpperCAmelCase    	=  Heap()
				heap.build_max_heap(unsorted)
				print(f"""after build heap: {heap}""")

				print(f"""max value: {heap.extract_max()}""")
				print(f"""after max value removed: {heap}""")

				heap.insert(1_00)
				print(f"""after new value 100 inserted: {heap}""")

				heap.heap_sort()
				print(f"""heap-sorted array: {heap}\n""")










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|>"      )





