


"""simple docstring"""







from collections import OrderedDict
from typing import TYPE_CHECKING, Any, List, Mapping, Optional, Union

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import TensorType, logging


if TYPE_CHECKING:
     from ...onnx.config import PatchingSpec
     from ...tokenization_utils_base import PreTrainedTokenizerBase


lowerCAmelCase__      				=   logging.get_logger(__name__)

lowerCAmelCase__      				=   {
    '''allenai/longformer-base-4096''': '''https://huggingface.co/allenai/longformer-base-4096/resolve/main/config.json''',
    '''allenai/longformer-large-4096''': '''https://huggingface.co/allenai/longformer-large-4096/resolve/main/config.json''',
    '''allenai/longformer-large-4096-finetuned-triviaqa''': (
        '''https://huggingface.co/allenai/longformer-large-4096-finetuned-triviaqa/resolve/main/config.json'''
    ),
    '''allenai/longformer-base-4096-extra.pos.embd.only''': (
        '''https://huggingface.co/allenai/longformer-base-4096-extra.pos.embd.only/resolve/main/config.json'''
    ),
    '''allenai/longformer-large-4096-extra.pos.embd.only''': (
        '''https://huggingface.co/allenai/longformer-large-4096-extra.pos.embd.only/resolve/main/config.json'''
    ),
}


class       SCREAMING_SNAKE_CASE__				(		lowercase				):
       """simple docstring"""


       a  :				Optional[int]   ="longformer"

       def __init__(						self		,     snake_case__ = 512		,     snake_case__ = 2		,     snake_case__ = 1		,     snake_case__ = 0		,     snake_case__ = 2		,     snake_case__ = 30_522		,     snake_case__ = 768		,     snake_case__ = 12		,     snake_case__ = 12		,     snake_case__ = 3_072		,     snake_case__ = "gelu"		,     snake_case__ = 0.1		,     snake_case__ = 0.1		,     snake_case__ = 512		,     snake_case__ = 2		,     snake_case__ = 0.02		,     snake_case__ = 1e-12		,     snake_case__ = False		,     **snake_case__		,     ):






         """simple docstring"""





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

         lowerCAmelCase     :     Union[str, Any]								=							attention_window
         lowerCAmelCase     :     List[Any]								=							sep_token_id
         lowerCAmelCase     :     Dict								=							bos_token_id
         lowerCAmelCase     :     int								=							eos_token_id
         lowerCAmelCase     :     Dict								=							vocab_size
         lowerCAmelCase     :     Dict								=							hidden_size
         lowerCAmelCase     :     Optional[Any]								=							num_hidden_layers
         lowerCAmelCase     :     Tuple								=							num_attention_heads
         lowerCAmelCase     :     Union[str, Any]								=							hidden_act
         lowerCAmelCase     :     Optional[int]								=							intermediate_size
         lowerCAmelCase     :     Dict								=							hidden_dropout_prob
         lowerCAmelCase     :     int								=							attention_probs_dropout_prob
         lowerCAmelCase     :     Tuple								=							max_position_embeddings
         lowerCAmelCase     :     Optional[int]								=							type_vocab_size
         lowerCAmelCase     :     Any								=							initializer_range
         lowerCAmelCase     :     Union[str, Any]								=							layer_norm_eps
         lowerCAmelCase     :     List[str]								=							onnx_export


class       SCREAMING_SNAKE_CASE__				(		lowercase				):
       """simple docstring"""


       def __init__(						self		,     snake_case__		,     snake_case__ = "default"		,     snake_case__ = None						):






         """simple docstring"""





         super().__init__(snake_case__		,     snake_case__		,     snake_case__						)
         lowerCAmelCase     :     Any								=							True

       @property
       def        lowercase__							(						self						):






         """simple docstring"""





         if self.task == "multiple-choice":
           lowerCAmelCase     :     Tuple								=							{0: "batch", 1: "choice", 2: "sequence"}
         else:
           lowerCAmelCase     :     Any								=							{0: "batch", 1: "sequence"}
         return OrderedDict(
             [
                 ("input_ids", dynamic_axis),
                 ("attention_mask", dynamic_axis),
                 ("global_attention_mask", dynamic_axis),
             ]						)

       @property
       def        lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase     :     Tuple								=							super().outputs
         if self.task == "default":
           lowerCAmelCase     :     Tuple								=							{0: "batch"}
         return outputs

       @property
       def        lowercase__							(						self						):






         """simple docstring"""





         return 1e-4

       @property
       def        lowercase__							(						self						):






         """simple docstring"""





         return max(super().default_onnx_opset		,     14						)







       def        lowercase__							(						self		,     snake_case__		,     snake_case__ = -1		,     snake_case__ = -1		,     snake_case__ = False		,     snake_case__ = None		,     ):






         """simple docstring"""





         lowerCAmelCase     :     Dict								=							super().generate_dummy_inputs(
             preprocessor=snake_case__		,     batch_size=snake_case__		,     seq_length=snake_case__		,     is_pair=snake_case__		,     framework=snake_case__						)
         import torch

         # for some reason, replacing this code by inputs["global_attention_mask"] = torch.randint(2, inputs["input_ids"].shape, dtype=torch.int64)
         # makes the export fail randomly
         lowerCAmelCase     :     Dict								=							torch.zeros_like(inputs["input_ids"]						)
         # make every second token global
         lowerCAmelCase     :     List[Any]								=							1

         return inputs












'''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      snake_case     (    __lowerCamelCase       ):




 """simple docstring"""



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

 SCREAMING_SNAKE_CASE_	:					List[Any]					=["image", "text"]
 SCREAMING_SNAKE_CASE_	:					Any					=["text"]






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

        super().__init__(*__A							,	**__A	)






 def        _lowerCamelCase					(       self       :							Any							,	__A       :							"Image"							,	__A       :							str	):
        __UpperCamelCase       =  '<s_docvqa><s_question>{user_input}</s_question><s_answer>'
        __UpperCamelCase       =  task_prompt.replace('{user_input}'							,	__A	)
        __UpperCamelCase       =  self.pre_processor.tokenizer(
            __A							,	add_special_tokens=__A							,	return_tensors='pt'	).input_ids
        __UpperCamelCase       =  self.pre_processor(__A							,	return_tensors='pt'	).pixel_values

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






 def        _lowerCamelCase					(       self       :							Union[str, Any]							,	__A       :							Optional[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=__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        _lowerCamelCase					(       self       :							Tuple							,	__A       :							List[Any]	):
        __UpperCamelCase       =  self.pre_processor.batch_decode(__A	)[0]
        __UpperCamelCase       =  sequence.replace(self.pre_processor.tokenizer.eos_token							,	''	)
        __UpperCamelCase       =  sequence.replace(self.pre_processor.tokenizer.pad_token							,	''	)
        __UpperCamelCase       =  re.sub(R'<.*?>'							,	''							,	__A							,	count=1	).strip()  # remove first task start token
        __UpperCamelCase       =  self.pre_processor.tokenajson(__A	)

        return sequence["answer"]
