




"""simple docstring"""




from ...processing_utils import ProcessorMixin

class   UpperCAmelCase_    (			snake_case		):
		UpperCamelCase							="WhisperFeatureExtractor"
		UpperCamelCase							="WhisperTokenizer"
		def __init__(						self				,						UpperCamelCase_				,						UpperCamelCase_       )						->       Dict:
					super().__init__(UpperCamelCase_				,						UpperCamelCase_       )
					__lowercase			:  Union[str, Any]								=       self.feature_extractor
					__lowercase			:  Tuple								=       False
		def 	_lowerCamelCase							(						self				,						UpperCamelCase_=None				,						UpperCamelCase_=None				,						UpperCamelCase_=True       )						->       Any:
					return self.tokenizer.get_decoder_prompt_ids(task=UpperCamelCase_				,						language=UpperCamelCase_				,						no_timestamps=UpperCamelCase_       )
		def __call__(						self				,						*UpperCamelCase_				,						**UpperCamelCase_       )						->       Optional[int]:
					# For backward compatibility
					if self._in_target_context_manager:
								return self.current_processor(*UpperCamelCase_				,						**UpperCamelCase_       )

					__lowercase			:  Optional[int]								=       kwargs.pop('''audio'''				,						UpperCamelCase_       )
					__lowercase			:  Optional[Any]								=       kwargs.pop('''sampling_rate'''				,						UpperCamelCase_       )
					__lowercase			:  str								=       kwargs.pop('''text'''				,						UpperCamelCase_       )
					if len(UpperCamelCase_       ) > 0:
								__lowercase			:  Union[str, Any]								=       args[0]
								__lowercase			:  List[str]								=       args[1:]

					if audio is None and text is None:
								raise ValueError('''You need to specify either an `audio` or `text` input to process.'''       )

					if audio is not None:
								__lowercase			:  Tuple								=       self.feature_extractor(UpperCamelCase_				,						*UpperCamelCase_				,						sampling_rate=UpperCamelCase_				,						**UpperCamelCase_       )
					if text is not None:
								__lowercase			:  List[Any]								=       self.tokenizer(UpperCamelCase_				,						**UpperCamelCase_       )

					if text is None:
								return inputs

					elif audio is None:
								return encodings
					else:
								__lowercase			:  int								=       encodings['''input_ids''']
								return inputs
		def 	_lowerCamelCase							(						self				,						*UpperCamelCase_				,						**UpperCamelCase_       )						->       List[Any]:
					return self.tokenizer.batch_decode(*UpperCamelCase_				,						**UpperCamelCase_       )
		def 	_lowerCamelCase							(						self				,						*UpperCamelCase_				,						**UpperCamelCase_       )						->       List[Any]:
					return self.tokenizer.decode(*UpperCamelCase_				,						**UpperCamelCase_       )
		def 	_lowerCamelCase							(						self				,						UpperCamelCase_				,						UpperCamelCase_="np"       )						->       int:
					return self.tokenizer.get_prompt_ids(UpperCamelCase_				,						return_tensors=UpperCamelCase_       )






'''simple docstring'''





# tests directory-specific settings - this file is run automatically
# by pytest before any tests are run

import doctest
import sys
import warnings
from os.path import abspath, dirname, join

import _pytest

from transformers.testing_utils import HfDoctestModule, HfDocTestParser


# allow having multiple repository checkouts and not needing to remember to rerun
# 'pip install -e .[dev]' when switching between checkouts and running tests.
UpperCamelCase_    						=       abspath(join(dirname(__file__), """src"""))
sys.path.insert(1, git_repo_path)

# silence FutureWarning warnings in tests since often we can't act on them until
# they become normal warnings - i.e. the tests still need to test the current functionality
warnings.simplefilter(action="""ignore""", category=FutureWarning)






def 				_lowerCAmelCase			(   __magic_name__						:     int						)				->  Tuple:
						config.addinivalue_line(
						    '''markers'''   , '''is_pt_tf_cross_test: mark test to run only when PT and TF interactions are tested'''						)
						config.addinivalue_line(
						    '''markers'''   , '''is_pt_flax_cross_test: mark test to run only when PT and FLAX interactions are tested'''						)
						config.addinivalue_line('''markers'''   , '''is_pipeline_test: mark test to run only when pipelines are tested'''						)
						config.addinivalue_line('''markers'''   , '''is_staging_test: mark test to run only in the staging environment'''						)
						config.addinivalue_line('''markers'''   , '''accelerate_tests: mark test that require accelerate'''						)
						config.addinivalue_line('''markers'''   , '''tool_tests: mark the tool tests that are run on their specific schedule'''						)






def 				_lowerCAmelCase			(   __magic_name__						:     int						)				->  Any:
						from transformers.testing_utils import pytest_addoption_shared

						pytest_addoption_shared(__magic_name__						)






def 				_lowerCAmelCase			(   __magic_name__						:     Any						)				->  Any:
						from transformers.testing_utils import pytest_terminal_summary_main

						lowercase :							Optional[Any]    		=terminalreporter.config.getoption('''--make-reports'''						)
						if make_reports:
												pytest_terminal_summary_main(__magic_name__   , id=__magic_name__						)






def 				_lowerCAmelCase			(   __magic_name__						:     Tuple   , __magic_name__						:     Union[str, Any]						)				->  List[str]:
						# If no tests are collected, pytest exists with code 5, which makes the CI fail.
						if exitstatus == 5:
												lowercase :							Optional[int]    		=0


# Doctest custom flag to ignore output.
UpperCamelCase_    						=       doctest.register_optionflag("""IGNORE_RESULT""")

UpperCamelCase_    						=       doctest.OutputChecker





class 		__SCREAMING_SNAKE_CASE							(			lowercase__      ):







				def  lowerCamelCase_	(       self     :		Optional[Any]		,					UpperCAmelCase__     :		Union[str, Any]		,					UpperCAmelCase__     :		List[Any]		,					UpperCAmelCase__     :		List[Any]   ):
										'''simple docstring'''
										if IGNORE_RESULT & optionflags:
																return True
										return OutputChecker.check_output(self		,					UpperCAmelCase__		,					UpperCAmelCase__		,					UpperCAmelCase__   )



UpperCamelCase_    						=       CustomOutputChecker
UpperCamelCase_    						=       HfDoctestModule







UpperCamelCase_    						=       HfDocTestParser





