

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


snake_case_       =       5_0_3_5_8
snake_case_       =       5_0_3_6_2
@require_torch
@require_torchaudio
@require_sentencepiece
class 	SCREAMING_SNAKE_CASE__			(				unittest.TestCase      ):




    def   __lowerCamelCase      (					self			):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_      :			Dict     =       "openai/whisper-small.en"
          SCREAMING_SNAKE_CASE_      :			Union[str, Any]     =       tempfile.mkdtemp()




    def   __lowerCamelCase      (					self				,     **lowercase__			):






          """simple docstring"""






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




    def   __lowerCamelCase      (					self				,     **lowercase__			):






          """simple docstring"""






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




    def   __lowerCamelCase      (					self			):






          """simple docstring"""






          shutil.rmtree(self.tmpdirname			)




    def   __lowerCamelCase      (					self			):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_      :			List[str]     =       self.get_tokenizer()
          SCREAMING_SNAKE_CASE_      :			int     =       self.get_feature_extractor()

          SCREAMING_SNAKE_CASE_      :			Any     =       WhisperProcessor(tokenizer=lowercase__				,     feature_extractor=lowercase__			)

          processor.save_pretrained(self.tmpdirname			)
          SCREAMING_SNAKE_CASE_      :			Optional[int]     =       WhisperProcessor.from_pretrained(self.tmpdirname			)

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

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




    def   __lowerCamelCase      (					self			):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_      :			Optional[Any]     =       WhisperProcessor(tokenizer=self.get_tokenizer()				,     feature_extractor=self.get_feature_extractor()			)
          processor.save_pretrained(self.tmpdirname			)

          SCREAMING_SNAKE_CASE_      :			Tuple     =       self.get_tokenizer(bos_token="(BOS)"				,     eos_token="(EOS)"			)
          SCREAMING_SNAKE_CASE_      :			Optional[Any]     =       self.get_feature_extractor(do_normalize=lowercase__				,     padding_value=1.0			)

          SCREAMING_SNAKE_CASE_      :			List[Any]     =       WhisperProcessor.from_pretrained(
              self.tmpdirname				,     bos_token="(BOS)"				,     eos_token="(EOS)"				,     do_normalize=lowercase__				,     padding_value=1.0			)

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

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




    def   __lowerCamelCase      (					self			):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_      :			Union[str, Any]     =       self.get_feature_extractor()
          SCREAMING_SNAKE_CASE_      :			Tuple     =       self.get_tokenizer()

          SCREAMING_SNAKE_CASE_      :			Optional[int]     =       WhisperProcessor(tokenizer=lowercase__				,     feature_extractor=lowercase__			)

          SCREAMING_SNAKE_CASE_      :			List[Any]     =       floats_list((3, 1000)			)

          SCREAMING_SNAKE_CASE_      :			Union[str, Any]     =       feature_extractor(lowercase__				,     return_tensors="np"			)
          SCREAMING_SNAKE_CASE_      :			Union[str, Any]     =       processor(lowercase__				,     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"""






          SCREAMING_SNAKE_CASE_      :			int     =       self.get_feature_extractor()
          SCREAMING_SNAKE_CASE_      :			Optional[int]     =       self.get_tokenizer()

          SCREAMING_SNAKE_CASE_      :			Optional[Any]     =       WhisperProcessor(tokenizer=lowercase__				,     feature_extractor=lowercase__			)

          SCREAMING_SNAKE_CASE_      :			int     =       "This is a test string"

          SCREAMING_SNAKE_CASE_      :			Any     =       processor(text=lowercase__			)

          SCREAMING_SNAKE_CASE_      :			Optional[int]     =       tokenizer(lowercase__			)

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




    def   __lowerCamelCase      (					self			):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_      :			int     =       self.get_feature_extractor()
          SCREAMING_SNAKE_CASE_      :			int     =       self.get_tokenizer()

          SCREAMING_SNAKE_CASE_      :			str     =       WhisperProcessor(tokenizer=lowercase__				,     feature_extractor=lowercase__			)

          SCREAMING_SNAKE_CASE_      :			int     =       [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

          SCREAMING_SNAKE_CASE_      :			List[Any]     =       processor.batch_decode(lowercase__			)
          SCREAMING_SNAKE_CASE_      :			Union[str, Any]     =       tokenizer.batch_decode(lowercase__			)

          self.assertListEqual(lowercase__				,     lowercase__			)




    def   __lowerCamelCase      (					self			):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_      :			Optional[Any]     =       self.get_feature_extractor()
          SCREAMING_SNAKE_CASE_      :			List[str]     =       self.get_tokenizer()

          SCREAMING_SNAKE_CASE_      :			List[str]     =       WhisperProcessor(tokenizer=lowercase__				,     feature_extractor=lowercase__			)

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






          SCREAMING_SNAKE_CASE_      :			Tuple     =       self.get_feature_extractor()
          SCREAMING_SNAKE_CASE_      :			str     =       self.get_tokenizer()

          SCREAMING_SNAKE_CASE_      :			Any     =       WhisperProcessor(tokenizer=lowercase__				,     feature_extractor=lowercase__			)
          SCREAMING_SNAKE_CASE_      :			List[Any]     =       processor.get_decoder_prompt_ids(task="transcribe"				,     no_timestamps=lowercase__			)

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

          SCREAMING_SNAKE_CASE_      :			List[Any]     =       [TRANSCRIBE, NOTIMESTAMPS]
          self.assertListEqual([ids[-1] for ids in forced_decoder_ids]				,     lowercase__			)




    def   __lowerCamelCase      (					self			):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_      :			int     =       WhisperProcessor(tokenizer=self.get_tokenizer()				,     feature_extractor=self.get_feature_extractor()			)
          SCREAMING_SNAKE_CASE_      :			Optional[int]     =       processor.get_prompt_ids("Mr. Quilter"			)
          SCREAMING_SNAKE_CASE_      :			int     =       processor.tokenizer.decode(lowercase__			)

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




    def   __lowerCamelCase      (					self			):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_      :			int     =       WhisperProcessor(tokenizer=self.get_tokenizer()				,     feature_extractor=self.get_feature_extractor()			)
          SCREAMING_SNAKE_CASE_      :			Optional[int]     =       processor.get_prompt_ids(""			)
          SCREAMING_SNAKE_CASE_      :			Union[str, Any]     =       processor.tokenizer.decode(lowercase__			)

          self.assertListEqual(prompt_ids.tolist()				,     [5_0360, 220]			)
          self.assertEqual(lowercase__				,     "<|startofprev|> "			)







    def   __lowerCamelCase      (					self			):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_      :			Tuple     =       WhisperProcessor(tokenizer=self.get_tokenizer()				,     feature_extractor=self.get_feature_extractor()			)

          def _test_prompt_error_raised_helper(lowercase__				,     lowercase__			):
                with pytest.raises(lowercase__			) as excinfo:
                      processor.get_prompt_ids(lowercase__			)
                SCREAMING_SNAKE_CASE_      :			Optional[Any]     =       F"Encountered text in the prompt corresponding to disallowed special token: {special_token}."
                self.assertEqual(lowercase__				,     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 torch

from transformers import AutoTokenizer

class 				_UpperCamelCase (    _A     ):






			'''simple docstring'''

			def __init__(				self       :				List[str]  ,		snake_case_       :				Dict					):
							UpperCamelCase_:							int		=  AutoTokenizer.from_pretrained(snake_case_					)

			def 					lowerCAmelCase__		(				self       :				Union[str, Any]  ,		snake_case_       :				Optional[Any]					):

							if isinstance(snake_case_  ,		snake_case_					) and all(isinstance(_x  ,		snake_case_					) for _x in x					):
											UpperCamelCase_:							Tuple		=  None
											for l in x:
															UpperCamelCase_:							Optional[Any]		=  self.tokenizer(
															    snake_case_  ,		padding="""max_length"""  ,		max_length=384  ,		truncation=snake_case_  ,		return_tensors="""pt"""  ,		)
															UpperCamelCase_:							str		=  torch.tensor([len(snake_case_					)]					)
															if d is not None:
																			for k in d.keys():
																							UpperCamelCase_:							List[Any]		=  torch.cat((d[k], t[k])  ,		0					)
															else:
																			UpperCamelCase_:							Optional[int]		=  t

											UpperCamelCase_:							Union[str, Any]		=  torch.tensor(self.tokenizer.convert_tokens_to_ids("""[E]"""					)					)
											UpperCamelCase_:							List[str]		=  torch.tensor(self.tokenizer.convert_tokens_to_ids("""[/E]"""					)					)

							elif isinstance(snake_case_  ,		snake_case_					) and all(isinstance(_x  ,		snake_case_					) for _x in x					):
											UpperCamelCase_:							List[str]		=  self.tokenizer(
											    snake_case_  ,		padding="""max_length"""  ,		max_length=384  ,		truncation=snake_case_  ,		return_tensors="""pt"""  ,		)

							else:
											raise Exception(
											    """Type of parameter x was not recognized! Only `list of strings` for query or `list of lists of"""
											    """ strings` for supports are supported."""					)

							return d




			def 					lowerCAmelCase__		(				self       :				int  ,		snake_case_       :				List[str]  ,		snake_case_       :				Optional[int]  ,		snake_case_       :				Optional[Any]  ,		snake_case_       :				Optional[int]  ,		snake_case_       :				List[Any]=0.70					):
							UpperCamelCase_:							int		=  []
							for idx in range(len(W_query["""input_ids"""]					)					):
											UpperCamelCase_:							List[str]		=  range(p_start.shape[1]					)

											UpperCamelCase_:							str		=  []
											for start_id in start_indexes:
															for end_id in end_indexes:
																			if start_id < end_id:
																							output.append(
																							    (
																							        start_id,
																							        end_id,
																							        p_start[idx][start_id].item(),
																							        p_end[idx][end_id].item(),
																							    )					)

											output.sort(key=lambda snake_case_					: (tup[2] * tup[3])  ,		reverse=snake_case_					)
											UpperCamelCase_:							Optional[int]		=  []
											for k in range(len(snake_case_					)					):
															if output[k][2] * output[k][3] >= thresh:
																			UpperCamelCase_,      UpperCamelCase_:							Tuple		=  output[k][0], output[k][1]
																			UpperCamelCase_:							Any		=  self.tokenizer.decode(W_query["""input_ids"""][idx][c_start_pos:c_end_pos]					)
																			temp.append((decoded, output[k][2] * output[k][3])					)

											final_outputs.append(snake_case_					)

							return final_outputs






