


"""simple docstring"""
import warnings
from contextlib import contextmanager

from ...processing_utils import ProcessorMixin



class      _UpperCAmelCase					(				__snake_case							):






		'''simple docstring'''

		lowerCamelCase__           ='AutoFeatureExtractor'
		lowerCamelCase__           ='Speech2Text2Tokenizer'



		def __init__(self							,			a_							,			a_   ):





			'''simple docstring'''

			super().__init__(a_							,			a_   )
			__snake_case      :		List[str]         =							self.feature_extractor
			__snake_case      :		List[Any]         =							False



		def __call__(self							,			*a_							,			**a_   ):





			'''simple docstring'''

			if self._in_target_context_manager:
				return self.current_processor(*a_							,			**a_   )

			if "raw_speech" in kwargs:
				warnings.warn('''Using `raw_speech` as a keyword argument is deprecated. Use `audio` instead.'''   )
				__snake_case      :		List[Any]         =							kwargs.pop('''raw_speech'''   )
			else:
				__snake_case      :		Union[str, Any]         =							kwargs.pop('''audio'''							,			a_   )
			__snake_case      :		int         =							kwargs.pop('''sampling_rate'''							,			a_   )
			__snake_case      :		List[Any]         =							kwargs.pop('''text'''							,			a_   )
			if len(a_   ) > 0:
				__snake_case      :		Optional[Any]         =							args[0]
				__snake_case      :		Dict         =							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:
				__snake_case      :		str         =							self.feature_extractor(a_							,			*a_							,			sampling_rate=a_							,			**a_   )
			if text is not None:
				__snake_case      :		Optional[Any]         =							self.tokenizer(a_							,			**a_   )

			if text is None:
				return inputs
			elif audio is None:
				return encodings
			else:
				__snake_case      :		List[Any]         =							encodings['''input_ids''']
				return inputs



		def 							SCREAMING_SNAKE_CASE    (self							,			*a_							,			**a_   ):





			'''simple docstring'''

			return self.tokenizer.batch_decode(*a_							,			**a_   )



		def 							SCREAMING_SNAKE_CASE    (self							,			*a_							,			**a_   ):





			'''simple docstring'''

			return self.tokenizer.decode(*a_							,			**a_   )



		@contextmanager
		def 							SCREAMING_SNAKE_CASE    (self   ):





			'''simple docstring'''

			warnings.warn(
			    '''`as_target_processor` is deprecated and will be removed in v5 of Transformers. You can process your '''
			    '''labels by using the argument `text` of the regular `__call__` method (either in the same call as '''
			    '''your audio inputs, or in a separate call.'''   )
			__snake_case      :		Dict         =							True
			__snake_case      :		Union[str, Any]         =							self.tokenizer
			yield
			__snake_case      :		str         =							self.feature_extractor
			__snake_case      :		Any         =							False











def        lowerCamelCase_     (     SCREAMING_SNAKE_CASE       ,						SCREAMING_SNAKE_CASE ):
			'''simple docstring'''
			if n == 0:
						return 1

			elif n % 2 == 1:
						return binary_exponentiation(SCREAMING_SNAKE_CASE       ,						n - 1 ) * a

			else:
						SCREAMING_SNAKE_CASE     =       binary_exponentiation(SCREAMING_SNAKE_CASE       ,						n / 2 )
						return b * b


if __name__ == "__main__":
		try:
				__A    :				Tuple    						=	int(input("""Enter Base : """).strip())
				__A    :				Any    						=	int(input("""Enter Power : """).strip())
		except ValueError:
				print("""Invalid literal for integer""")

		__A    :				Union[str, Any]    						=	binary_exponentiation(BASE, POWER)
		print(f'''{BASE}^({POWER}) : {RESULT}''')






