




"""simple docstring"""
from typing import TYPE_CHECKING

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


a_				:    Union[str, Any]										=     {
    "configuration_convnext": ["CONVNEXT_PRETRAINED_CONFIG_ARCHIVE_MAP", "ConvNextConfig", "ConvNextOnnxConfig"]
}

try:
					if not is_vision_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					a_				:    List[str]										=     ["ConvNextFeatureExtractor"]
					a_				:    Optional[Any]										=     ["ConvNextImageProcessor"]

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					a_				:    Any										=     [
					    "CONVNEXT_PRETRAINED_MODEL_ARCHIVE_LIST",
					    "ConvNextForImageClassification",
					    "ConvNextModel",
					    "ConvNextPreTrainedModel",
					    "ConvNextBackbone",
					]

try:
					if not is_tf_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					a_				:    str										=     [
					    "TFConvNextForImageClassification",
					    "TFConvNextModel",
					    "TFConvNextPreTrainedModel",
					]

if TYPE_CHECKING:
					from .configuration_convnext import CONVNEXT_PRETRAINED_CONFIG_ARCHIVE_MAP, ConvNextConfig, ConvNextOnnxConfig

					try:
										if not is_vision_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .feature_extraction_convnext import ConvNextFeatureExtractor
										from .image_processing_convnext import ConvNextImageProcessor

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_convnext import (
										    CONVNEXT_PRETRAINED_MODEL_ARCHIVE_LIST,
										    ConvNextBackbone,
										    ConvNextForImageClassification,
										    ConvNextModel,
										    ConvNextPreTrainedModel,
										)

					try:
										if not is_tf_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_tf_convnext import TFConvNextForImageClassification, TFConvNextModel, TFConvNextPreTrainedModel


else:
					import sys

					a_				:    int										=     _LazyModule(__name__, globals()['''__file__'''], _import_structure)









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

from ...processing_utils import ProcessorMixin

class __lowercase(      lowercase__				):




					'''simple docstring'''


					__a						:						List[str]     		= 'Speech2TextFeatureExtractor'
					__a						:						Optional[int]     		= 'Speech2TextTokenizer'
					def __init__(    self						,	__a						,	__a     ):
								super().__init__(__a						,	__a     )
								__lowerCamelCase					:	Union[str, Any]	       =				self.feature_extractor
								__lowerCamelCase					:	List[str]	       =				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.'     )
											__lowerCamelCase					:	str	       =				kwargs.pop('raw_speech'     )
								else:
											__lowerCamelCase					:	Optional[Any]	       =				kwargs.pop('audio'						,	__a     )
								__lowerCamelCase					:	Optional[Any]	       =				kwargs.pop('sampling_rate'						,	__a     )
								__lowerCamelCase					:	Optional[int]	       =				kwargs.pop('text'						,	__a     )
								if len(__a     ) > 0:
											__lowerCamelCase					:	Optional[int]	       =				args[0]
											__lowerCamelCase					:	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:
											__lowerCamelCase					:	Dict	       =				self.feature_extractor(__a						,	*__a						,	sampling_rate=__a						,	**__a     )
								if text is not None:
											__lowerCamelCase					:	Optional[int]	       =				self.tokenizer(__a						,	**__a     )

								if text is None:
											return inputs
								elif audio is None:
											return encodings
								else:
											__lowerCamelCase					:	Any	       =				encodings['input_ids']
											return inputs
					def     snake_case_				(    self						,	*__a						,	**__a     ):
								return self.tokenizer.batch_decode(*__a						,	**__a     )
					def     snake_case_				(    self						,	*__a						,	**__a     ):
								return self.tokenizer.decode(*__a						,	**__a     )





					@contextmanager
					def     snake_case_				(    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.'     )
								__lowerCamelCase					:	int	       =				True
								__lowerCamelCase					:	Union[str, Any]	       =				self.tokenizer
								yield
								__lowerCamelCase					:	Tuple	       =				self.feature_extractor
								__lowerCamelCase					:	List[str]	       =				False



