

"""simple docstring"""


import unittest

from transformers import MODEL_FOR_VISUAL_QUESTION_ANSWERING_MAPPING, is_vision_available
from transformers.pipelines import pipeline
from transformers.testing_utils import (
    is_pipeline_test,
    nested_simplify,
    require_tf,
    require_torch,
    require_vision,
    slow,
)

from .test_pipelines_common import ANY


if is_vision_available():
  from PIL import Image
else:

  class    __a							:






       '''simple docstring'''

       @staticmethod
       def     _a	(  *_a		,			**_a     )     ->					int:


             """simple docstring"""


             pass

@is_pipeline_test
@require_torch
@require_vision
class    __a							(unittest.TestCase):






     '''simple docstring'''
     _SCREAMING_SNAKE_CASE  :Union[str, Any]				=       MODEL_FOR_VISUAL_QUESTION_ANSWERING_MAPPING

     def     _a	(  self		,			_a		,			_a		,			_a     )     ->					Any:


           """simple docstring"""


           SCREAMING_SNAKE_CASE__      :					Tuple											=		pipeline("""visual-question-answering"""		,			model="""hf-internal-testing/tiny-vilt-random-vqa"""     )
           SCREAMING_SNAKE_CASE__      :					str											=		[
               {
                   """image""": Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""     ),
                   """question""": """How many cats are there?""",
               },
               {
                   """image""": """./tests/fixtures/tests_samples/COCO/000000039769.png""",
                   """question""": """How many cats are there?""",
               },
           ]
           return vqa_pipeline, examples

     def     _a	(  self		,			_a		,			_a     )     ->					Optional[Any]:


           """simple docstring"""


           SCREAMING_SNAKE_CASE__      :					List[str]											=		vqa_pipeline(__a		,			top_k=1     )
           self.assertEqual(
               __a		,			[
                   [{"""score""": ANY(__a     ), """answer""": ANY(__a     )}],
                   [{"""score""": ANY(__a     ), """answer""": ANY(__a     )}],
               ]		,			)

     @require_torch
     def     _a	(  self     )     ->					List[str]:


           """simple docstring"""


           SCREAMING_SNAKE_CASE__      :					List[Any]											=		pipeline("""visual-question-answering"""		,			model="""hf-internal-testing/tiny-vilt-random-vqa"""     )
           SCREAMING_SNAKE_CASE__      :					Any											=		"""./tests/fixtures/tests_samples/COCO/000000039769.png"""
           SCREAMING_SNAKE_CASE__      :					Dict											=		"""How many cats are there?"""

           SCREAMING_SNAKE_CASE__      :					Optional[int]											=		vqa_pipeline(image=__a		,			question="""How many cats are there?"""		,			top_k=2     )
           self.assertEqual(
               __a		,			[{"""score""": ANY(__a     ), """answer""": ANY(__a     )}, {"""score""": ANY(__a     ), """answer""": ANY(__a     )}]     )

           SCREAMING_SNAKE_CASE__      :					int											=		vqa_pipeline({"""image""": image, """question""": question}		,			top_k=2     )
           self.assertEqual(
               __a		,			[{"""score""": ANY(__a     ), """answer""": ANY(__a     )}, {"""score""": ANY(__a     ), """answer""": ANY(__a     )}]     )

     @slow
     @require_torch
     def     _a	(  self     )     ->					Tuple:


           """simple docstring"""


           SCREAMING_SNAKE_CASE__      :					List[Any]											=		pipeline("""visual-question-answering"""		,			model="""dandelin/vilt-b32-finetuned-vqa"""     )
           SCREAMING_SNAKE_CASE__      :					int											=		"""./tests/fixtures/tests_samples/COCO/000000039769.png"""
           SCREAMING_SNAKE_CASE__      :					Optional[Any]											=		"""How many cats are there?"""

           SCREAMING_SNAKE_CASE__      :					Any											=		vqa_pipeline(image=__a		,			question=__a		,			top_k=2     )
           self.assertEqual(
               nested_simplify(__a		,			decimals=4     )		,			[{"""score""": 0.8_799, """answer""": """2"""}, {"""score""": 0.296, """answer""": """1"""}]     )

           SCREAMING_SNAKE_CASE__      :					Dict											=		vqa_pipeline({"""image""": image, """question""": question}		,			top_k=2     )
           self.assertEqual(
               nested_simplify(__a		,			decimals=4     )		,			[{"""score""": 0.8_799, """answer""": """2"""}, {"""score""": 0.296, """answer""": """1"""}]     )

           SCREAMING_SNAKE_CASE__      :					Optional[int]											=		vqa_pipeline(
               [{"""image""": image, """question""": question}, {"""image""": image, """question""": question}]		,			top_k=2     )
           self.assertEqual(
               nested_simplify(__a		,			decimals=4     )		,			[[{"""score""": 0.8_799, """answer""": """2"""}, {"""score""": 0.296, """answer""": """1"""}]] * 2		,			)





     @require_tf
     @unittest.skip("""Visual question answering not implemented in TF"""     )
     def     _a	(  self     )     ->					Tuple:


           """simple docstring"""


           pass








