






'''simple docstring'''







from typing import TYPE_CHECKING

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


SCREAMING_SNAKE_CASE_      =			{
    'configuration_wav2vec2': ['WAV_2_VEC_2_PRETRAINED_CONFIG_ARCHIVE_MAP', 'Wav2Vec2Config'],
    'feature_extraction_wav2vec2': ['Wav2Vec2FeatureExtractor'],
    'processing_wav2vec2': ['Wav2Vec2Processor'],
    'tokenization_wav2vec2': ['Wav2Vec2CTCTokenizer', 'Wav2Vec2Tokenizer'],
}


try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 SCREAMING_SNAKE_CASE_      =			[
     'WAV_2_VEC_2_PRETRAINED_MODEL_ARCHIVE_LIST',
     'Wav2Vec2ForAudioFrameClassification',
     'Wav2Vec2ForCTC',
     'Wav2Vec2ForMaskedLM',
     'Wav2Vec2ForPreTraining',
     'Wav2Vec2ForSequenceClassification',
     'Wav2Vec2ForXVector',
     'Wav2Vec2Model',
     'Wav2Vec2PreTrainedModel',
 ]

try:
 if not is_tf_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 SCREAMING_SNAKE_CASE_      =			[
     'TF_WAV_2_VEC_2_PRETRAINED_MODEL_ARCHIVE_LIST',
     'TFWav2Vec2ForCTC',
     'TFWav2Vec2Model',
     'TFWav2Vec2PreTrainedModel',
     'TFWav2Vec2ForSequenceClassification',
 ]

try:
 if not is_flax_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 SCREAMING_SNAKE_CASE_      =			[
     'FlaxWav2Vec2ForCTC',
     'FlaxWav2Vec2ForPreTraining',
     'FlaxWav2Vec2Model',
     'FlaxWav2Vec2PreTrainedModel',
 ]


if TYPE_CHECKING:
 from .configuration_wavaveca import WAV_2_VEC_2_PRETRAINED_CONFIG_ARCHIVE_MAP, WavaVecaConfig
 from .feature_extraction_wavaveca import WavaVecaFeatureExtractor
 from .processing_wavaveca import WavaVecaProcessor
 from .tokenization_wavaveca import WavaVecaCTCTokenizer, WavaVecaTokenizer

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_wavaveca import (
      WAV_2_VEC_2_PRETRAINED_MODEL_ARCHIVE_LIST,
      WavaVecaForAudioFrameClassification,
      WavaVecaForCTC,
      WavaVecaForMaskedLM,
      WavaVecaForPreTraining,
      WavaVecaForSequenceClassification,
      WavaVecaForXVector,
      WavaVecaModel,
      WavaVecaPreTrainedModel,
  )

 try:
  if not is_tf_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_tf_wavaveca import (
      TF_WAV_2_VEC_2_PRETRAINED_MODEL_ARCHIVE_LIST,
      TFWavaVecaForCTC,
      TFWavaVecaForSequenceClassification,
      TFWavaVecaModel,
      TFWavaVecaPreTrainedModel,
  )

 try:
  if not is_flax_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_tf_wavaveca import (
      FlaxWavaVecaForCTC,
      FlaxWavaVecaForPreTraining,
      FlaxWavaVecaModel,
      FlaxWavaVecaPreTrainedModel,
  )


else:
 import sys

 SCREAMING_SNAKE_CASE_      =			_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)










'''simple docstring'''







from ...processing_utils import ProcessorMixin


class  lowerCAmelCase_						(       snake_case__      ):





  """simple docstring"""



  a_       :Dict												=["""image_processor""", """feature_extractor"""]
  a_       :str												="""TvltImageProcessor"""
  a_       :str												="""TvltFeatureExtractor"""

  def __init__(					self     :							Dict				,							SCREAMING_SNAKE_CASE__     :							Optional[Any]				,							SCREAMING_SNAKE_CASE__     :							Union[str, Any]						):





       '''simple docstring'''

       super().__init__(image_processor=SCREAMING_SNAKE_CASE__				,							feature_extractor=SCREAMING_SNAKE_CASE__						)

       __a       =   image_processor
       __a       =   feature_extractor

  def __call__(					self     :							Union[str, Any]				,							SCREAMING_SNAKE_CASE__     :							str=None				,							SCREAMING_SNAKE_CASE__     :							Optional[Any]=None				,							SCREAMING_SNAKE_CASE__     :							Tuple=None				,							SCREAMING_SNAKE_CASE__     :							List[Any]=None				,							SCREAMING_SNAKE_CASE__     :							Any=False				,							SCREAMING_SNAKE_CASE__     :							List[str]=False				,							*SCREAMING_SNAKE_CASE__     :							str				,							**SCREAMING_SNAKE_CASE__     :							Optional[int]				,							):





       '''simple docstring'''

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

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

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


  @property
  def __a						(					self     :							List[str]						):





       '''simple docstring'''

       __a       =   self.image_processor.model_input_names
       __a       =   self.feature_extractor.model_input_names
       return list(dict.fromkeys(image_processor_input_names + feature_extractor_input_names						)						)






