

import warnings
from contextlib import contextmanager

from ....processing_utils import ProcessorMixin



class 					_a		(__magic_name__       ):


					'''simple docstring'''






					UpperCAmelCase__:     str													= '''MCTCTFeatureExtractor'''
					UpperCAmelCase__:     Any													= '''AutoTokenizer'''






					def __init__(				self					, A__					, A__    ):
						super().__init__(A__					, A__    )
						A__							:					str       =	self.feature_extractor
						A__							:					Optional[Any]       =	False






					def __call__(				self					, *A__					, **A__    ):
						# For backward compatibility
						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."""    )
							A__							:					int       =	kwargs.pop("""raw_speech"""    )
						else:
							A__							:					Union[str, Any]       =	kwargs.pop("""audio"""					, A__    )
						A__							:					Dict       =	kwargs.pop("""sampling_rate"""					, A__    )
						A__							:					Union[str, Any]       =	kwargs.pop("""text"""					, A__    )
						if len(A__    ) > 0:
							A__							:					List[str]       =	args[0]
							A__							:					Optional[int]       =	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:
							A__							:					List[Any]       =	self.feature_extractor(A__					, *A__					, sampling_rate=A__					, **A__    )
						if text is not None:
							A__							:					Optional[Any]       =	self.tokenizer(A__					, **A__    )

						if text is None:
							return inputs
						elif audio is None:
							return encodings
						else:
							A__							:					Optional[int]       =	encodings["""input_ids"""]
							return inputs






					def 						__A    (				self					, *A__					, **A__    ):
						return self.tokenizer.batch_decode(*A__					, **A__    )






					def 						__A    (				self					, *A__					, **A__    ):
						# For backward compatibility
						if self._in_target_context_manager:
							return self.current_processor.pad(*A__					, **A__    )

						A__							:					List[str]       =	kwargs.pop("""input_features"""					, A__    )
						A__							:					Union[str, Any]       =	kwargs.pop("""labels"""					, A__    )
						if len(A__    ) > 0:
							A__							:					int       =	args[0]
							A__							:					Any       =	args[1:]

						if input_features is not None:
							A__							:					Optional[int]       =	self.feature_extractor.pad(A__					, *A__					, **A__    )
						if labels is not None:
							A__							:					Optional[Any]       =	self.tokenizer.pad(A__					, **A__    )

						if labels is None:
							return input_features
						elif input_features is None:
							return labels
						else:
							A__							:					Dict       =	labels["""input_ids"""]
							return input_features






					def 						__A    (				self					, *A__					, **A__    ):
						return self.tokenizer.decode(*A__					, **A__    )






					@contextmanager
					def 						__A    (				self    ):
						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."""    )
						A__							:					Optional[Any]       =	True
						A__							:					Union[str, Any]       =	self.tokenizer
						yield
						A__							:					Optional[Any]       =	self.feature_extractor
						A__							:					Optional[Any]       =	False






def 		UpperCamelCase      (lowercase_:				int      )  ->   int:
	if not isinstance(lowercase_					,   lowercase_      ):
		raise TypeError("""Input value must be an 'int' type"""      )

	A__							:					int       =	0
	while number:
		position += 1
		number >>= 1

	return position


if __name__ == "__main__":
	import doctest

	doctest.testmod()



