




# 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 							UpperCamelCase_       (					UpperCAmelCase__	):

    '''simple docstring'''






    UpperCAmelCase__				    = '''naver-clova-ix/donut-base-finetuned-docvqa'''
    UpperCAmelCase__				    = (
        '''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__				    = '''document_qa'''
    UpperCAmelCase__				    = AutoProcessor
    UpperCAmelCase__				    = VisionEncoderDecoderModel

    UpperCAmelCase__				    = ['''image''', '''text''']
    UpperCAmelCase__				    = ['''text''']


    def __init__(     self :      int   ,					*UpperCAmelCase__ :      Dict   ,					**UpperCAmelCase__ :      Dict)		->List[str]:





           '''simple docstring'''

           if not is_vision_available():
                  raise ValueError('''Pillow must be installed to use the DocumentQuestionAnsweringTool.''')

           super().__init__(*UpperCAmelCase__   ,					**UpperCAmelCase__)


    def 			SCREAMING_SNAKE_CASE				(     self :      Union[str, Any]   ,					UpperCAmelCase__ :      "Image"   ,					UpperCAmelCase__ :      str)		->Optional[int]:





           '''simple docstring'''

           A__ 					=       '''<s_docvqa><s_question>{user_input}</s_question><s_answer>'''
           A__ 					=       task_prompt.replace('''{user_input}'''   ,					UpperCAmelCase__)
           A__ 					=       self.pre_processor.tokenizer(
               UpperCAmelCase__   ,					add_special_tokens=UpperCAmelCase__   ,					return_tensors='''pt''').input_ids
           A__ 					=       self.pre_processor(UpperCAmelCase__   ,					return_tensors='''pt''').pixel_values

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


    def 			SCREAMING_SNAKE_CASE				(     self :      int   ,					UpperCAmelCase__ :      List[str])		->Any:





           '''simple docstring'''

           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 			SCREAMING_SNAKE_CASE				(     self :      Dict   ,					UpperCAmelCase__ :      Optional[int])		->Dict:





           '''simple docstring'''

           A__ 					=       self.pre_processor.batch_decode(UpperCAmelCase__)[0]
           A__ 					=       sequence.replace(self.pre_processor.tokenizer.eos_token   ,					'''''')
           A__ 					=       sequence.replace(self.pre_processor.tokenizer.pad_token   ,					'''''')
           A__ 					=       re.sub(R'''<.*?>'''   ,					''''''   ,					UpperCAmelCase__   ,					count=1).strip()  # remove first task start token
           A__ 					=       self.pre_processor.tokenajson(UpperCAmelCase__)

           return sequence["answer"]









"""simple docstring"""
from ...configuration_utils import PretrainedConfig
from ...utils import logging


__UpperCamelCase     :						Optional[Any]						       =  logging.get_logger(__name__)

__UpperCamelCase     :						List[Any]						       =  {
    # See all MEGATRON_BERT models at https://huggingface.co/models?filter=bert
}







class       a							(   a__  ):
 snake_case__             =       '''megatron-bert'''



 def __init__(     self				,       _snake_case=2_90_56				,       _snake_case=10_24				,       _snake_case=24				,       _snake_case=16				,       _snake_case=40_96				,       _snake_case="gelu"				,       _snake_case=0.1				,       _snake_case=0.1				,       _snake_case=5_12				,       _snake_case=2				,       _snake_case=0.02				,       _snake_case=1E-12				,       _snake_case=0				,       _snake_case="absolute"				,       _snake_case=True				,       **_snake_case				,       ):







  """simple docstring"""






  super().__init__(pad_token_id=_snake_case				,       **_snake_case     )

  lowerCAmelCase    				= vocab_size
  lowerCAmelCase    				= hidden_size
  lowerCAmelCase    				= num_hidden_layers
  lowerCAmelCase    				= num_attention_heads
  lowerCAmelCase    				= hidden_act
  lowerCAmelCase    				= intermediate_size
  lowerCAmelCase    				= hidden_dropout_prob
  lowerCAmelCase    				= attention_probs_dropout_prob
  lowerCAmelCase    				= max_position_embeddings
  lowerCAmelCase    				= type_vocab_size
  lowerCAmelCase    				= initializer_range
  lowerCAmelCase    				= layer_norm_eps
  lowerCAmelCase    				= position_embedding_type
  lowerCAmelCase    				= use_cache





