






from ...processing_utils import ProcessorMixin
class 		SCREAMING_SNAKE_CASE__	(  UpperCAmelCase     ):

  '''simple docstring'''







  _lowerCamelCase    =  ['''image_processor''', '''feature_extractor''']
  _lowerCamelCase    =  '''TvltImageProcessor'''
  _lowerCamelCase    =  '''TvltFeatureExtractor'''


  def __init__(      self		:			int       ,				lowerCamelCase		:			str       ,				lowerCamelCase		:			int							)						->	str:


         """simple docstring"""
         super().__init__(image_processor=lowerCamelCase       ,				feature_extractor=lowerCamelCase							)

         _UpperCAmelCase							=    image_processor
         _UpperCAmelCase							=    feature_extractor


  def __call__(      self		:			Any       ,				lowerCamelCase		:			Optional[Any]=None       ,				lowerCamelCase		:			List[Any]=None       ,				lowerCamelCase		:			str=None       ,				lowerCamelCase		:			Optional[int]=None       ,				lowerCamelCase		:			str=False       ,				lowerCamelCase		:			Any=False       ,				*lowerCamelCase		:			Any       ,				**lowerCamelCase		:			Optional[int]       ,				)						->	List[Any]:


         """simple docstring"""

         if images is None and audio is None:
                raise ValueError("""You need to specify either an `images` or `audio` input to process."""							)

         _UpperCAmelCase							=    None
         if images is not None:
                _UpperCAmelCase							=    self.image_processor(lowerCamelCase       ,				mask_pixel=lowerCamelCase       ,				*lowerCamelCase       ,				**lowerCamelCase							)
         if images_mixed is not None:
                _UpperCAmelCase							=    self.image_processor(lowerCamelCase       ,				is_mixed=lowerCamelCase       ,				*lowerCamelCase       ,				**lowerCamelCase							)
         if audio is not None:
                _UpperCAmelCase							=    self.feature_extractor(
                    lowerCamelCase       ,				*lowerCamelCase       ,				sampling_rate=lowerCamelCase       ,				mask_audio=lowerCamelCase       ,				**lowerCamelCase							)

         _UpperCAmelCase							=    {}
         if audio is not None:
                output_dict.update(lowerCamelCase							)
         if images is not None:
                output_dict.update(lowerCamelCase							)
         if images_mixed_dict is not None:
                output_dict.update(lowerCamelCase							)
         return output_dict





  @property
  def  lowerCamelCase       (      self		:			Dict							)						->	Any:


         """simple docstring"""
         _UpperCAmelCase							=    self.image_processor.model_input_names
         _UpperCAmelCase							=    self.feature_extractor.model_input_names
         return list(dict.fromkeys(image_processor_input_names + feature_extractor_input_names							)							)







from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available


__a:     int   					=					{
    '''configuration_mvp''': ['''MVP_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''MvpConfig''', '''MvpOnnxConfig'''],
    '''tokenization_mvp''': ['''MvpTokenizer'''],
}

try:
  if not is_tokenizers_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  __a:     Dict   					=					['''MvpTokenizerFast''']

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  __a:     Tuple   					=					[
      '''MVP_PRETRAINED_MODEL_ARCHIVE_LIST''',
      '''MvpForCausalLM''',
      '''MvpForConditionalGeneration''',
      '''MvpForQuestionAnswering''',
      '''MvpForSequenceClassification''',
      '''MvpModel''',
      '''MvpPreTrainedModel''',
  ]

if TYPE_CHECKING:
  from .configuration_mvp import MVP_PRETRAINED_CONFIG_ARCHIVE_MAP, MvpConfig, MvpOnnxConfig
  from .tokenization_mvp import MvpTokenizer

  try:
    if not is_tokenizers_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .tokenization_mvp_fast import MvpTokenizerFast

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_mvp import (
        MVP_PRETRAINED_MODEL_ARCHIVE_LIST,
        MvpForCausalLM,
        MvpForConditionalGeneration,
        MvpForQuestionAnswering,
        MvpForSequenceClassification,
        MvpModel,
        MvpPreTrainedModel,
    )

else:
  import sys

  __a:     Optional[Any]   					=					_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)