


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

					lowerCAmelCase      :Tuple   =					['''image''', '''text''']
					lowerCAmelCase      :str   =					['''text''']




					def __init__(      self							,							*_lowerCamelCase							,							**_lowerCamelCase):
								if not is_vision_available():
											raise ValueError("""Pillow must be installed to use the DocumentQuestionAnsweringTool.""")

								super().__init__(*_lowerCamelCase							,							**_lowerCamelCase)




					def 				snake_case__						(      self							,							_lowerCamelCase							,							_lowerCamelCase):
								UpperCAmelCase__  :					Optional[Any]        =     """<s_docvqa><s_question>{user_input}</s_question><s_answer>"""
								UpperCAmelCase__  :					Dict        =     task_prompt.replace("""{user_input}"""							,							_lowerCamelCase)
								UpperCAmelCase__  :					Optional[int]        =     self.pre_processor.tokenizer(
								    _lowerCamelCase							,							add_special_tokens=_lowerCamelCase							,							return_tensors="""pt""").input_ids
								UpperCAmelCase__  :					str        =     self.pre_processor(_lowerCamelCase							,							return_tensors="""pt""").pixel_values

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




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




					def 				snake_case__						(      self							,							_lowerCamelCase):
								UpperCAmelCase__  :					Optional[int]        =     self.pre_processor.batch_decode(_lowerCamelCase)[0]
								UpperCAmelCase__  :					int        =     sequence.replace(self.pre_processor.tokenizer.eos_token							,							"""""")
								UpperCAmelCase__  :					Any        =     sequence.replace(self.pre_processor.tokenizer.pad_token							,							"""""")
								UpperCAmelCase__  :					int        =     re.sub(r"""<.*?>"""							,							""""""							,							_lowerCamelCase							,							count=1).strip()  # remove first task start token
								UpperCAmelCase__  :					Dict        =     self.pre_processor.tokenajson(_lowerCamelCase)

								return sequence["answer"]



'''simple docstring'''



from typing import TYPE_CHECKING

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


__A	={
    'configuration_encodec': [
        'ENCODEC_PRETRAINED_CONFIG_ARCHIVE_MAP',
        'EncodecConfig',
    ],
    'feature_extraction_encodec': ['EncodecFeatureExtractor'],
}

try:
		if not is_torch_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		__A	=[
		    'ENCODEC_PRETRAINED_MODEL_ARCHIVE_LIST',
		    'EncodecModel',
		    'EncodecPreTrainedModel',
		]

if TYPE_CHECKING:
		from .configuration_encodec import (
		    ENCODEC_PRETRAINED_CONFIG_ARCHIVE_MAP,
		    EncodecConfig,
		)
		from .feature_extraction_encodec import EncodecFeatureExtractor

		try:
				if not is_torch_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_encodec import (
				    ENCODEC_PRETRAINED_MODEL_ARCHIVE_LIST,
				    EncodecModel,
				    EncodecPreTrainedModel,
				)

else:
		import sys

		__A	=_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)