





'''simple docstring'''


import unittest

from transformers import MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING, AutoTokenizer, is_vision_available
from transformers.pipelines import pipeline
from transformers.pipelines.document_question_answering import apply_tesseract
from transformers.testing_utils import (
    is_pipeline_test,
    nested_simplify,
    require_detectrona,
    require_pytesseract,
    require_tf,
    require_torch,
    require_vision,
    slow,
)

from .test_pipelines_common import ANY


if is_vision_available():
 from PIL import Image

 from transformers.image_utils import load_image
else:
 class       a_   :





      @staticmethod
      def 							lowercase__      ( *lowercase		:					int	,      **lowercase		:					int						):





         """simple docstring"""




         pass







 def 							UpperCAmelCase_  (						__lowerCamelCase					:					List[str] ):
    return None


# This is a pinned image from a specific revision of a document question answering space, hosted by HuggingFace,
# so we can expect it to be available.
lowerCAmelCase					:     str												=(
    '''https://huggingface.co/spaces/impira/docquery/resolve/2f6c96314dc84dfda62d40de9da55f2f5165d403/invoice.png'''
)
@is_pipeline_test
@require_torch
@require_vision
class       a_   (				unittest.TestCase							):
     __A      =			MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING





     @require_pytesseract
     @require_vision
     def 							lowercase__      ( self		:					str	,      lowercase		:					Optional[Any]	,      lowercase		:					Dict	,      lowercase		:					Union[str, Any]						):





        """simple docstring"""




        lowercase_			:str    			= pipeline(
            "document-question-answering"	,      model=lowercase	,      tokenizer=lowercase	,      image_processor=lowercase						)

        lowercase_			:Optional[Any]    			= INVOICE_URL
        lowercase_			:Any    			= list(zip(*apply_tesseract(load_image(lowercase						)	,      lowercase	,      ""						)						)						)
        lowercase_			:int    			= "What is the placebo?"
        lowercase_			:str    			= [
            {
                "image": load_image(lowercase						),
                "question": question,
            },
            {
                "image": image,
                "question": question,
            },
            {
                "image": image,
                "question": question,
                "word_boxes": word_boxes,
            },
        ]
        return dqa_pipeline, examples





     def 							lowercase__      ( self		:					Optional[Any]	,      lowercase		:					List[str]	,      lowercase		:					Tuple						):





        """simple docstring"""




        lowercase_			:Optional[int]    			= dqa_pipeline(lowercase	,      top_k=2						)
        self.assertEqual(
            lowercase	,      [
                [
                    {"score": ANY(lowercase						), "answer": ANY(lowercase						), "start": ANY(lowercase						), "end": ANY(lowercase						)},
                    {"score": ANY(lowercase						), "answer": ANY(lowercase						), "start": ANY(lowercase						), "end": ANY(lowercase						)},
                ]
            ]
            * 3	,      )





     @require_torch
     @require_detectrona
     @require_pytesseract
     def 							lowercase__      ( self		:					Optional[Any]						):





        """simple docstring"""




        lowercase_			:Tuple    			= pipeline("document-question-answering"	,      model="hf-internal-testing/tiny-random-layoutlmv2"						)
        lowercase_			:int    			= INVOICE_URL
        lowercase_			:str    			= "How many cats are there?"

        lowercase_			:Union[str, Any]    			= [
            {"score": 0.00_01, "answer": "oy 2312/2019", "start": 38, "end": 39},
            {"score": 0.00_01, "answer": "oy 2312/2019 DUE", "start": 38, "end": 40},
        ]
        lowercase_			:List[str]    			= dqa_pipeline(image=lowercase	,      question=lowercase	,      top_k=2						)
        self.assertEqual(nested_simplify(lowercase	,      decimals=4						)	,      lowercase						)

        lowercase_			:int    			= dqa_pipeline({"image": image, "question": question}	,      top_k=2						)
        self.assertEqual(nested_simplify(lowercase	,      decimals=4						)	,      lowercase						)

        # This image does not detect ANY text in it, meaning layoutlmv2 should fail.
        # Empty answer probably
        lowercase_			:Union[str, Any]    			= "./tests/fixtures/tests_samples/COCO/000000039769.png"
        lowercase_			:Dict    			= dqa_pipeline(image=lowercase	,      question=lowercase	,      top_k=2						)
        self.assertEqual(lowercase	,      []						)

        # We can optionnally pass directly the words and bounding boxes
        lowercase_			:Optional[Any]    			= "./tests/fixtures/tests_samples/COCO/000000039769.png"
        lowercase_			:Tuple    			= []
        lowercase_			:Optional[Any]    			= []
        lowercase_			:Optional[Any]    			= dqa_pipeline(image=lowercase	,      question=lowercase	,      words=lowercase	,      boxes=lowercase	,      top_k=2						)
        self.assertEqual(lowercase	,      []						)





     @slow
     @require_torch
     @require_detectrona
     @require_pytesseract
     def 							lowercase__      ( self		:					Optional[Any]						):





        """simple docstring"""




        lowercase_			:Dict    			= pipeline(
            "document-question-answering"	,      model="tiennvcs/layoutlmv2-base-uncased-finetuned-docvqa"	,      revision="9977165"	,      )
        lowercase_			:Union[str, Any]    			= INVOICE_URL
        lowercase_			:List[str]    			= "What is the invoice number?"

        lowercase_			:Any    			= dqa_pipeline(image=lowercase	,      question=lowercase	,      top_k=2						)
        self.assertEqual(
            nested_simplify(lowercase	,      decimals=4						)	,      [
                {"score": 0.99_44, "answer": "us-001", "start": 16, "end": 16},
                {"score": 0.00_09, "answer": "us-001", "start": 16, "end": 16},
            ]	,      )

        lowercase_			:Optional[Any]    			= dqa_pipeline({"image": image, "question": question}	,      top_k=2						)
        self.assertEqual(
            nested_simplify(lowercase	,      decimals=4						)	,      [
                {"score": 0.99_44, "answer": "us-001", "start": 16, "end": 16},
                {"score": 0.00_09, "answer": "us-001", "start": 16, "end": 16},
            ]	,      )

        lowercase_			:Any    			= dqa_pipeline(
            [{"image": image, "question": question}, {"image": image, "question": question}]	,      top_k=2						)
        self.assertEqual(
            nested_simplify(lowercase	,      decimals=4						)	,      [
                [
                    {"score": 0.99_44, "answer": "us-001", "start": 16, "end": 16},
                    {"score": 0.00_09, "answer": "us-001", "start": 16, "end": 16},
                ],
            ]
            * 2	,      )





     @slow
     @require_torch
     @require_detectrona
     @require_pytesseract
     def 							lowercase__      ( self		:					List[str]						):





        """simple docstring"""




        lowercase_			:Optional[int]    			= pipeline(
            "document-question-answering"	,      model="tiennvcs/layoutlmv2-base-uncased-finetuned-docvqa"	,      revision="9977165"	,      max_seq_len=50	,      )
        lowercase_			:Optional[int]    			= INVOICE_URL
        lowercase_			:Union[str, Any]    			= "What is the invoice number?"

        lowercase_			:Optional[Any]    			= dqa_pipeline(image=lowercase	,      question=lowercase	,      top_k=2						)
        self.assertEqual(
            nested_simplify(lowercase	,      decimals=4						)	,      [
                {"score": 0.99_74, "answer": "1110212019", "start": 23, "end": 23},
                {"score": 0.99_48, "answer": "us-001", "start": 16, "end": 16},
            ]	,      )

        lowercase_			:Optional[Any]    			= dqa_pipeline({"image": image, "question": question}	,      top_k=2						)
        self.assertEqual(
            nested_simplify(lowercase	,      decimals=4						)	,      [
                {"score": 0.99_74, "answer": "1110212019", "start": 23, "end": 23},
                {"score": 0.99_48, "answer": "us-001", "start": 16, "end": 16},
            ]	,      )

        lowercase_			:Union[str, Any]    			= dqa_pipeline(
            [{"image": image, "question": question}, {"image": image, "question": question}]	,      top_k=2						)
        self.assertEqual(
            nested_simplify(lowercase	,      decimals=4						)	,      [
                [
                    {"score": 0.99_74, "answer": "1110212019", "start": 23, "end": 23},
                    {"score": 0.99_48, "answer": "us-001", "start": 16, "end": 16},
                ]
            ]
            * 2	,      )





     @slow
     @require_torch
     @require_pytesseract
     @require_vision
     def 							lowercase__      ( self		:					str						):





        """simple docstring"""




        lowercase_			:Tuple    			= AutoTokenizer.from_pretrained(
            "impira/layoutlm-document-qa"	,      revision="3dc6de3"	,      add_prefix_space=lowercase						)
        lowercase_			:Dict    			= pipeline(
            "document-question-answering"	,      model="impira/layoutlm-document-qa"	,      tokenizer=lowercase	,      revision="3dc6de3"	,      )
        lowercase_			:Union[str, Any]    			= INVOICE_URL
        lowercase_			:List[Any]    			= "What is the invoice number?"

        lowercase_			:Optional[Any]    			= dqa_pipeline(image=lowercase	,      question=lowercase	,      top_k=2						)
        self.assertEqual(
            nested_simplify(lowercase	,      decimals=4						)	,      [
                {"score": 0.42_51, "answer": "us-001", "start": 16, "end": 16},
                {"score": 0.08_19, "answer": "1110212019", "start": 23, "end": 23},
            ]	,      )

        lowercase_			:List[str]    			= dqa_pipeline({"image": image, "question": question}	,      top_k=2						)
        self.assertEqual(
            nested_simplify(lowercase	,      decimals=4						)	,      [
                {"score": 0.42_51, "answer": "us-001", "start": 16, "end": 16},
                {"score": 0.08_19, "answer": "1110212019", "start": 23, "end": 23},
            ]	,      )

        lowercase_			:Union[str, Any]    			= dqa_pipeline(
            [{"image": image, "question": question}, {"image": image, "question": question}]	,      top_k=2						)
        self.assertEqual(
            nested_simplify(lowercase	,      decimals=4						)	,      [
                [
                    {"score": 0.42_51, "answer": "us-001", "start": 16, "end": 16},
                    {"score": 0.08_19, "answer": "1110212019", "start": 23, "end": 23},
                ]
            ]
            * 2	,      )

        lowercase_			:Any    			= list(zip(*apply_tesseract(load_image(lowercase						)	,      lowercase	,      ""						)						)						)

        # This model should also work if `image` is set to None
        lowercase_			:Tuple    			= dqa_pipeline({"image": None, "word_boxes": word_boxes, "question": question}	,      top_k=2						)
        self.assertEqual(
            nested_simplify(lowercase	,      decimals=4						)	,      [
                {"score": 0.42_51, "answer": "us-001", "start": 16, "end": 16},
                {"score": 0.08_19, "answer": "1110212019", "start": 23, "end": 23},
            ]	,      )





     @slow
     @require_torch
     @require_pytesseract
     @require_vision
     def 							lowercase__      ( self		:					Dict						):





        """simple docstring"""




        lowercase_			:str    			= AutoTokenizer.from_pretrained(
            "impira/layoutlm-document-qa"	,      revision="3dc6de3"	,      add_prefix_space=lowercase						)
        lowercase_			:Union[str, Any]    			= pipeline(
            "document-question-answering"	,      model="impira/layoutlm-document-qa"	,      tokenizer=lowercase	,      revision="3dc6de3"	,      max_seq_len=50	,      )
        lowercase_			:Tuple    			= INVOICE_URL
        lowercase_			:str    			= "What is the invoice number?"

        lowercase_			:int    			= dqa_pipeline(image=lowercase	,      question=lowercase	,      top_k=2						)
        self.assertEqual(
            nested_simplify(lowercase	,      decimals=4						)	,      [
                {"score": 0.99_99, "answer": "us-001", "start": 16, "end": 16},
                {"score": 0.99_98, "answer": "us-001", "start": 16, "end": 16},
            ]	,      )

        lowercase_			:List[Any]    			= dqa_pipeline(
            [{"image": image, "question": question}, {"image": image, "question": question}]	,      top_k=2						)
        self.assertEqual(
            nested_simplify(lowercase	,      decimals=4						)	,      [
                [
                    {"score": 0.99_99, "answer": "us-001", "start": 16, "end": 16},
                    {"score": 0.99_98, "answer": "us-001", "start": 16, "end": 16},
                ]
            ]
            * 2	,      )

        lowercase_			:Dict    			= list(zip(*apply_tesseract(load_image(lowercase						)	,      lowercase	,      ""						)						)						)

        # This model should also work if `image` is set to None
        lowercase_			:Optional[int]    			= dqa_pipeline({"image": None, "word_boxes": word_boxes, "question": question}	,      top_k=2						)
        self.assertEqual(
            nested_simplify(lowercase	,      decimals=4						)	,      [
                {"score": 0.99_99, "answer": "us-001", "start": 16, "end": 16},
                {"score": 0.99_98, "answer": "us-001", "start": 16, "end": 16},
            ]	,      )





     @slow
     @require_torch
     def 							lowercase__      ( self		:					Union[str, Any]						):





        """simple docstring"""




        lowercase_			:Any    			= pipeline(
            "document-question-answering"	,      model="naver-clova-ix/donut-base-finetuned-docvqa"	,      tokenizer=AutoTokenizer.from_pretrained("naver-clova-ix/donut-base-finetuned-docvqa"						)	,      feature_extractor="naver-clova-ix/donut-base-finetuned-docvqa"	,      )

        lowercase_			:Optional[Any]    			= INVOICE_URL
        lowercase_			:Tuple    			= "What is the invoice number?"
        lowercase_			:List[str]    			= dqa_pipeline(image=lowercase	,      question=lowercase	,      top_k=2						)
        self.assertEqual(nested_simplify(lowercase	,      decimals=4						)	,      [{"answer": "us-001"}]						)







     @require_tf
     @unittest.skip("Document question answering not implemented in TF"						)
     def 							lowercase__      ( self		:					Optional[Any]						):





        """simple docstring"""




        pass









