


import copy
import tempfile
import unittest

from huggingface_hub import HfFolder, delete_repo
from parameterized import parameterized
from requests.exceptions import HTTPError

from transformers import AutoConfig, GenerationConfig
from transformers.testing_utils import TOKEN, USER, is_staging_test



class 	__lowerCamelCase			(unittest.TestCase						):







       @parameterized.expand([(None,), ('foo.json',)]					)
       def 		snake_case_	(			self: int,A_: int					):






            '''simple docstring'''




            __UpperCamelCase =			GenerationConfig(
                do_sample=A_,temperature=0.7,length_penalty=1.0,bad_words_ids=[[1, 2, 3], [4, 5]],)
            with tempfile.TemporaryDirectory() as tmp_dir:
                 config.save_pretrained(A_,config_name=A_					)
                 __UpperCamelCase =			GenerationConfig.from_pretrained(A_,config_name=A_					)

            # Checks parameters that were specified
            self.assertEqual(loaded_config.do_sample,A_					)
            self.assertEqual(loaded_config.temperature,0.7					)
            self.assertEqual(loaded_config.length_penalty,1.0					)
            self.assertEqual(loaded_config.bad_words_ids,[[1, 2, 3], [4, 5]]					)

            # Checks parameters that were not specified (defaults)
            self.assertEqual(loaded_config.top_k,50					)
            self.assertEqual(loaded_config.max_length,20					)
            self.assertEqual(loaded_config.max_time,A_					)







       def 		snake_case_	(			self: Tuple					):






            '''simple docstring'''




            __UpperCamelCase =			AutoConfig.from_pretrained('gpt2'					)
            __UpperCamelCase =			GenerationConfig.from_model_config(A_					)
            __UpperCamelCase =			GenerationConfig()

            # The generation config has loaded a few non-default parameters from the model config
            self.assertNotEqual(A_,A_					)

            # One of those parameters is eos_token_id -- check if it matches
            self.assertNotEqual(generation_config_from_model.eos_token_id,default_generation_config.eos_token_id					)
            self.assertEqual(generation_config_from_model.eos_token_id,model_config.eos_token_id					)







       def 		snake_case_	(			self: Any					):






            '''simple docstring'''




            __UpperCamelCase =			GenerationConfig()
            __UpperCamelCase =			{
                'max_new_tokens': 1024,
                'foo': 'bar',
            }
            __UpperCamelCase =			copy.deepcopy(A_					)
            __UpperCamelCase =			generation_config.update(**A_					)

            # update_kwargs was not modified (no side effects)
            self.assertEqual(A_,A_					)

            # update_kwargs was used to update the config on valid attributes
            self.assertEqual(generation_config.max_new_tokens,1024					)

            # `.update()` returns a dictionary of unused kwargs
            self.assertEqual(A_,{'foo': 'bar'}					)







       def 		snake_case_	(			self: List[Any]					):






            '''simple docstring'''




            __UpperCamelCase =			GenerationConfig()
            __UpperCamelCase =			'bar'

            with tempfile.TemporaryDirectory('test-generation-config'					) as tmp_dir:
                 generation_config.save_pretrained(A_					)

                 __UpperCamelCase =			GenerationConfig.from_pretrained(A_					)
            # update_kwargs was used to update the config on valid attributes
            self.assertEqual(new_config.foo,'bar'					)

            __UpperCamelCase =			GenerationConfig.from_model_config(A_					)
            assert not hasattr(A_,'foo'					)  # no new kwargs should be initialized if from config







       def 		snake_case_	(			self: List[Any]					):






            '''simple docstring'''




            __UpperCamelCase =			GenerationConfig()
            self.assertEqual(default_config.temperature,1.0					)
            self.assertEqual(default_config.do_sample,A_					)
            self.assertEqual(default_config.num_beams,1					)

            __UpperCamelCase =			GenerationConfig(
                do_sample=A_,temperature=0.7,length_penalty=1.0,bad_words_ids=[[1, 2, 3], [4, 5]],)
            self.assertEqual(config.temperature,0.7					)
            self.assertEqual(config.do_sample,A_					)
            self.assertEqual(config.num_beams,1					)

            with tempfile.TemporaryDirectory() as tmp_dir:
                 config.save_pretrained(A_					)
                 __UpperCamelCase =			GenerationConfig.from_pretrained(A_,temperature=1.0					)

            self.assertEqual(loaded_config.temperature,1.0					)
            self.assertEqual(loaded_config.do_sample,A_					)
            self.assertEqual(loaded_config.num_beams,1					)  # default value



