






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										=		50358
__UpperCAmelCase										=		50362



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







		'''simple docstring'''



		def       __UpperCAmelCase    (							self     )			->							Dict:
							UpperCAmelCase_					:   Tuple   =		'openai/whisper-small.en'
							UpperCAmelCase_					:   Union[str, Any]   =		tempfile.mkdtemp()



		def       __UpperCAmelCase    (							self       ,	**_UpperCamelCase     )			->							str:
							return WhisperTokenizer.from_pretrained(self.checkpoint       ,	**_UpperCamelCase     )



		def       __UpperCAmelCase    (							self       ,	**_UpperCamelCase     )			->							Tuple:
							return WhisperFeatureExtractor.from_pretrained(self.checkpoint       ,	**_UpperCamelCase     )



		def       __UpperCAmelCase    (							self     )			->							List[str]:
							shutil.rmtree(self.tmpdirname     )



		def       __UpperCAmelCase    (							self     )			->							str:
							UpperCAmelCase_					:   Optional[int]   =		self.get_tokenizer()
							UpperCAmelCase_					:   Tuple   =		self.get_feature_extractor()

							UpperCAmelCase_					:   List[Any]   =		WhisperProcessor(tokenizer=_UpperCamelCase       ,	feature_extractor=_UpperCamelCase     )

							processor.save_pretrained(self.tmpdirname     )
							UpperCAmelCase_					:   Tuple   =		WhisperProcessor.from_pretrained(self.tmpdirname     )

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

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



		def       __UpperCAmelCase    (							self     )			->							Tuple:
							UpperCAmelCase_					:   Tuple   =		WhisperProcessor(tokenizer=self.get_tokenizer()       ,	feature_extractor=self.get_feature_extractor()     )
							processor.save_pretrained(self.tmpdirname     )

							UpperCAmelCase_					:   int   =		self.get_tokenizer(bos_token='(BOS)'       ,	eos_token='(EOS)'     )
							UpperCAmelCase_					:   Any   =		self.get_feature_extractor(do_normalize=_UpperCamelCase       ,	padding_value=1.0     )

							UpperCAmelCase_					:   List[str]   =		WhisperProcessor.from_pretrained(
							    self.tmpdirname       ,	bos_token='(BOS)'       ,	eos_token='(EOS)'       ,	do_normalize=_UpperCamelCase       ,	padding_value=1.0     )

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

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



		def       __UpperCAmelCase    (							self     )			->							Any:
							UpperCAmelCase_					:   Tuple   =		self.get_feature_extractor()
							UpperCAmelCase_					:   str   =		self.get_tokenizer()

							UpperCAmelCase_					:   Optional[int]   =		WhisperProcessor(tokenizer=_UpperCamelCase       ,	feature_extractor=_UpperCamelCase     )

							UpperCAmelCase_					:   Any   =		floats_list((3, 1_0_0_0)     )

							UpperCAmelCase_					:   int   =		feature_extractor(_UpperCamelCase       ,	return_tensors='np'     )
							UpperCAmelCase_					:   Any   =		processor(_UpperCamelCase       ,	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       __UpperCAmelCase    (							self     )			->							Any:
							UpperCAmelCase_					:   Optional[Any]   =		self.get_feature_extractor()
							UpperCAmelCase_					:   Optional[Any]   =		self.get_tokenizer()

							UpperCAmelCase_					:   List[str]   =		WhisperProcessor(tokenizer=_UpperCamelCase       ,	feature_extractor=_UpperCamelCase     )

							UpperCAmelCase_					:   str   =		'This is a test string'

							UpperCAmelCase_					:   Any   =		processor(text=_UpperCamelCase     )

							UpperCAmelCase_					:   List[Any]   =		tokenizer(_UpperCamelCase     )

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



		def       __UpperCAmelCase    (							self     )			->							Dict:
							UpperCAmelCase_					:   Dict   =		self.get_feature_extractor()
							UpperCAmelCase_					:   List[Any]   =		self.get_tokenizer()

							UpperCAmelCase_					:   str   =		WhisperProcessor(tokenizer=_UpperCamelCase       ,	feature_extractor=_UpperCamelCase     )

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

							UpperCAmelCase_					:   List[str]   =		processor.batch_decode(_UpperCamelCase     )
							UpperCAmelCase_					:   int   =		tokenizer.batch_decode(_UpperCamelCase     )

							self.assertListEqual(_UpperCamelCase       ,	_UpperCamelCase     )



		def       __UpperCAmelCase    (							self     )			->							Union[str, Any]:
							UpperCAmelCase_					:   Optional[int]   =		self.get_feature_extractor()
							UpperCAmelCase_					:   Any   =		self.get_tokenizer()

							UpperCAmelCase_					:   Optional[int]   =		WhisperProcessor(tokenizer=_UpperCamelCase       ,	feature_extractor=_UpperCamelCase     )

							self.assertListEqual(
							    processor.model_input_names       ,	feature_extractor.model_input_names       ,	msg='`processor` and `feature_extractor` model input names do not match'       ,	)



		def       __UpperCAmelCase    (							self     )			->							Optional[Any]:
							UpperCAmelCase_					:   Tuple   =		self.get_feature_extractor()
							UpperCAmelCase_					:   Dict   =		self.get_tokenizer()

							UpperCAmelCase_					:   List[Any]   =		WhisperProcessor(tokenizer=_UpperCamelCase       ,	feature_extractor=_UpperCamelCase     )
							UpperCAmelCase_					:   List[Any]   =		processor.get_decoder_prompt_ids(task='transcribe'       ,	no_timestamps=_UpperCamelCase     )

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

							UpperCAmelCase_					:   List[str]   =		[TRANSCRIBE, NOTIMESTAMPS]
							self.assertListEqual([ids[-1] for ids in forced_decoder_ids]       ,	_UpperCamelCase     )



		def       __UpperCAmelCase    (							self     )			->							Any:
							UpperCAmelCase_					:   List[Any]   =		WhisperProcessor(tokenizer=self.get_tokenizer()       ,	feature_extractor=self.get_feature_extractor()     )
							UpperCAmelCase_					:   int   =		processor.get_prompt_ids('Mr. Quilter'     )
							UpperCAmelCase_					:   List[str]   =		processor.tokenizer.decode(_UpperCamelCase     )

							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(_UpperCamelCase       ,	'<|startofprev|> Mr. Quilter'     )



		def       __UpperCAmelCase    (							self     )			->							int:
							UpperCAmelCase_					:   int   =		WhisperProcessor(tokenizer=self.get_tokenizer()       ,	feature_extractor=self.get_feature_extractor()     )
							UpperCAmelCase_					:   str   =		processor.get_prompt_ids(''     )
							UpperCAmelCase_					:   Optional[Any]   =		processor.tokenizer.decode(_UpperCamelCase     )

							self.assertListEqual(prompt_ids.tolist()       ,	[5_0_3_6_0, 2_2_0]     )
							self.assertEqual(_UpperCamelCase       ,	'<|startofprev|> '     )



		def       __UpperCAmelCase    (							self     )			->							Any:
							UpperCAmelCase_					:   Tuple   =		WhisperProcessor(tokenizer=self.get_tokenizer()       ,	feature_extractor=self.get_feature_extractor()     )

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














from __future__ import annotations

from typing import Any




def   lowercase__   (  *__snake_case					:							list[list[int]]						):


					'''simple docstring'''


					if all(_check_not_integer(__snake_case						) for m in matrix_s						):
										for i in matrix_s[1:]:
															_verify_matrix_sizes(matrix_s[0]  , __snake_case						)
										return [[sum(__snake_case						) for t in zip(*__snake_case						)] for m in zip(*__snake_case						)]
					raise TypeError('Expected a matrix, got int/list instead'						)




def   lowercase__   (  __snake_case					:							list[list[int]]  , __snake_case					:							list[list[int]]						):


					'''simple docstring'''


					if (
					    _check_not_integer(__snake_case						)
					    and _check_not_integer(__snake_case						)
					    and _verify_matrix_sizes(__snake_case  , __snake_case						)
					):
										return [[i - j for i, j in zip(*__snake_case						)] for m in zip(__snake_case  , __snake_case						)]
					raise TypeError('Expected a matrix, got int/list instead'						)




def   lowercase__   (  __snake_case					:							list[list[int]]  , __snake_case					:							int | float						):


					'''simple docstring'''


					return [[x * n for x in row] for row in matrix]




def   lowercase__   (  __snake_case					:							list[list[int]]  , __snake_case					:							list[list[int]]						):


					'''simple docstring'''


					if _check_not_integer(__snake_case						) and _check_not_integer(__snake_case						):
										UpperCAmelCase_ ,						UpperCAmelCase_					:   str   =		_verify_matrix_sizes(__snake_case  , __snake_case						)

					if cols[0] != rows[1]:
										UpperCAmelCase_					:   Dict   =		(
										    'Cannot multiply matrix of dimensions '
										    F"({rows[0]},{cols[0]}) and ({rows[1]},{cols[1]})"
										)
										raise ValueError(__snake_case						)
					return [
					    [sum(m * n for m, n in zip(__snake_case  , __snake_case						)						) for j in zip(*__snake_case						)] for i in matrix_a
					]




def   lowercase__   (  __snake_case					:							int						):


					'''simple docstring'''


					UpperCAmelCase_					:   Optional[Any]   =		int(__snake_case						)
					return [[int(row == column						) for column in range(__snake_case						)] for row in range(__snake_case						)]




def   lowercase__   (  __snake_case					:							list[list[int]]  , __snake_case					:							bool = True						):


					'''simple docstring'''


					if _check_not_integer(__snake_case						):
										if return_map:
															return map(__snake_case  , zip(*__snake_case						)						)
										else:
															return list(map(__snake_case  , zip(*__snake_case						)						)						)
					raise TypeError('Expected a matrix, got int/list instead'						)




def   lowercase__   (  __snake_case					:							list[list[int]]  , __snake_case					:							int  , __snake_case					:							int						):


					'''simple docstring'''


					UpperCAmelCase_					:   Any   =		matrix[:row] + matrix[row + 1 :]
					return [row[:column] + row[column + 1 :] for row in minor]




def   lowercase__   (  __snake_case					:							list[list[int]]						):


					'''simple docstring'''


					if len(__snake_case						) == 1:
										return matrix[0][0]

					return sum(
					    x * determinant(minor(__snake_case  , 0  , __snake_case						)						) * (-1) ** i
					    for i, x in enumerate(matrix[0]						)						)




def   lowercase__   (  __snake_case					:							list[list[int]]						):


					'''simple docstring'''


					UpperCAmelCase_					:   Optional[int]   =		determinant(__snake_case						)
					if det == 0:
										return None

					UpperCAmelCase_					:   List[str]   =		[
					    [determinant(minor(__snake_case  , __snake_case  , __snake_case						)						) for j in range(len(__snake_case						)						)]
					    for i in range(len(__snake_case						)						)
					]

					UpperCAmelCase_					:   List[str]   =		[
					    [x * (-1) ** (row + col) for col, x in enumerate(matrix_minor[row]						)]
					    for row in range(len(__snake_case						)						)
					]
					UpperCAmelCase_					:   Tuple   =		list(transpose(__snake_case						)						)
					return scalar_multiply(__snake_case  , 1 / det						)




def   lowercase__   (  __snake_case					:							list[list[int]]						):


					'''simple docstring'''


					return not isinstance(__snake_case  , __snake_case						) and not isinstance(matrix[0]  , __snake_case						)




def   lowercase__   (  __snake_case					:							list[list[int]]						):


					'''simple docstring'''


					return len(__snake_case						), len(matrix[0]						)




def   lowercase__   (  __snake_case					:							list[list[int]]  , __snake_case					:							list[list[int]]						):


					'''simple docstring'''


					UpperCAmelCase_					:   Optional[Any]   =		_shape(__snake_case						) + _shape(__snake_case						)
					if shape[0] != shape[3] or shape[1] != shape[2]:
										UpperCAmelCase_					:   Optional[int]   =		(
										    'operands could not be broadcast together with shape '
										    F"({shape[0], shape[1]}), ({shape[2], shape[3]})"
										)
										raise ValueError(__snake_case						)
					return (shape[0], shape[2]), (shape[1], shape[3])




def   lowercase__   (  ):


					'''simple docstring'''


					UpperCAmelCase_					:   Tuple   =		[[12, 10], [3, 9]]
					UpperCAmelCase_					:   Optional[int]   =		[[3, 4], [7, 4]]
					UpperCAmelCase_					:   List[str]   =		[[11, 12, 13, 14], [21, 22, 23, 24], [31, 32, 33, 34], [41, 42, 43, 44]]
					UpperCAmelCase_					:   str   =		[[3, 0, 2], [2, 0, -2], [0, 1, 1]]
					print(F"Add Operation, {add(__snake_case  , __snake_case						) = } \n"						)
					print(
					    F"Multiply Operation, {multiply(__snake_case  , __snake_case						) = } \n"  , )
					print(F"Identity: {identity(5						)}\n"						)
					print(F"Minor of {matrix_c} = {minor(__snake_case  , 1  , 2						)} \n"						)
					print(F"Determinant of {matrix_b} = {determinant(__snake_case						)} \n"						)
					print(F"Inverse of {matrix_d} = {inverse(__snake_case						)}\n"						)


if __name__ == "__main__":
		import doctest

		doctest.testmod()
		main()






