
"""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.
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 				a			(					lowercase      ):
      UpperCamelCase							:   Tuple           =     """naver-clova-ix/donut-base-finetuned-docvqa"""
      UpperCamelCase							:   int           =     (
          """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							:   Optional[Any]           =     """document_qa"""
      UpperCamelCase							:   List[Any]           =     AutoProcessor
      UpperCamelCase							:   int           =     VisionEncoderDecoderModel

      UpperCamelCase							:   str           =     ["""image""", """text"""]
      UpperCamelCase							:   Tuple           =     ["""text"""]



      def __init__(   self     ,	*UpperCamelCase_     ,	**UpperCamelCase_      ):
          if not is_vision_available():
              raise ValueError('Pillow must be installed to use the DocumentQuestionAnsweringTool.'      )

          super().__init__(*UpperCamelCase_     ,	**UpperCamelCase_      )



      def  __snake_case							(   self     ,	UpperCamelCase_     ,	UpperCamelCase_      ):
          UpperCAmelCase__	:      Optional[Any]     							=					'<s_docvqa><s_question>{user_input}</s_question><s_answer>'
          UpperCAmelCase__	:      int     							=					task_prompt.replace('{user_input}'     ,	UpperCamelCase_      )
          UpperCAmelCase__	:      Tuple     							=					self.pre_processor.tokenizer(
              UpperCamelCase_     ,	add_special_tokens=UpperCamelCase_     ,	return_tensors='pt'      ).input_ids
          UpperCAmelCase__	:      List[Any]     							=					self.pre_processor(UpperCamelCase_     ,	return_tensors='pt'      ).pixel_values

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



      def  __snake_case							(   self     ,	UpperCamelCase_      ):
          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=UpperCamelCase_     ,	pad_token_id=self.pre_processor.tokenizer.pad_token_id     ,	eos_token_id=self.pre_processor.tokenizer.eos_token_id     ,	use_cache=UpperCamelCase_     ,	num_beams=1     ,	bad_words_ids=[[self.pre_processor.tokenizer.unk_token_id]]     ,	return_dict_in_generate=UpperCamelCase_     ,	).sequences



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

          return sequence["answer"]








from typing import List

from .keymap import KEYMAP, get_character
def      A__       (    SCREAMING_SNAKE_CASE_   :      str						)  ->  List[str]:






   """simple docstring"""







   def decorator(SCREAMING_SNAKE_CASE_   :      List[Any]						):
      _UpperCAmelCase           =   getattr(SCREAMING_SNAKE_CASE_				,	'''handle_key'''				,	[]						)
      handle += [key]
      setattr(SCREAMING_SNAKE_CASE_				,	'''handle_key'''				,	SCREAMING_SNAKE_CASE_						)
      return func

   return decorator
def      A__       (    *SCREAMING_SNAKE_CASE_   :      List[str]						)  ->  Dict:






   """simple docstring"""







   def decorator(SCREAMING_SNAKE_CASE_   :      Any						):
      _UpperCAmelCase           =   getattr(SCREAMING_SNAKE_CASE_				,	'''handle_key'''				,	[]						)
      handle += keys
      setattr(SCREAMING_SNAKE_CASE_				,	'''handle_key'''				,	SCREAMING_SNAKE_CASE_						)
      return func

   return decorator




class 			__UpperCamelCase    (							A__    ):





     def __new__(     cls				,							_UpperCamelCase				,							_UpperCamelCase				,							_UpperCamelCase					):
        _UpperCAmelCase           =   super().__new__(cls				,							_UpperCamelCase				,							_UpperCamelCase				,							_UpperCamelCase					)
        if not hasattr(_UpperCamelCase				,							'''key_handler'''					):
           setattr(_UpperCamelCase				,							'''key_handler'''				,							{}					)
        setattr(_UpperCamelCase				,							'''handle_input'''				,							KeyHandler.handle_input					)

        for value in attrs.values():
           _UpperCAmelCase           =   getattr(_UpperCamelCase				,							'''handle_key'''				,							[]					)
           for key in handled_keys:
              _UpperCAmelCase           =   value
        return new_cls





     @staticmethod
     def 		UpperCamelCase(     cls					):
        _UpperCAmelCase           =   get_character()
        if char != KEYMAP["undefined"]:
           _UpperCAmelCase           =   ord(_UpperCamelCase					)
        _UpperCAmelCase           =   cls.key_handler.get(_UpperCamelCase					)
        if handler:
           _UpperCAmelCase           =   char
           return handler(cls					)
        else:
           return None




def      A__       (    cls   :      Union[str, Any]						)  ->  Any:






   """simple docstring"""







   return KeyHandler(cls.__name__				,	cls.__bases__				,	cls.__dict__.copy()						)