from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


__SCREAMING_SNAKE_CASE						:    int     = {
    'configuration_dpr': ['DPR_PRETRAINED_CONFIG_ARCHIVE_MAP', 'DPRConfig'],
    'tokenization_dpr': [
        'DPRContextEncoderTokenizer',
        'DPRQuestionEncoderTokenizer',
        'DPRReaderOutput',
        'DPRReaderTokenizer',
    ],
}


try:
				if not is_tokenizers_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				__SCREAMING_SNAKE_CASE						:    int     = [
				    'DPRContextEncoderTokenizerFast',
				    'DPRQuestionEncoderTokenizerFast',
				    'DPRReaderTokenizerFast',
				]

try:
				if not is_torch_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				__SCREAMING_SNAKE_CASE						:    List[str]     = [
				    'DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST',
				    'DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST',
				    'DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST',
				    'DPRContextEncoder',
				    'DPRPretrainedContextEncoder',
				    'DPRPreTrainedModel',
				    'DPRPretrainedQuestionEncoder',
				    'DPRPretrainedReader',
				    'DPRQuestionEncoder',
				    'DPRReader',
				]

try:
				if not is_tf_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				__SCREAMING_SNAKE_CASE						:    List[str]     = [
				    'TF_DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST',
				    'TF_DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST',
				    'TF_DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST',
				    'TFDPRContextEncoder',
				    'TFDPRPretrainedContextEncoder',
				    'TFDPRPretrainedQuestionEncoder',
				    'TFDPRPretrainedReader',
				    'TFDPRQuestionEncoder',
				    'TFDPRReader',
				]


if TYPE_CHECKING:
				from .configuration_dpr import DPR_PRETRAINED_CONFIG_ARCHIVE_MAP, DPRConfig
				from .tokenization_dpr import (
				    DPRContextEncoderTokenizer,
				    DPRQuestionEncoderTokenizer,
				    DPRReaderOutput,
				    DPRReaderTokenizer,
				)

				try:
								if not is_tokenizers_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .tokenization_dpr_fast import (
								    DPRContextEncoderTokenizerFast,
								    DPRQuestionEncoderTokenizerFast,
								    DPRReaderTokenizerFast,
								)

				try:
								if not is_torch_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_dpr import (
								    DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST,
								    DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST,
								    DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST,
								    DPRContextEncoder,
								    DPRPretrainedContextEncoder,
								    DPRPreTrainedModel,
								    DPRPretrainedQuestionEncoder,
								    DPRPretrainedReader,
								    DPRQuestionEncoder,
								    DPRReader,
								)

				try:
								if not is_tf_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_tf_dpr import (
								    TF_DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST,
								    TF_DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST,
								    TF_DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST,
								    TFDPRContextEncoder,
								    TFDPRPretrainedContextEncoder,
								    TFDPRPretrainedQuestionEncoder,
								    TFDPRPretrainedReader,
								    TFDPRQuestionEncoder,
								    TFDPRReader,
								)

else:
				import sys

				__SCREAMING_SNAKE_CASE						:    str     = _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)



"""simple docstring"""


import warnings
from contextlib import contextmanager

from ...processing_utils import ProcessorMixin
class snake_case					(     _UpperCamelCase):
		__UpperCamelCase							=	'AutoFeatureExtractor'
		__UpperCamelCase							=	'Speech2Text2Tokenizer'







		def __init__(    self					:				int			,      a__					:				Tuple			,      a__					:				Optional[Any]						)				->  str:





						'''simple docstring'''







						super().__init__(a__			,      a__						)
						_A         =	self.feature_extractor
						_A         =	False







		def __call__(    self					:				Optional[int]			,      *a__					:				List[str]			,      **a__					:				Any						)				->  List[Any]:





						'''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."						)
										_A         =	kwargs.pop("raw_speech"						)
						else:
										_A         =	kwargs.pop("audio"			,      a__						)
						_A         =	kwargs.pop("sampling_rate"			,      a__						)
						_A         =	kwargs.pop("text"			,      a__						)
						if len(a__						) > 0:
										_A         =	args[0]
										_A         =	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         =	self.feature_extractor(a__			,      *a__			,      sampling_rate=a__			,      **a__						)
						if text is not None:
										_A         =	self.tokenizer(a__			,      **a__						)

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







		def        a_       (    self					:				List[Any]			,      *a__					:				Tuple			,      **a__					:				List[Any]						)				->  List[Any]:





						'''simple docstring'''







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







		def        a_       (    self					:				Any			,      *a__					:				Dict			,      **a__					:				Tuple						)				->  Union[str, Any]:





						'''simple docstring'''







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







		@contextmanager
		def        a_       (    self					:				Optional[int]						)				->  Optional[int]:





						'''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."						)
						_A         =	True
						_A         =	self.tokenizer
						yield
						_A         =	self.feature_extractor
						_A         =	False