





# 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      lowercase__    (							__A  ):
  __UpperCamelCase	     =  """dandelin/vilt-b32-finetuned-vqa"""
  __UpperCamelCase	     =  (
      """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."""
  )
  __UpperCamelCase	     =  """image_qa"""
  __UpperCamelCase	     =  AutoProcessor
  __UpperCamelCase	     =  AutoModelForVisualQuestionAnswering

  __UpperCamelCase	     =  ["""image""", """text"""]
  __UpperCamelCase	     =  ["""text"""]







  def __init__(	self    ,						*_lowercase    ,						**_lowercase						):
       requires_backends(self    ,						["""vision"""]						)
       super().__init__(*_lowercase    ,						**_lowercase						)







  def 	UpperCAmelCase__		(	self    ,						_lowercase    ,						_lowercase						):
       return self.pre_processor(_lowercase    ,						_lowercase    ,						return_tensors="""pt"""						)







  def 	UpperCAmelCase__		(	self    ,						_lowercase						):
       with torch.no_grad():
            return self.model(**_lowercase						).logits







  def 	UpperCAmelCase__		(	self    ,						_lowercase						):
       lowerCAmelCase_					:       str    =		outputs.argmax(-1						).item()
       return self.model.config.idalabel[idx]







from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_sentencepiece_available,
    is_tokenizers_available,
    is_torch_available,
)


UpperCAmelCase_					:   int 							=						{"""configuration_plbart""": ["""PLBART_PRETRAINED_CONFIG_ARCHIVE_MAP""", """PLBartConfig"""]}

try:
      if not is_sentencepiece_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      UpperCAmelCase_					:   Optional[int] 							=						["""PLBartTokenizer"""]

try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      UpperCAmelCase_					:   Union[str, Any] 							=						[
          """PLBART_PRETRAINED_MODEL_ARCHIVE_LIST""",
          """PLBartForCausalLM""",
          """PLBartForConditionalGeneration""",
          """PLBartForSequenceClassification""",
          """PLBartModel""",
          """PLBartPreTrainedModel""",
      ]


if TYPE_CHECKING:
      from .configuration_plbart import PLBART_PRETRAINED_CONFIG_ARCHIVE_MAP, PLBartConfig

      try:
            if not is_sentencepiece_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .tokenization_plbart import PLBartTokenizer

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_plbart import (
                PLBART_PRETRAINED_MODEL_ARCHIVE_LIST,
                PLBartForCausalLM,
                PLBartForConditionalGeneration,
                PLBartForSequenceClassification,
                PLBartModel,
                PLBartPreTrainedModel,
            )


else:
      import sys

      UpperCAmelCase_					:   List[str] 							=						_LazyModule(__name__, globals()["""__file__"""], _import_structure)
