



# 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.
import re

from ..models.auto import AutoProcessor
from ..models.vision_encoder_decoder import VisionEncoderDecoderModel
from ..utils import is_vision_available
from .base import PipelineTool


if is_vision_available():
 from PIL import Image



class   lowercase_   (  __lowercase					):
      UpperCamelCase_      :		Union[str, Any]										=    "naver-clova-ix/donut-base-finetuned-docvqa"
      UpperCamelCase_      :		str										=    (
          "This is a tool that answers a question about an document (pdf). It takes an input named `document` which "
          "should be the document containing the information, as well as a `question` that is the question about the "
          "document. It returns a text that contains the answer to the question."
      )
      UpperCamelCase_      :		str										=    "document_qa"
      UpperCamelCase_      :		str										=    AutoProcessor
      UpperCamelCase_      :		List[Any]										=    VisionEncoderDecoderModel

      UpperCamelCase_      :		List[Any]										=    ["image", "text"]
      UpperCamelCase_      :		Optional[Any]										=    ["text"]



      def __init__(      self				:    List[str]      , *A__				:    str      , **A__				:    str		)   ->					Optional[Any]:
        if not is_vision_available():
          raise ValueError('''Pillow must be installed to use the DocumentQuestionAnsweringTool.'''		)

        super().__init__(*A__      , **A__		)



      def 						UpperCamelCase_		(      self				:    Optional[int]      , A__				:    "Image"      , A__				:    str		)   ->					Optional[int]:
        _snake_case						=							'''<s_docvqa><s_question>{user_input}</s_question><s_answer>'''
        _snake_case						=							task_prompt.replace('''{user_input}'''      , A__		)
        _snake_case						=							self.pre_processor.tokenizer(
            A__      , add_special_tokens=A__      , return_tensors='''pt'''		).input_ids
        _snake_case						=							self.pre_processor(A__      , return_tensors='''pt'''		).pixel_values

        return {"decoder_input_ids": decoder_input_ids, "pixel_values": pixel_values}



      def 						UpperCamelCase_		(      self				:    Optional[int]      , A__				:    Tuple		)   ->					Tuple:
        return self.model.generate(
            inputs['''pixel_values'''].to(self.device		)      , decoder_input_ids=inputs['''decoder_input_ids'''].to(self.device		)      , max_length=self.model.decoder.config.max_position_embeddings      , early_stopping=A__      , pad_token_id=self.pre_processor.tokenizer.pad_token_id      , eos_token_id=self.pre_processor.tokenizer.eos_token_id      , use_cache=A__      , num_beams=1      , bad_words_ids=[[self.pre_processor.tokenizer.unk_token_id]]      , return_dict_in_generate=A__      , ).sequences







      def 						UpperCamelCase_		(      self				:    Union[str, Any]      , A__				:    Dict		)   ->					List[str]:
        _snake_case						=							self.pre_processor.batch_decode(A__		)[0]
        _snake_case						=							sequence.replace(self.pre_processor.tokenizer.eos_token      , ''''''		)
        _snake_case						=							sequence.replace(self.pre_processor.tokenizer.pad_token      , ''''''		)
        _snake_case						=							re.sub(R'''<.*?>'''      , ''''''      , A__      , count=1		).strip()  # remove first task start token
        _snake_case						=							self.pre_processor.tokenajson(A__		)

        return sequence["answer"]




import os
import sys
from contextlib import contextmanager


# Windows only
if os.name == "nt":
 import ctypes
 import msvcrt  # noqa



 class   lowercase_   (  ctypes.Structure					):
       # _fields is a specific attr expected by ctypes
       UpperCamelCase_      :		List[Any]										=    [("size", ctypes.c_int), ("visible", ctypes.c_byte)]



def 				snake_case_()							->     int:



  """simple docstring"""






  if os.name == "nt":
    _snake_case						=							CursorInfo()
    _snake_case						=							ctypes.windll.kernelaa.GetStdHandle(-11					)
    ctypes.windll.kernelaa.GetConsoleCursorInfo(_UpperCamelCase			,	ctypes.byref(_UpperCamelCase					)					)
    _snake_case						=							False
    ctypes.windll.kernelaa.SetConsoleCursorInfo(_UpperCamelCase			,	ctypes.byref(_UpperCamelCase					)					)
  elif os.name == "posix":
    sys.stdout.write('''\033[?25l'''					)
    sys.stdout.flush()



def 				snake_case_()							->     Optional[Any]:



  """simple docstring"""






  if os.name == "nt":
    _snake_case						=							CursorInfo()
    _snake_case						=							ctypes.windll.kernelaa.GetStdHandle(-11					)
    ctypes.windll.kernelaa.GetConsoleCursorInfo(_UpperCamelCase			,	ctypes.byref(_UpperCamelCase					)					)
    _snake_case						=							True
    ctypes.windll.kernelaa.SetConsoleCursorInfo(_UpperCamelCase			,	ctypes.byref(_UpperCamelCase					)					)
  elif os.name == "posix":
    sys.stdout.write('''\033[?25h'''					)
    sys.stdout.flush()



@contextmanager
def 				snake_case_()							->     int:



  """simple docstring"""






  try:
    hide_cursor()
    yield
  finally:
    show_cursor()

