

'''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_			(    _snake_case							):






     '''simple docstring'''



     UpperCAmelCase_						:     Dict  		=  """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_						:     Any  		=  """document_qa"""
     UpperCAmelCase_						:     Tuple  		=  AutoProcessor
     UpperCAmelCase_						:     Any  		=  VisionEncoderDecoderModel

     UpperCAmelCase_						:     List[Any]  		=  ["""image""", """text"""]
     UpperCAmelCase_						:     Optional[int]  		=  ["""text"""]


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

      super().__init__(*lowercase_					,      **lowercase_	)


     def        UpperCAmelCase_	(		self			:					List[Any]					,      lowercase_			:					"Image"					,      lowercase_			:					str	)						->     Any:
      UpperCAmelCase	:     Any						 =			'<s_docvqa><s_question>{user_input}</s_question><s_answer>'
      UpperCAmelCase	:     Dict						 =			task_prompt.replace('{user_input}'					,      lowercase_	)
      UpperCAmelCase	:     Any						 =			self.pre_processor.tokenizer(
          lowercase_					,      add_special_tokens=lowercase_					,      return_tensors='pt'	).input_ids
      UpperCAmelCase	:     Optional[Any]						 =			self.pre_processor(lowercase_					,      return_tensors='pt'	).pixel_values

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


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




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

      return sequence["answer"]







'''simple docstring'''

from typing import TYPE_CHECKING

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


lowercase__         =      {
    "configuration_xlm": ["XLM_PRETRAINED_CONFIG_ARCHIVE_MAP", "XLMConfig", "XLMOnnxConfig"],
    "tokenization_xlm": ["XLMTokenizer"],
}

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 lowercase__         =      [
     "XLM_PRETRAINED_MODEL_ARCHIVE_LIST",
     "XLMForMultipleChoice",
     "XLMForQuestionAnswering",
     "XLMForQuestionAnsweringSimple",
     "XLMForSequenceClassification",
     "XLMForTokenClassification",
     "XLMModel",
     "XLMPreTrainedModel",
     "XLMWithLMHeadModel",
 ]

try:
 if not is_tf_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 lowercase__         =      [
     "TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST",
     "TFXLMForMultipleChoice",
     "TFXLMForQuestionAnsweringSimple",
     "TFXLMForSequenceClassification",
     "TFXLMForTokenClassification",
     "TFXLMMainLayer",
     "TFXLMModel",
     "TFXLMPreTrainedModel",
     "TFXLMWithLMHeadModel",
 ]


if TYPE_CHECKING:
 from .configuration_xlm import XLM_PRETRAINED_CONFIG_ARCHIVE_MAP, XLMConfig, XLMOnnxConfig
 from .tokenization_xlm import XLMTokenizer

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_xlm import (
      XLM_PRETRAINED_MODEL_ARCHIVE_LIST,
      XLMForMultipleChoice,
      XLMForQuestionAnswering,
      XLMForQuestionAnsweringSimple,
      XLMForSequenceClassification,
      XLMForTokenClassification,
      XLMModel,
      XLMPreTrainedModel,
      XLMWithLMHeadModel,
  )

 try:
  if not is_tf_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_tf_xlm import (
      TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST,
      TFXLMForMultipleChoice,
      TFXLMForQuestionAnsweringSimple,
      TFXLMForSequenceClassification,
      TFXLMForTokenClassification,
      TFXLMMainLayer,
      TFXLMModel,
      TFXLMPreTrainedModel,
      TFXLMWithLMHeadModel,
  )

else:
 import sys

 lowercase__         =      _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)




