"""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		( __lowerCAmelCase			):
      snake_case__    :     List[str]													=			'naver-clova-ix/donut-base-finetuned-docvqa'
      snake_case__    :     Union[str, Any]													=			(
          '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.'
      )
      snake_case__    :     Dict													=			'document_qa'
      snake_case__    :     str													=			AutoProcessor
      snake_case__    :     Union[str, Any]													=			VisionEncoderDecoderModel

      snake_case__    :     Dict													=			['image', 'text']
      snake_case__    :     Optional[int]													=			['text']

      def __init__(		self	, *__lowerCAmelCase	, **__lowerCAmelCase		):







            """simple docstring"""



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

            super().__init__(*_UpperCamelCase	, **_UpperCamelCase		)

      def        A__ (		self	, __lowerCAmelCase	, __lowerCAmelCase		):







            """simple docstring"""



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

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

      def        A__ (		self	, __lowerCAmelCase		):







            """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        A__ (		self	, __lowerCAmelCase		):







            """simple docstring"""



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

            return sequence["answer"]







"""simple docstring"""






from typing import TYPE_CHECKING

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


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

try:
       if not is_torch_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       __lowerCAmelCase					: int        =[
           """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:
       __lowerCAmelCase					: Union[str, Any]        =[
           """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

       __lowerCAmelCase					: Optional[int]        =_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)