'''simple docstring'''


from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


lowerCAmelCase					:     int												={
    '''configuration_bigbird_pegasus''': [
        '''BIGBIRD_PEGASUS_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''BigBirdPegasusConfig''',
        '''BigBirdPegasusOnnxConfig''',
    ],
}

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 lowerCAmelCase					:     Any												=[
     '''BIGBIRD_PEGASUS_PRETRAINED_MODEL_ARCHIVE_LIST''',
     '''BigBirdPegasusForCausalLM''',
     '''BigBirdPegasusForConditionalGeneration''',
     '''BigBirdPegasusForQuestionAnswering''',
     '''BigBirdPegasusForSequenceClassification''',
     '''BigBirdPegasusModel''',
     '''BigBirdPegasusPreTrainedModel''',
 ]


if TYPE_CHECKING:
 from .configuration_bigbird_pegasus import (
     BIGBIRD_PEGASUS_PRETRAINED_CONFIG_ARCHIVE_MAP,
     BigBirdPegasusConfig,
     BigBirdPegasusOnnxConfig,
 )

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_bigbird_pegasus import (
      BIGBIRD_PEGASUS_PRETRAINED_MODEL_ARCHIVE_LIST,
      BigBirdPegasusForCausalLM,
      BigBirdPegasusForConditionalGeneration,
      BigBirdPegasusForQuestionAnswering,
      BigBirdPegasusForSequenceClassification,
      BigBirdPegasusModel,
      BigBirdPegasusPreTrainedModel,
  )


else:
 import sys

 lowerCAmelCase					:     Dict												=_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)


