


import unittest

from huggingface_hub import hf_hub_download

from transformers import MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING, VideoMAEFeatureExtractor
from transformers.pipelines import VideoClassificationPipeline, pipeline
from transformers.testing_utils import (
    is_pipeline_test,
    nested_simplify,
    require_decord,
    require_tf,
    require_torch,
    require_torch_or_tf,
    require_vision,
)

from .test_pipelines_common import ANY
@is_pipeline_test
@require_torch_or_tf
@require_vision
@require_decord
class 		__magic_name__						(unittest.TestCase				):





     '''simple docstring'''



     __lowercase				:							Tuple	   =       MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING

     def 	SCREAMING_SNAKE_CASE__						(					self:Optional[Any]     ,		_a:int     ,		_a:str     ,		_a:Optional[Any]   ):
       snake_case__						= hf_hub_download(
           repo_id='''nateraw/video-demo'''     ,		filename='''archery.mp4'''     ,		repo_type='''dataset'''   )
       snake_case__						= VideoClassificationPipeline(model=_a     ,		image_processor=_a     ,		top_k=2   )
       snake_case__						= [
           example_video_filepath,
           '''https://huggingface.co/datasets/nateraw/video-demo/resolve/main/archery.mp4''',
       ]
       return video_classifier, examples

     def 	SCREAMING_SNAKE_CASE__						(					self:List[Any]     ,		_a:Optional[Any]     ,		_a:Optional[Any]   ):
       for example in examples:
         snake_case__						= video_classifier(_a   )

         self.assertEqual(
             _a     ,		[
                 {'''score''': ANY(_a   ), '''label''': ANY(_a   )},
                 {'''score''': ANY(_a   ), '''label''': ANY(_a   )},
             ]     ,		)

     @require_torch
     def 	SCREAMING_SNAKE_CASE__						(					self:Union[str, Any]   ):
       snake_case__						= '''hf-internal-testing/tiny-random-VideoMAEForVideoClassification'''
       snake_case__						= VideoMAEFeatureExtractor(
           size={'''shortest_edge''': 10}     ,		crop_size={'''height''': 10, '''width''': 10}   )
       snake_case__						= pipeline(
           '''video-classification'''     ,		model=_a     ,		feature_extractor=_a     ,		frame_sampling_rate=4   )

       snake_case__						= hf_hub_download(repo_id='''nateraw/video-demo'''     ,		filename='''archery.mp4'''     ,		repo_type='''dataset'''   )
       snake_case__						= video_classifier(_a     ,		top_k=2   )
       self.assertEqual(
           nested_simplify(_a     ,		decimals=4   )     ,		[{'''score''': 0.5199, '''label''': '''LABEL_0'''}, {'''score''': 0.4801, '''label''': '''LABEL_1'''}]     ,		)

       snake_case__						= video_classifier(
           [
               video_file_path,
               video_file_path,
           ]     ,		top_k=2     ,		)
       self.assertEqual(
           nested_simplify(_a     ,		decimals=4   )     ,		[
               [{'''score''': 0.5199, '''label''': '''LABEL_0'''}, {'''score''': 0.4801, '''label''': '''LABEL_1'''}],
               [{'''score''': 0.5199, '''label''': '''LABEL_0'''}, {'''score''': 0.4801, '''label''': '''LABEL_1'''}],
           ]     ,		)







     @require_tf
     def 	SCREAMING_SNAKE_CASE__						(					self:Optional[int]   ):
       pass








'''simple docstring'''






from typing import TYPE_CHECKING

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


A__							:  int    ={
    '''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:
      A__							:  str    =[
          '''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:
      A__							:  Union[str, Any]    =[
          '''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:
      A__							:  List[str]    =[
          '''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

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






