





"""simple docstring"""


import copy
import json
import os
import tempfile

from transformers import is_torch_available

from .test_configuration_utils import config_common_kwargs






class 							lowercase__			(   __SCREAMING_SNAKE_CASE	):

			"""simple docstring"""







			def __init__(      self						,   _A						,   _A=None						,   _A=True						,   _A=None						,   **_A    ):






									'''simple docstring'''







									UpperCamelCase				:		Optional[Any]				   =			parent
									UpperCamelCase				:		List[str]				   =			config_class
									UpperCamelCase				:		str				   =			has_text_modality
									UpperCamelCase				:		Optional[Any]				   =			kwargs
									UpperCamelCase				:		Optional[Any]				   =			common_properties







			def   _a      (      self    ):






									'''simple docstring'''







									UpperCamelCase				:		Any				   =			self.config_class(**self.inputs_dict    )
									UpperCamelCase				:		int				   =			(
									    ["""hidden_size""", """num_attention_heads""", """num_hidden_layers"""]
									    if self.common_properties is None
									    else self.common_properties
									)

									# Add common fields for text models
									if self.has_text_modality:
															common_properties.extend(["""vocab_size"""]    )

									# Test that config has the common properties as getters
									for prop in common_properties:
															self.parent.assertTrue(hasattr(_A						,   _A    )						,   msg=f"""`{prop}` does not exist"""    )

									# Test that config has the common properties as setter
									for idx, name in enumerate(_A    ):
															try:
																					setattr(_A						,   _A						,   _A    )
																					self.parent.assertEqual(
																					    getattr(_A						,   _A    )						,   _A						,   msg=f"""`{name} value {idx} expected, but was {getattr(_A						,   _A    )}"""    )
															except NotImplementedError:
																					# Some models might not be able to implement setters for common_properties
																					# In that case, a NotImplementedError is raised
																					pass

        # Test if config class can be called with Config(prop_name=..)
									for idx, name in enumerate(_A    ):
															try:
																					UpperCamelCase				:		Any				   =			self.config_class(**{name: idx}    )
																					self.parent.assertEqual(
																					    getattr(_A						,   _A    )						,   _A						,   msg=f"""`{name} value {idx} expected, but was {getattr(_A						,   _A    )}"""    )
															except NotImplementedError:
																					# Some models might not be able to implement setters for common_properties
																					# In that case, a NotImplementedError is raised
																					pass







			def   _a      (      self    ):






									'''simple docstring'''







									UpperCamelCase				:		Any				   =			self.config_class(**self.inputs_dict    )
									UpperCamelCase				:		Optional[Any]				   =			json.loads(config.to_json_string()    )
									for key, value in self.inputs_dict.items():
															self.parent.assertEqual(obj[key]						,   _A    )







			def   _a      (      self    ):






									'''simple docstring'''







									UpperCamelCase				:		str				   =			self.config_class(**self.inputs_dict    )

									with tempfile.TemporaryDirectory() as tmpdirname:
															UpperCamelCase				:		Any				   =			os.path.join(_A						,   """config.json"""    )
															config_first.to_json_file(_A    )
															UpperCamelCase				:		Optional[int]				   =			self.config_class.from_json_file(_A    )

									self.parent.assertEqual(config_second.to_dict()						,   config_first.to_dict()    )







			def   _a      (      self    ):






									'''simple docstring'''







									UpperCamelCase				:		str				   =			self.config_class(**self.inputs_dict    )

									with tempfile.TemporaryDirectory() as tmpdirname:
															config_first.save_pretrained(_A    )
															UpperCamelCase				:		Optional[int]				   =			self.config_class.from_pretrained(_A    )

									self.parent.assertEqual(config_second.to_dict()						,   config_first.to_dict()    )







			def   _a      (      self    ):






									'''simple docstring'''







									UpperCamelCase				:		str				   =			self.config_class(**self.inputs_dict    )

									UpperCamelCase				:		int				   =			"""test"""
									with tempfile.TemporaryDirectory() as tmpdirname:
															UpperCamelCase				:		Union[str, Any]				   =			os.path.join(_A						,   _A    )
															config_first.save_pretrained(_A    )
															UpperCamelCase				:		str				   =			self.config_class.from_pretrained(_A						,   subfolder=_A    )

									self.parent.assertEqual(config_second.to_dict()						,   config_first.to_dict()    )







			def   _a      (      self    ):






									'''simple docstring'''







									UpperCamelCase				:		Dict				   =			self.config_class(**self.inputs_dict						,   num_labels=5    )
									self.parent.assertEqual(len(config.idalabel    )						,   5    )
									self.parent.assertEqual(len(config.labelaid    )						,   5    )

									UpperCamelCase				:		Tuple				   =			3
									self.parent.assertEqual(len(config.idalabel    )						,   3    )
									self.parent.assertEqual(len(config.labelaid    )						,   3    )







			def   _a      (      self    ):






									'''simple docstring'''







									if self.config_class.is_composition:
															return
									UpperCamelCase				:		str				   =			self.config_class()
									self.parent.assertIsNotNone(_A    )







			def   _a      (      self    ):






									'''simple docstring'''







									UpperCamelCase				:		Optional[int]				   =			copy.deepcopy(_A    )
									UpperCamelCase				:		Dict				   =			self.config_class(**_A    )
									UpperCamelCase				:		List[Any]				   =			[]
									for key, value in config_common_kwargs.items():
															if key == "torch_dtype":
																					if not is_torch_available():
																											continue
																					else:
																											import torch

																											if config.torch_dtype != torch.floataa:
																																	wrong_values.append(("""torch_dtype""", config.torch_dtype, torch.floataa)    )
															elif getattr(_A						,   _A    ) != value:
																					wrong_values.append((key, getattr(_A						,   _A    ), value)    )

									if len(_A    ) > 0:
															UpperCamelCase				:		Dict				   =			"""\n""".join([f"""- {v[0]}: got {v[1]} instead of {v[2]}""" for v in wrong_values]    )
															raise ValueError(f"""The following keys were not properly set in the config:\n{errors}"""    )







			def   _a      (      self    ):






									'''simple docstring'''







									self.create_and_test_config_common_properties()
									self.create_and_test_config_to_json_string()
									self.create_and_test_config_to_json_file()
									self.create_and_test_config_from_and_save_pretrained()
									self.create_and_test_config_from_and_save_pretrained_subfolder()
									self.create_and_test_config_with_num_labels()
									self.check_config_can_be_init_without_params()
									self.check_config_arguments_init()










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        SCREAMING_SNAKE_CASE__					(		unittest.TestCase ):
 __SCREAMING_SNAKE_CASE							=      MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING



 def 							UpperCamelCase     (				self,__lowerCamelCase,__lowerCamelCase,__lowerCamelCase					):
        A__		   =		hf_hub_download(
            repo_id='''nateraw/video-demo''',filename='''archery.mp4''',repo_type='''dataset'''					)
        A__		   =		VideoClassificationPipeline(model=__lowerCamelCase,image_processor=__lowerCamelCase,top_k=2					)
        A__		   =		[
            example_video_filepath,
            '''https://huggingface.co/datasets/nateraw/video-demo/resolve/main/archery.mp4''',
        ]
        return video_classifier, examples



 def 							UpperCamelCase     (				self,__lowerCamelCase,__lowerCamelCase					):
        for example in examples:
               A__		   =		video_classifier(__lowerCamelCase					)

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



 @require_torch
 def 							UpperCamelCase     (				self					):
        A__		   =		'''hf-internal-testing/tiny-random-VideoMAEForVideoClassification'''
        A__		   =		VideoMAEFeatureExtractor(
            size={'''shortest_edge''': 10},crop_size={'''height''': 10, '''width''': 10}					)
        A__		   =		pipeline(
            '''video-classification''',model=__lowerCamelCase,feature_extractor=__lowerCamelCase,frame_sampling_rate=4					)

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

        A__		   =		video_classifier(
            [
                video_file_path,
                video_file_path,
            ],top_k=2,)
        self.assertEqual(
            nested_simplify(__lowerCamelCase,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 							UpperCamelCase     (				self					):
        pass





