

# coding=utf-8
# Copyright 2023 The HuggingFace Inc. team.
#
# 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.

# this script dumps information about the environment

import os
import platform
import sys


_lowerCamelCase    :       Any        =							"3"

print("Python version:", sys.version)

print("OS platform:", platform.platform())
print("OS architecture:", platform.machine())

try:
					import torch

					print("Torch version:", torch.__version__)
					print("Cuda available:", torch.cuda.is_available())
					print("Cuda version:", torch.version.cuda)
					print("CuDNN version:", torch.backends.cudnn.version())
					print("Number of GPUs available:", torch.cuda.device_count())
except ImportError:
					print("Torch version:", None)

try:
					import transformers

					print("transformers version:", transformers.__version__)
except ImportError:
					print("transformers version:", None)








from typing import Union

from ..utils import add_end_docstrings, is_torch_available, is_vision_available, logging
from .base import PIPELINE_INIT_ARGS, Pipeline


if is_vision_available():
     from PIL import Image

     from ..image_utils import load_image

if is_torch_available():
     from ..models.auto.modeling_auto import MODEL_FOR_VISUAL_QUESTION_ANSWERING_MAPPING

_lowerCamelCase    :       Dict        =							logging.get_logger(__name__)





@add_end_docstrings(lowerCamelCase__						)
class  __UpperCAmelCase					(	lowerCamelCase__						):



   def __init__(							self							:					Optional[Any],		*__A							:					Tuple,		**__A							:					Tuple						):
     super().__init__(*__A,		**__A						)
     self.check_model_type(__A						)



   def 	__magic_name__   (							self							:					Union[str, Any],		__A							:					int=None,		__A							:					Tuple=None,		__A							:					Any=None,		**__A							:					Optional[int]						):
     UpperCAmelCase			,						UpperCAmelCase	:							List[Any]						=			{}, {}
     if padding is not None:
       UpperCAmelCase	:							Optional[int]						=			padding
     if truncation is not None:
       UpperCAmelCase	:							Optional[int]						=			truncation
     if top_k is not None:
       UpperCAmelCase	:							Tuple						=			top_k
     return preprocess_params, {}, postprocess_params



   def __call__(							self							:					Union[str, Any],		__A							:					Union["Image.Image", str],		__A							:					str = None,		**__A							:					Optional[int]						):
     if isinstance(__A,		(Image.Image, str)						) and isinstance(__A,		__A						):
       UpperCAmelCase	:							int						=			{'''image''': image, '''question''': question}
     else:
       UpperCAmelCase	:							str						=			image
     UpperCAmelCase	:							Union[str, Any]						=			super().__call__(__A,		**__A						)
     return results



   def 	__magic_name__   (							self							:					List[str],		__A							:					Union[str, Any],		__A							:					Tuple=False,		__A							:					List[Any]=False						):
     UpperCAmelCase	:							int						=			load_image(inputs['''image''']						)
     UpperCAmelCase	:							List[str]						=			self.tokenizer(
         inputs['''question'''],		return_tensors=self.framework,		padding=__A,		truncation=__A						)
     UpperCAmelCase	:							Union[str, Any]						=			self.image_processor(images=__A,		return_tensors=self.framework						)
     model_inputs.update(__A						)
     return model_inputs



   def 	__magic_name__   (							self							:					Optional[Any],		__A							:					List[Any]						):
     UpperCAmelCase	:							Optional[int]						=			self.model(**__A						)
     return model_outputs





   def 	__magic_name__   (							self							:					Any,		__A							:					List[str],		__A							:					Union[str, Any]=5						):
     if top_k > self.model.config.num_labels:
       UpperCAmelCase	:							Any						=			self.model.config.num_labels

     if self.framework == "pt":
       UpperCAmelCase	:							Any						=			model_outputs.logits.sigmoid()[0]
       UpperCAmelCase			,						UpperCAmelCase	:							Union[str, Any]						=			probs.topk(__A						)
     else:
       raise ValueError(F'''Unsupported framework: {self.framework}'''						)

     UpperCAmelCase	:							str						=			scores.tolist()
     UpperCAmelCase	:							Tuple						=			ids.tolist()
     return [{"score": score, "answer": self.model.config.idalabel[_id]} for score, _id in zip(__A,		__A						)]





