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


__lowercase				   =  5_0_3_5_8
__lowercase				   =  5_0_3_6_2






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


			'''simple docstring'''






			def 							a_	(       self):




					"""simple docstring"""


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



			def 							a_	(       self	,   **__lowerCAmelCase):




					"""simple docstring"""


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



			def 							a_	(       self	,   **__lowerCAmelCase):




					"""simple docstring"""


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



			def 							a_	(       self):




					"""simple docstring"""


					shutil.rmtree(self.tmpdirname)



			def 							a_	(       self):




					"""simple docstring"""


					lowerCAmelCase        =  self.get_tokenizer()
					lowerCAmelCase        =  self.get_feature_extractor()

					lowerCAmelCase        =  WhisperProcessor(tokenizer=_lowerCamelCase	,   feature_extractor=_lowerCamelCase)

					processor.save_pretrained(self.tmpdirname)
					lowerCAmelCase        =  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):




					"""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=_lowerCamelCase	,   padding_value=1.0)

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




					"""simple docstring"""


					lowerCAmelCase        =  self.get_feature_extractor()
					lowerCAmelCase        =  self.get_tokenizer()

					lowerCAmelCase        =  WhisperProcessor(tokenizer=_lowerCamelCase	,   feature_extractor=_lowerCamelCase)

					lowerCAmelCase        =  floats_list((3, 1000))

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




					"""simple docstring"""


					lowerCAmelCase        =  self.get_feature_extractor()
					lowerCAmelCase        =  self.get_tokenizer()

					lowerCAmelCase        =  WhisperProcessor(tokenizer=_lowerCamelCase	,   feature_extractor=_lowerCamelCase)

					lowerCAmelCase        =  """This is a test string"""

					lowerCAmelCase        =  processor(text=_lowerCamelCase)

					lowerCAmelCase        =  tokenizer(_lowerCamelCase)

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



			def 							a_	(       self):




					"""simple docstring"""


					lowerCAmelCase        =  self.get_feature_extractor()
					lowerCAmelCase        =  self.get_tokenizer()

					lowerCAmelCase        =  WhisperProcessor(tokenizer=_lowerCamelCase	,   feature_extractor=_lowerCamelCase)

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

					lowerCAmelCase        =  processor.batch_decode(_lowerCamelCase)
					lowerCAmelCase        =  tokenizer.batch_decode(_lowerCamelCase)

					self.assertListEqual(_lowerCamelCase	,   _lowerCamelCase)



			def 							a_	(       self):




					"""simple docstring"""


					lowerCAmelCase        =  self.get_feature_extractor()
					lowerCAmelCase        =  self.get_tokenizer()

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




					"""simple docstring"""


					lowerCAmelCase        =  self.get_feature_extractor()
					lowerCAmelCase        =  self.get_tokenizer()

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

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



			def 							a_	(       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(_lowerCamelCase)

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



			def 							a_	(       self):




					"""simple docstring"""


					lowerCAmelCase        =  WhisperProcessor(tokenizer=self.get_tokenizer()	,   feature_extractor=self.get_feature_extractor())
					lowerCAmelCase        =  processor.get_prompt_ids("""""")
					lowerCAmelCase        =  processor.tokenizer.decode(_lowerCamelCase)

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







			def 							a_	(       self):




					"""simple docstring"""


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

					def _test_prompt_error_raised_helper(__lowerCAmelCase	,   __lowerCAmelCase):
							with pytest.raises(_lowerCamelCase) as excinfo:
									processor.get_prompt_ids(_lowerCamelCase)
							lowerCAmelCase        =  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|>""")





'''simple docstring'''




from __future__ import annotations

__lowercase				   =  [2, 1, 4, 5, 6, 0, 8, 9, 1, 2, 0, 6, 4, 2, 0, 6, 5, 3, 2, 7]






