



"""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     lowerCAmelCase__						(	_lowerCamelCase ):


	'''simple docstring'''







	_SCREAMING_SNAKE_CASE	:		Optional[Any]  						= '''naver-clova-ix/donut-base-finetuned-docvqa'''
	_SCREAMING_SNAKE_CASE	:		Optional[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.'''
	)
	_SCREAMING_SNAKE_CASE	:		Any  						= '''document_qa'''
	_SCREAMING_SNAKE_CASE	:		Optional[int]  						= AutoProcessor
	_SCREAMING_SNAKE_CASE	:		Union[str, Any]  						= VisionEncoderDecoderModel

	_SCREAMING_SNAKE_CASE	:		List[str]  						= ['''image''', '''text''']
	_SCREAMING_SNAKE_CASE	:		Union[str, Any]  						= ['''text''']





	def __init__(      self				:       Optional[int]     ,       *_SCREAMING_SNAKE_CASE				:       str     ,       **_SCREAMING_SNAKE_CASE				:       str    )						->	List[Any]:





					"""simple docstring"""


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

					super().__init__(*_SCREAMING_SNAKE_CASE     ,       **_SCREAMING_SNAKE_CASE    )





	def 			_lowerCAmelCase     (      self				:       int     ,       _SCREAMING_SNAKE_CASE				:       "Image"     ,       _SCREAMING_SNAKE_CASE				:       str    )						->	List[str]:





					"""simple docstring"""


					SCREAMING_SNAKE_CASE						:							Any							=     '<s_docvqa><s_question>{user_input}</s_question><s_answer>'
					SCREAMING_SNAKE_CASE						:							Optional[int]							=     task_prompt.replace('{user_input}'     ,       _SCREAMING_SNAKE_CASE    )
					SCREAMING_SNAKE_CASE						:							Any							=     self.pre_processor.tokenizer(
					    _SCREAMING_SNAKE_CASE     ,       add_special_tokens=_SCREAMING_SNAKE_CASE     ,       return_tensors='pt'    ).input_ids
					SCREAMING_SNAKE_CASE						:							Dict							=     self.pre_processor(_SCREAMING_SNAKE_CASE     ,       return_tensors='pt'    ).pixel_values

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





	def 			_lowerCAmelCase     (      self				:       List[str]     ,       _SCREAMING_SNAKE_CASE				:       Optional[Any]    )						->	int:





					"""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=_SCREAMING_SNAKE_CASE     ,       pad_token_id=self.pre_processor.tokenizer.pad_token_id     ,       eos_token_id=self.pre_processor.tokenizer.eos_token_id     ,       use_cache=_SCREAMING_SNAKE_CASE     ,       num_beams=1     ,       bad_words_ids=[[self.pre_processor.tokenizer.unk_token_id]]     ,       return_dict_in_generate=_SCREAMING_SNAKE_CASE     ,       ).sequences







	def 			_lowerCAmelCase     (      self				:       List[str]     ,       _SCREAMING_SNAKE_CASE				:       Tuple    )						->	Tuple:





					"""simple docstring"""


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

					return sequence["answer"]










"""simple docstring"""

from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_torch_available,
)


A_						:    str				=      {'configuration_unispeech': ['UNISPEECH_PRETRAINED_CONFIG_ARCHIVE_MAP', 'UniSpeechConfig']}

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							A_						:    Optional[int]				=      [
							    'UNISPEECH_PRETRAINED_MODEL_ARCHIVE_LIST',
							    'UniSpeechForCTC',
							    'UniSpeechForPreTraining',
							    'UniSpeechForSequenceClassification',
							    'UniSpeechModel',
							    'UniSpeechPreTrainedModel',
							]

if TYPE_CHECKING:
							from .configuration_unispeech import UNISPEECH_PRETRAINED_CONFIG_ARCHIVE_MAP, UniSpeechConfig

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_unispeech import (
														    UNISPEECH_PRETRAINED_MODEL_ARCHIVE_LIST,
														    UniSpeechForCTC,
														    UniSpeechForPreTraining,
														    UniSpeechForSequenceClassification,
														    UniSpeechModel,
														    UniSpeechPreTrainedModel,
														)

else:
							import sys

							A_						:    int				=      _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)