@is_staging_test
class 	__lowerCamelCase			(unittest.TestCase						):







       @classmethod
       def 		snake_case_	(			cls: int					):






            '''simple docstring'''




            __UpperCamelCase =			TOKEN
            HfFolder.save_token(A_					)







       @classmethod
       def 		snake_case_	(			cls: int					):






            '''simple docstring'''




            try:
                 delete_repo(token=cls._token,repo_id='test-generation-config'					)
            except HTTPError:
                 pass

            try:
                 delete_repo(token=cls._token,repo_id='valid_org/test-generation-config-org'					)
            except HTTPError:
                 pass







       def 		snake_case_	(			self: int					):






            '''simple docstring'''




            __UpperCamelCase =			GenerationConfig(
                do_sample=A_,temperature=0.7,length_penalty=1.0,)
            config.push_to_hub('test-generation-config',use_auth_token=self._token					)

            __UpperCamelCase =			GenerationConfig.from_pretrained(F'''{USER}/test-generation-config'''					)
            for k, v in config.to_dict().items():
                 if k != "transformers_version":
                      self.assertEqual(A_,getattr(A_,A_					)					)

        # Reset repo
            delete_repo(token=self._token,repo_id='test-generation-config'					)

            # Push to hub via save_pretrained
            with tempfile.TemporaryDirectory() as tmp_dir:
                 config.save_pretrained(
                     A_,repo_id='test-generation-config',push_to_hub=A_,use_auth_token=self._token					)

            __UpperCamelCase =			GenerationConfig.from_pretrained(F'''{USER}/test-generation-config'''					)
            for k, v in config.to_dict().items():
                 if k != "transformers_version":
                      self.assertEqual(A_,getattr(A_,A_					)					)







       def 		snake_case_	(			self: Dict					):






            '''simple docstring'''




            __UpperCamelCase =			GenerationConfig(
                do_sample=A_,temperature=0.7,length_penalty=1.0,)
            config.push_to_hub('valid_org/test-generation-config-org',use_auth_token=self._token					)

            __UpperCamelCase =			GenerationConfig.from_pretrained('valid_org/test-generation-config-org'					)
            for k, v in config.to_dict().items():
                 if k != "transformers_version":
                      self.assertEqual(A_,getattr(A_,A_					)					)

        # Reset repo
            delete_repo(token=self._token,repo_id='valid_org/test-generation-config-org'					)

            # Push to hub via save_pretrained
            with tempfile.TemporaryDirectory() as tmp_dir:
                 config.save_pretrained(
                     A_,repo_id='valid_org/test-generation-config-org',push_to_hub=A_,use_auth_token=self._token					)

            __UpperCamelCase =			GenerationConfig.from_pretrained('valid_org/test-generation-config-org'					)
            for k, v in config.to_dict().items():
                 if k != "transformers_version":
                      self.assertEqual(A_,getattr(A_,A_					)					)






'''simple docstring'''
# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from typing import TYPE_CHECKING

import torch

from ..models.auto import AutoModelForVisualQuestionAnswering, AutoProcessor
from ..utils import requires_backends
from .base import PipelineTool


if TYPE_CHECKING:
 from PIL import Image

class     _lowerCamelCase       (     snake_case_					):




 '''simple docstring'''
 __lowercase					:		int     				=    '''dandelin/vilt-b32-finetuned-vqa'''
 __lowercase					:		int     				=    (
     '''This is a tool that answers a question about an image. It takes an input named `image` which should be the '''
     '''image containing the information, as well as a `question` which should be the question in English. It '''
     '''returns a text that is the answer to the question.'''
 )
 __lowercase					:		Union[str, Any]     				=    '''image_qa'''
 __lowercase					:		Optional[Any]     				=    AutoProcessor
 __lowercase					:		Tuple     				=    AutoModelForVisualQuestionAnswering

 __lowercase					:		Tuple     				=    ['''image''', '''text''']
 __lowercase					:		List[str]     				=    ['''text''']


 def __init__(   self   ,   *__lowercase   ,   **__lowercase    ):

  """simple docstring"""







  requires_backends(self   ,   ['vision']    )
  super().__init__(*__lowercase   ,   **__lowercase    )


 def 			snake_case__ (   self   ,   __lowercase   ,   __lowercase    ):

  """simple docstring"""







  return self.pre_processor(__lowercase   ,   __lowercase   ,   return_tensors='pt'    )


 def 			snake_case__ (   self   ,   __lowercase    ):

  """simple docstring"""







  with torch.no_grad():
   return self.model(**__lowercase    ).logits







 def 			snake_case__ (   self   ,   __lowercase    ):

  """simple docstring"""







  __A	:		List[str]	  =      outputs.argmax(-1    ).item()
  return self.model.config.idalabel[idx]






