
"""simple docstring"""





from typing import TYPE_CHECKING

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


_a								=						{
    """configuration_mega""": ["""MEGA_PRETRAINED_CONFIG_ARCHIVE_MAP""", """MegaConfig""", """MegaOnnxConfig"""],
}

try:
				if not is_torch_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				_a								=						[
				    """MEGA_PRETRAINED_MODEL_ARCHIVE_LIST""",
				    """MegaForCausalLM""",
				    """MegaForMaskedLM""",
				    """MegaForMultipleChoice""",
				    """MegaForQuestionAnswering""",
				    """MegaForSequenceClassification""",
				    """MegaForTokenClassification""",
				    """MegaModel""",
				    """MegaPreTrainedModel""",
				]

if TYPE_CHECKING:
				from .configuration_mega import MEGA_PRETRAINED_CONFIG_ARCHIVE_MAP, MegaConfig, MegaOnnxConfig

				try:
								if not is_torch_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_mega import (
								    MEGA_PRETRAINED_MODEL_ARCHIVE_LIST,
								    MegaForCausalLM,
								    MegaForMaskedLM,
								    MegaForMultipleChoice,
								    MegaForQuestionAnswering,
								    MegaForSequenceClassification,
								    MegaForTokenClassification,
								    MegaModel,
								    MegaPreTrainedModel,
								)

else:
				import sys

				_a								=						_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)








"""simple docstring"""





import warnings

from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding






class        _UpperCAmelCase(       lowerCamelCase      ):
		lowercase__         = ['image_processor', 'tokenizer']
		lowercase__         = 'ViTImageProcessor'
		lowercase__         = ('CLIPTokenizer', 'CLIPTokenizerFast')



		def __init__(   self							,						__a=None							,						__a=None							,						**__a)			->			Union[str, Any]:






							'''simple docstring'''
							_UpperCamelCase									=    None
							if "feature_extractor" in kwargs:
												warnings.warn(
												    '''The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`'''
												    ''' instead.'''							,						__a							,						)
												_UpperCamelCase									=    kwargs.pop('''feature_extractor''')

							_UpperCamelCase									=    image_processor if image_processor is not None else feature_extractor
							if image_processor is None:
												raise ValueError('''You need to specify an `image_processor`.''')
							if tokenizer is None:
												raise ValueError('''You need to specify a `tokenizer`.''')

							super().__init__(__a							,						__a)



		def __call__(   self							,						__a=None							,						__a=None							,						__a=None							,						__a=None							,						**__a)			->			Tuple:






							'''simple docstring'''
							if text is None and visual_prompt is None and images is None:
												raise ValueError('''You have to specify either text, visual prompt or images.''')

							if text is not None and visual_prompt is not None:
												raise ValueError('''You have to specify exactly one type of prompt. Either text or visual prompt.''')

							if text is not None:
												_UpperCamelCase									=    self.tokenizer(__a							,						return_tensors=__a							,						**__a)

							if visual_prompt is not None:
												_UpperCamelCase									=    self.image_processor(__a							,						return_tensors=__a							,						**__a)

							if images is not None:
												_UpperCamelCase									=    self.image_processor(__a							,						return_tensors=__a							,						**__a)

							if visual_prompt is not None and images is not None:
												_UpperCamelCase									=    {
												    '''pixel_values''': image_features.pixel_values,
												    '''conditional_pixel_values''': prompt_features.pixel_values,
												}
												return encoding
							elif text is not None and images is not None:
												_UpperCamelCase									=    image_features.pixel_values
												return encoding
							elif text is not None:
												return encoding
							elif visual_prompt is not None:
												_UpperCamelCase									=    {
												    '''conditional_pixel_values''': prompt_features.pixel_values,
												}
												return encoding
							else:
												return BatchEncoding(data=dict(**__a)							,						tensor_type=__a)



		def 		UpperCAmelCase				(   self							,						*__a							,						**__a)			->			Any:






							'''simple docstring'''
							return self.tokenizer.batch_decode(*__a							,						**__a)



		def 		UpperCAmelCase				(   self							,						*__a							,						**__a)			->			List[str]:






							'''simple docstring'''
							return self.tokenizer.decode(*__a							,						**__a)



		@property
		def 		UpperCAmelCase				(   self)			->			List[str]:






							'''simple docstring'''
							warnings.warn(
							    '''`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead.'''							,						__a							,						)
							return self.image_processor_class




		@property
		def 		UpperCAmelCase				(   self)			->			List[str]:






							'''simple docstring'''
							warnings.warn(
							    '''`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead.'''							,						__a							,						)
							return self.image_processor






