






# 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     __SCREAMING_SNAKE_CASE					(   __lowercase):
						_SCREAMING_SNAKE_CASE	:       List[str]   =					'''dandelin/vilt-b32-finetuned-vqa'''
						_SCREAMING_SNAKE_CASE	:       Union[str, Any]   =					(
						    '''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.'''
						)
						_SCREAMING_SNAKE_CASE	:       List[str]   =					'''image_qa'''
						_SCREAMING_SNAKE_CASE	:       Tuple   =					AutoProcessor
						_SCREAMING_SNAKE_CASE	:       Union[str, Any]   =					AutoModelForVisualQuestionAnswering

						_SCREAMING_SNAKE_CASE	:       Optional[Any]   =					['''image''', '''text''']
						_SCREAMING_SNAKE_CASE	:       List[str]   =					['''text''']






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






												"""simple docstring"""
												requires_backends(self     ,						['vision']   )
												super().__init__(*_UpperCamelCase     ,						**_UpperCamelCase   )






						def       UpperCamelCase__      (	self     ,						_UpperCamelCase     ,						_UpperCamelCase   ):






												"""simple docstring"""
												return self.pre_processor(_UpperCamelCase     ,						_UpperCamelCase     ,						return_tensors='pt'   )






						def       UpperCamelCase__      (	self     ,						_UpperCamelCase   ):






												"""simple docstring"""
												with torch.no_grad():
																		return self.model(**_UpperCamelCase   ).logits







						def       UpperCamelCase__      (	self     ,						_UpperCamelCase   ):






												"""simple docstring"""
												lowerCAmelCase__    						=						outputs.argmax(-1   ).item()
												return self.model.config.idalabel[idx]













from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


__snake_case    :    Tuple         =     {"""configuration_glpn""": ["""GLPN_PRETRAINED_CONFIG_ARCHIVE_MAP""", """GLPNConfig"""]}

try:
					if not is_vision_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					__snake_case    :    Dict         =     ["""GLPNFeatureExtractor"""]
					__snake_case    :    Optional[Any]         =     ["""GLPNImageProcessor"""]

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					__snake_case    :    Tuple         =     [
					    """GLPN_PRETRAINED_MODEL_ARCHIVE_LIST""",
					    """GLPNForDepthEstimation""",
					    """GLPNLayer""",
					    """GLPNModel""",
					    """GLPNPreTrainedModel""",
					]


if TYPE_CHECKING:
					from .configuration_glpn import GLPN_PRETRAINED_CONFIG_ARCHIVE_MAP, GLPNConfig

					try:
										if not is_vision_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .feature_extraction_glpn import GLPNFeatureExtractor
										from .image_processing_glpn import GLPNImageProcessor

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_glpn import (
										    GLPN_PRETRAINED_MODEL_ARCHIVE_LIST,
										    GLPNForDepthEstimation,
										    GLPNLayer,
										    GLPNModel,
										    GLPNPreTrainedModel,
										)


else:
					import sys

					__snake_case    :    Optional[int]         =     _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)





