


# 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        UpperCamelCase__   (	__lowercase   ):
					__SCREAMING_SNAKE_CASE       :  Union[str, Any]						=   'naver-clova-ix/donut-base-finetuned-docvqa'
					__SCREAMING_SNAKE_CASE       :  Tuple						=   (
					    '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[Any]						=   'document_qa'
					__SCREAMING_SNAKE_CASE       :  Dict						=   AutoProcessor
					__SCREAMING_SNAKE_CASE       :  Tuple						=   VisionEncoderDecoderModel

					__SCREAMING_SNAKE_CASE       :  Any						=   ['image', 'text']
					__SCREAMING_SNAKE_CASE       :  List[str]						=   ['text']

					def __init__(     self       :   Any							,					*UpperCamelCase__       :   Optional[int]							,					**UpperCamelCase__       :   List[str]       ):






												'''simple docstring'''






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

												super().__init__(*UpperCamelCase__							,					**UpperCamelCase__       )

					def   UpperCAmelCase__       (     self       :   int							,					UpperCamelCase__       :   "Image"							,					UpperCamelCase__       :   str       ):






												'''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   UpperCAmelCase__       (     self       :   Any							,					UpperCamelCase__       :   List[str]       ):






												'''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   UpperCAmelCase__       (     self       :   Optional[Any]							,					UpperCamelCase__       :   Dict       ):






												'''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"]






def 			UpperCAmelCase_				(      UpperCAmelCase__=2_8_1_2_3  ):
					lowercase_  							=			[1] * (limit + 1)

					for i in range(2						,							int(limit**0.5  ) + 1  ):
										sum_divs[i * i] += i
										for k in range(i + 1						,							limit // i + 1  ):
															sum_divs[k * i] += k + i

					lowercase_  							=			set()
					lowercase_  							=			0

					for n in range(1						,							limit + 1  ):
										if sum_divs[n] > n:
															abundants.add(UpperCAmelCase__  )

										if not any((n - a in abundants) for a in abundants  ):
															res += n

					return res


if __name__ == "__main__":
							print(solution())


