





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






     """simple docstring"""






     snake_case_						      =   "naver-clova-ix/donut-base-finetuned-docvqa"
     snake_case_						      =   (
         "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_						      =   "document_qa"
     snake_case_						      =   AutoProcessor
     snake_case_						      =   VisionEncoderDecoderModel

     snake_case_						      =   ["image", "text"]
     snake_case_						      =   ["text"]



     def __init__(   self							:			Dict   ,       *__snake_case							:			Optional[Any]   ,       **__snake_case							:			Dict						)->	Optional[Any]:
        if not is_vision_available():
           raise ValueError("""Pillow must be installed to use the DocumentQuestionAnsweringTool."""						)

        super().__init__(*__snake_case   ,       **__snake_case						)



     def      lowerCAmelCase			(   self							:			Optional[Any]   ,       __snake_case							:			"Image"   ,       __snake_case							:			str						)->	str:
        snake_case 						=   """<s_docvqa><s_question>{user_input}</s_question><s_answer>"""
        snake_case 						=   task_prompt.replace("""{user_input}"""   ,       __snake_case						)
        snake_case 						=   self.pre_processor.tokenizer(
            __snake_case   ,       add_special_tokens=__snake_case   ,       return_tensors="""pt"""						).input_ids
        snake_case 						=   self.pre_processor(__snake_case   ,       return_tensors="""pt"""						).pixel_values

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



     def      lowerCAmelCase			(   self							:			Union[str, Any]   ,       __snake_case							:			Optional[Any]						)->	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=__snake_case   ,       pad_token_id=self.pre_processor.tokenizer.pad_token_id   ,       eos_token_id=self.pre_processor.tokenizer.eos_token_id   ,       use_cache=__snake_case   ,       num_beams=1   ,       bad_words_ids=[[self.pre_processor.tokenizer.unk_token_id]]   ,       return_dict_in_generate=__snake_case   ,       ).sequences



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

        return sequence["answer"]








'''simple docstring'''




from __future__ import annotations





def 	__lowerCamelCase			(      __lowerCAmelCase       :							float      ,    __lowerCAmelCase       :							float      ,    __lowerCAmelCase       :							float		)		->  float:
   if days_between_payments <= 0:
      raise ValueError("""days_between_payments must be > 0"""		)
   if daily_interest_rate < 0:
      raise ValueError("""daily_interest_rate must be >= 0"""		)
   if principal <= 0:
      raise ValueError("""principal must be > 0"""		)
   return principal * daily_interest_rate * days_between_payments





def 	__lowerCamelCase			(      __lowerCAmelCase       :							float      ,    __lowerCAmelCase       :							float      ,    __lowerCAmelCase       :							float      ,    )		->  float:
   if number_of_compounding_periods <= 0:
      raise ValueError("""number_of_compounding_periods must be > 0"""		)
   if nominal_annual_interest_rate_percentage < 0:
      raise ValueError("""nominal_annual_interest_rate_percentage must be >= 0"""		)
   if principal <= 0:
      raise ValueError("""principal must be > 0"""		)

   return principal * (
       (1 + nominal_annual_interest_rate_percentage) ** number_of_compounding_periods
       - 1
   )





def 	__lowerCamelCase			(      __lowerCAmelCase       :							float      ,    __lowerCAmelCase       :							float      ,    __lowerCAmelCase       :							float      ,    )		->  float:
   if number_of_years <= 0:
      raise ValueError("""number_of_years must be > 0"""		)
   if nominal_annual_percentage_rate < 0:
      raise ValueError("""nominal_annual_percentage_rate must be >= 0"""		)
   if principal <= 0:
      raise ValueError("""principal must be > 0"""		)

   return compound_interest(
       __lowerCAmelCase      ,    nominal_annual_percentage_rate / 3_65      ,    number_of_years * 3_65		)


if __name__ == "__main__":
 import doctest

 doctest.testmod()