class     a__:


			'''simple docstring'''






			def __init__(       self	,   __lowerCAmelCase):




					"""simple docstring"""


					lowerCAmelCase        =  -1
					lowerCAmelCase        =  -1
					lowerCAmelCase        =  [-1] * length
					lowerCAmelCase        =  None
					lowerCAmelCase        =  None







			def __repr__(       self):




					"""simple docstring"""


					return f"Node(min_value={self.minn} max_value={self.maxx})"







def     snake_case__							(      _A: list[int]			)   ->     Node | None:

		'''simple docstring'''


		lowerCAmelCase        =  Node(len(_A			)			)
		lowerCAmelCase ,					lowerCAmelCase        =  min(_A			), max(_A			)
		# Leaf node case where the node contains only one unique value
		if root.minn == root.maxx:
				return root
		lowerCAmelCase        =  (root.minn + root.maxx) // 2

		lowerCAmelCase        =  []
		lowerCAmelCase        =  []

		for index, num in enumerate(_A			):
				if num <= pivot:
						left_arr.append(_A			)
				else:
						right_arr.append(_A			)
				lowerCAmelCase        =  len(_A			)
		lowerCAmelCase        =  build_tree(_A			)
		lowerCAmelCase        =  build_tree(_A			)
		return root






def     snake_case__							(      _A: Node | None				,       _A: int				,       _A: int			)   ->     int:

		'''simple docstring'''


		if index < 0 or node is None:
				return 0
		# Leaf node cases
		if node.minn == node.maxx:
				return index + 1 if node.minn == num else 0
		lowerCAmelCase        =  (node.minn + node.maxx) // 2
		if num <= pivot:
				# go the left subtree and map index to the left subtree
				return rank_till_index(node.left				,       _A				,       node.map_left[index] - 1			)
		else:
				# go to the right subtree and map index to the right subtree
				return rank_till_index(node.right				,       _A				,       index - node.map_left[index]			)






def     snake_case__							(      _A: Node | None				,       _A: int				,       _A: int				,       _A: int			)   ->     int:

		'''simple docstring'''


		if start > end:
				return 0
		lowerCAmelCase        =  rank_till_index(_A				,       _A				,       _A			)
		lowerCAmelCase        =  rank_till_index(_A				,       _A				,       start - 1			)
		return rank_till_end - rank_before_start






def     snake_case__							(      _A: Node | None				,       _A: int				,       _A: int				,       _A: int			)   ->     int:

		'''simple docstring'''


		if index > (end - start) or start > end or node is None:
				return -1
		# Leaf node case
		if node.minn == node.maxx:
				return node.minn
		# Number of elements in the left subtree in interval [start, end]
		lowerCAmelCase        =  node.map_left[end] - (
		    node.map_left[start - 1] if start else 0
		)
		if num_elements_in_left_tree > index:
				return quantile(
				    node.left				,       _A				,       (node.map_left[start - 1] if start else 0)				,       node.map_left[end] - 1				,       )
		else:
				return quantile(
				    node.right				,       index - num_elements_in_left_tree				,       start - (node.map_left[start - 1] if start else 0)				,       end - node.map_left[end]				,       )






def     snake_case__							(      _A: Node | None				,       _A: int				,       _A: int				,       _A: int				,       _A: int			)   ->     int:

		'''simple docstring'''


		if (
		    start > end
		    or node is None
		    or start_num > end_num
		    or node.minn > end_num
		    or node.maxx < start_num
		):
				return 0
		if start_num <= node.minn and node.maxx <= end_num:
				return end - start + 1
		lowerCAmelCase        =  range_counting(
		    node.left				,       (node.map_left[start - 1] if start else 0)				,       node.map_left[end] - 1				,       _A				,       _A				,       )
		lowerCAmelCase        =  range_counting(
		    node.right				,       start - (node.map_left[start - 1] if start else 0)				,       end - node.map_left[end]				,       _A				,       _A				,       )
		return left + right


if __name__ == "__main__":
						import doctest

						doctest.testmod()