"""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   _UpperCamelCase  (   lowerCAmelCase__		):
							'''simple docstring'''







							def __init__(     self    ,   __a    ,   __a=None    ,   __a=True    ,   __a=None    ,   **__a	):
										__lowerCAmelCase				    =			parent
										__lowerCAmelCase				    =			config_class
										__lowerCAmelCase				    =			has_text_modality
										__lowerCAmelCase				    =			kwargs
										__lowerCAmelCase				    =			common_properties

							def 			snake_case				(     self	):
										__lowerCAmelCase				    =			self.config_class(**self.inputs_dict	)
										__lowerCAmelCase				    =			(
										    ["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:
																__lowerCAmelCase				    =			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 			snake_case				(     self	):
										__lowerCAmelCase				    =			self.config_class(**self.inputs_dict	)
										__lowerCAmelCase				    =			json.loads(config.to_json_string()	)
										for key, value in self.inputs_dict.items():
													self.parent.assertEqual(obj[key]    ,   __a	)

							def 			snake_case				(     self	):
										__lowerCAmelCase				    =			self.config_class(**self.inputs_dict	)

										with tempfile.TemporaryDirectory() as tmpdirname:
													__lowerCAmelCase				    =			os.path.join(__a    ,   "config.json"	)
													config_first.to_json_file(__a	)
													__lowerCAmelCase				    =			self.config_class.from_json_file(__a	)

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

							def 			snake_case				(     self	):
										__lowerCAmelCase				    =			self.config_class(**self.inputs_dict	)

										with tempfile.TemporaryDirectory() as tmpdirname:
													config_first.save_pretrained(__a	)
													__lowerCAmelCase				    =			self.config_class.from_pretrained(__a	)

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

							def 			snake_case				(     self	):
										__lowerCAmelCase				    =			self.config_class(**self.inputs_dict	)

										__lowerCAmelCase				    =			"test"
										with tempfile.TemporaryDirectory() as tmpdirname:
													__lowerCAmelCase				    =			os.path.join(__a    ,   __a	)
													config_first.save_pretrained(__a	)
													__lowerCAmelCase				    =			self.config_class.from_pretrained(__a    ,   subfolder=__a	)

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

							def 			snake_case				(     self	):
										__lowerCAmelCase				    =			self.config_class(**self.inputs_dict    ,   num_labels=5	)
										self.parent.assertEqual(len(config.idalabel	)    ,   5	)
										self.parent.assertEqual(len(config.labelaid	)    ,   5	)

										__lowerCAmelCase				    =			3
										self.parent.assertEqual(len(config.idalabel	)    ,   3	)
										self.parent.assertEqual(len(config.labelaid	)    ,   3	)

							def 			snake_case				(     self	):
										if self.config_class.is_composition:
													return
										__lowerCAmelCase				    =			self.config_class()
										self.parent.assertIsNotNone(__a	)

							def 			snake_case				(     self	):
										__lowerCAmelCase				    =			copy.deepcopy(__a	)
										__lowerCAmelCase				    =			self.config_class(**__a	)
										__lowerCAmelCase				    =			[]
										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:
													__lowerCAmelCase				    =			"\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 			snake_case				(     self	):
										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()




