





# 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				(   __UpperCamelCase     ):
 UpperCAmelCase__						=						"""naver-clova-ix/donut-base-finetuned-docvqa"""
 UpperCAmelCase__						=						(
     """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."""
 )
 UpperCAmelCase__						=						"""document_qa"""
 UpperCAmelCase__						=						AutoProcessor
 UpperCAmelCase__						=						VisionEncoderDecoderModel

 UpperCAmelCase__						=						["""image""", """text"""]
 UpperCAmelCase__						=						["""text"""]
 def __init__( self    : List[str]     ,	*UpperCAmelCase    : Any     ,	**UpperCAmelCase    : str      )     ->      Tuple:
     if not is_vision_available():
         raise ValueError('Pillow must be installed to use the DocumentQuestionAnsweringTool.'      )

     super().__init__(*UpperCAmelCase     ,	**UpperCAmelCase      )
 def 	A_      ( self    : Tuple     ,	UpperCAmelCase    : "Image"     ,	UpperCAmelCase    : str      )     ->      Tuple:
     lowerCamelCase__       : Any   					=						'<s_docvqa><s_question>{user_input}</s_question><s_answer>'
     lowerCamelCase__       : Union[str, Any]   					=						task_prompt.replace('{user_input}'     ,	UpperCAmelCase      )
     lowerCamelCase__       : List[Any]   					=						self.pre_processor.tokenizer(
         UpperCAmelCase     ,	add_special_tokens=UpperCAmelCase     ,	return_tensors='pt'      ).input_ids
     lowerCamelCase__       : List[Any]   					=						self.pre_processor(UpperCAmelCase     ,	return_tensors='pt'      ).pixel_values

     return {"decoder_input_ids": decoder_input_ids, "pixel_values": pixel_values}
 def 	A_      ( self    : str     ,	UpperCAmelCase    : Tuple      )     ->      List[str]:
     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 	A_      ( self    : str     ,	UpperCAmelCase    : List[str]      )     ->      Any:
     lowerCamelCase__       : List[Any]   					=						self.pre_processor.batch_decode(UpperCAmelCase      )[0]
     lowerCamelCase__       : Optional[int]   					=						sequence.replace(self.pre_processor.tokenizer.eos_token     ,	''      )
     lowerCamelCase__       : List[str]   					=						sequence.replace(self.pre_processor.tokenizer.pad_token     ,	''      )
     lowerCamelCase__       : List[Any]   					=						re.sub(R'<.*?>'     ,	''     ,	UpperCAmelCase     ,	count=1      ).strip()  # remove first task start token
     lowerCamelCase__       : Optional[Any]   					=						self.pre_processor.tokenajson(UpperCAmelCase      )

     return sequence["answer"]












def 			SCREAMING_SNAKE_CASE (			_UpperCAmelCase		,      _UpperCAmelCase					)     ->	Union[str, Any]:
    lowerCamelCase__       : List[Any]   					=						[1]
    for i in range(2		,      _UpperCAmelCase					):
        factorials.append(factorials[-1] * i					)
    assert 0 <= k < factorials[-1] * n, "k out of bounds"

    lowerCamelCase__       : str   					=						[]
    lowerCamelCase__       : Optional[Any]   					=						list(range(_UpperCAmelCase					)					)

    # Find permutation
    while factorials:
        lowerCamelCase__       : List[str]   					=						factorials.pop()
        lowerCamelCase__					,				lowerCamelCase__       : Tuple   					=						divmod(_UpperCAmelCase		,      _UpperCAmelCase					)
        permutation.append(elements[number]					)
        elements.remove(elements[number]					)
    permutation.append(elements[0]					)

    return permutation


if __name__ == "__main__":
    import doctest

    doctest.testmod()





