






from typing import TYPE_CHECKING

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


__UpperCAmelCase     							=						{
    '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:
		__UpperCAmelCase     							=						[
		    '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:
		__UpperCAmelCase     							=						[
		    '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:
		__UpperCAmelCase     							=						[
		    '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

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














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   lowerCamelCase				(unittest.TestCase      ):







		'''simple docstring'''



		_snake_case   :   List[str]							=  MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING



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



		def  __UpperCAmelCase      (							self    ,		_UpperCamelCase    ,		_UpperCamelCase       )     ->							Dict:
							for example in examples:
												UpperCAmelCase_   :				str						=						video_classifier(_UpperCamelCase       )

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



		@require_torch
		def  __UpperCAmelCase      (							self       )     ->							List[Any]:
							UpperCAmelCase_   :				str						=						'hf-internal-testing/tiny-random-VideoMAEForVideoClassification'
							UpperCAmelCase_   :				Optional[Any]						=						VideoMAEFeatureExtractor(
							    size={'shortest_edge': 1_0}    ,		crop_size={'height': 1_0, 'width': 1_0}       )
							UpperCAmelCase_   :				str						=						pipeline(
							    'video-classification'    ,		model=_UpperCamelCase    ,		feature_extractor=_UpperCamelCase    ,		frame_sampling_rate=4       )

							UpperCAmelCase_   :				Any						=						hf_hub_download(repo_id='nateraw/video-demo'    ,		filename='archery.mp4'    ,		repo_type='dataset'       )
							UpperCAmelCase_   :				List[str]						=						video_classifier(_UpperCamelCase    ,		top_k=2       )
							self.assertEqual(
							    nested_simplify(_UpperCamelCase    ,		decimals=4       )    ,		[{'score': 0.51_99, 'label': 'LABEL_0'}, {'score': 0.48_01, 'label': 'LABEL_1'}]    ,		)

							UpperCAmelCase_   :				Tuple						=						video_classifier(
							    [
							        video_file_path,
							        video_file_path,
							    ]    ,		top_k=2    ,		)
							self.assertEqual(
							    nested_simplify(_UpperCamelCase    ,		decimals=4       )    ,		[
							        [{'score': 0.51_99, 'label': 'LABEL_0'}, {'score': 0.48_01, 'label': 'LABEL_1'}],
							        [{'score': 0.51_99, 'label': 'LABEL_0'}, {'score': 0.48_01, 'label': 'LABEL_1'}],
							    ]    ,		)



		@require_tf
		def  __UpperCAmelCase      (							self       )     ->							Dict:
							pass






