





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 					lowercase__ :

     '''simple docstring'''


     @staticmethod
     def    UpperCamelCase__						(					*__magic_name__,	**__magic_name__							)				->   List[Any]:






         """simple docstring"""
         pass




  def 	lowerCAmelCase_					(						__UpperCAmelCase:    List[str]   )   ->			Any:
      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.
UpperCAmelCase_  							=				(
    'https://huggingface.co/spaces/impira/docquery/resolve/2f6c96314dc84dfda62d40de9da55f2f5165d403/invoice.png'
)






@is_pipeline_test
@require_torch
@require_vision
class 					lowercase__ (			unittest.TestCase       ):

   '''simple docstring'''


   a		:							List[str]								=	MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING




   @require_pytesseract
   @require_vision
   def    UpperCamelCase__						(					self,	__magic_name__,	__magic_name__,	__magic_name__							)				->   str:






       """simple docstring"""
       UpperCamelCase__							:       Optional[Any]      =   pipeline(
           '''document-question-answering''',	model=__magic_name__,	tokenizer=__magic_name__,	image_processor=__magic_name__							)

       UpperCamelCase__							:       Tuple      =   INVOICE_URL
       UpperCamelCase__							:       Union[str, Any]      =   list(zip(*apply_tesseract(load_image(__magic_name__							),	__magic_name__,	''''''							)							)							)
       UpperCamelCase__							:       int      =   '''What is the placebo?'''
       UpperCamelCase__							:       Optional[int]      =   [
           {
               '''image''': load_image(__magic_name__							),
               '''question''': question,
           },
           {
               '''image''': image,
               '''question''': question,
           },
           {
               '''image''': image,
               '''question''': question,
               '''word_boxes''': word_boxes,
           },
       ]
       return dqa_pipeline, examples




   def    UpperCamelCase__						(					self,	__magic_name__,	__magic_name__							)				->   Tuple:






       """simple docstring"""
       UpperCamelCase__							:       Optional[int]      =   dqa_pipeline(__magic_name__,	top_k=2							)
       self.assertEqual(
           __magic_name__,	[
               [
                   {'''score''': ANY(__magic_name__							), '''answer''': ANY(__magic_name__							), '''start''': ANY(__magic_name__							), '''end''': ANY(__magic_name__							)},
                   {'''score''': ANY(__magic_name__							), '''answer''': ANY(__magic_name__							), '''start''': ANY(__magic_name__							), '''end''': ANY(__magic_name__							)},
               ]
           ]
           * 3,	)




   @require_torch
   @require_detectrona
   @require_pytesseract
   def    UpperCamelCase__						(					self							)				->   Optional[int]:






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

       UpperCamelCase__							:       int      =   [
           {'''score''': 0.0001, '''answer''': '''oy 2312/2019''', '''start''': 38, '''end''': 39},
           {'''score''': 0.0001, '''answer''': '''oy 2312/2019 DUE''', '''start''': 38, '''end''': 40},
       ]
       UpperCamelCase__							:       List[Any]      =   dqa_pipeline(image=__magic_name__,	question=__magic_name__,	top_k=2							)
       self.assertEqual(nested_simplify(__magic_name__,	decimals=4							),	__magic_name__							)

       UpperCamelCase__							:       Any      =   dqa_pipeline({'''image''': image, '''question''': question},	top_k=2							)
       self.assertEqual(nested_simplify(__magic_name__,	decimals=4							),	__magic_name__							)

       # This image does not detect ANY text in it, meaning layoutlmv2 should fail.
       # Empty answer probably
       UpperCamelCase__							:       Optional[Any]      =   '''./tests/fixtures/tests_samples/COCO/000000039769.png'''
       UpperCamelCase__							:       Any      =   dqa_pipeline(image=__magic_name__,	question=__magic_name__,	top_k=2							)
       self.assertEqual(__magic_name__,	[]							)

       # We can optionnally pass directly the words and bounding boxes
       UpperCamelCase__							:       List[Any]      =   '''./tests/fixtures/tests_samples/COCO/000000039769.png'''
       UpperCamelCase__							:       Union[str, Any]      =   []
       UpperCamelCase__							:       Optional[Any]      =   []
       UpperCamelCase__							:       Optional[int]      =   dqa_pipeline(image=__magic_name__,	question=__magic_name__,	words=__magic_name__,	boxes=__magic_name__,	top_k=2							)
       self.assertEqual(__magic_name__,	[]							)




   @slow
   @require_torch
   @require_detectrona
   @require_pytesseract
   def    UpperCamelCase__						(					self							)				->   Any:






       """simple docstring"""
       UpperCamelCase__							:       Optional[int]      =   pipeline(
           '''document-question-answering''',	model='''tiennvcs/layoutlmv2-base-uncased-finetuned-docvqa''',	revision='''9977165''',	)
       UpperCamelCase__							:       Dict      =   INVOICE_URL
       UpperCamelCase__							:       str      =   '''What is the invoice number?'''

       UpperCamelCase__							:       Any      =   dqa_pipeline(image=__magic_name__,	question=__magic_name__,	top_k=2							)
       self.assertEqual(
           nested_simplify(__magic_name__,	decimals=4							),	[
               {'''score''': 0.9944, '''answer''': '''us-001''', '''start''': 16, '''end''': 16},
               {'''score''': 0.0009, '''answer''': '''us-001''', '''start''': 16, '''end''': 16},
           ],	)

       UpperCamelCase__							:       int      =   dqa_pipeline({'''image''': image, '''question''': question},	top_k=2							)
       self.assertEqual(
           nested_simplify(__magic_name__,	decimals=4							),	[
               {'''score''': 0.9944, '''answer''': '''us-001''', '''start''': 16, '''end''': 16},
               {'''score''': 0.0009, '''answer''': '''us-001''', '''start''': 16, '''end''': 16},
           ],	)

       UpperCamelCase__							:       Tuple      =   dqa_pipeline(
           [{'''image''': image, '''question''': question}, {'''image''': image, '''question''': question}],	top_k=2							)
       self.assertEqual(
           nested_simplify(__magic_name__,	decimals=4							),	[
               [
                   {'''score''': 0.9944, '''answer''': '''us-001''', '''start''': 16, '''end''': 16},
                   {'''score''': 0.0009, '''answer''': '''us-001''', '''start''': 16, '''end''': 16},
               ],
           ]
           * 2,	)




   @slow
   @require_torch
   @require_detectrona
   @require_pytesseract
   def    UpperCamelCase__						(					self							)				->   Union[str, Any]:






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

       UpperCamelCase__							:       List[Any]      =   dqa_pipeline(image=__magic_name__,	question=__magic_name__,	top_k=2							)
       self.assertEqual(
           nested_simplify(__magic_name__,	decimals=4							),	[
               {'''score''': 0.9974, '''answer''': '''1110212019''', '''start''': 23, '''end''': 23},
               {'''score''': 0.9948, '''answer''': '''us-001''', '''start''': 16, '''end''': 16},
           ],	)

       UpperCamelCase__							:       Tuple      =   dqa_pipeline({'''image''': image, '''question''': question},	top_k=2							)
       self.assertEqual(
           nested_simplify(__magic_name__,	decimals=4							),	[
               {'''score''': 0.9974, '''answer''': '''1110212019''', '''start''': 23, '''end''': 23},
               {'''score''': 0.9948, '''answer''': '''us-001''', '''start''': 16, '''end''': 16},
           ],	)

       UpperCamelCase__							:       Optional[int]      =   dqa_pipeline(
           [{'''image''': image, '''question''': question}, {'''image''': image, '''question''': question}],	top_k=2							)
       self.assertEqual(
           nested_simplify(__magic_name__,	decimals=4							),	[
               [
                   {'''score''': 0.9974, '''answer''': '''1110212019''', '''start''': 23, '''end''': 23},
                   {'''score''': 0.9948, '''answer''': '''us-001''', '''start''': 16, '''end''': 16},
               ]
           ]
           * 2,	)




   @slow
   @require_torch
   @require_pytesseract
   @require_vision
   def    UpperCamelCase__						(					self							)				->   Optional[int]:






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

       UpperCamelCase__							:       Tuple      =   dqa_pipeline(image=__magic_name__,	question=__magic_name__,	top_k=2							)
       self.assertEqual(
           nested_simplify(__magic_name__,	decimals=4							),	[
               {'''score''': 0.4251, '''answer''': '''us-001''', '''start''': 16, '''end''': 16},
               {'''score''': 0.0819, '''answer''': '''1110212019''', '''start''': 23, '''end''': 23},
           ],	)

       UpperCamelCase__							:       List[Any]      =   dqa_pipeline({'''image''': image, '''question''': question},	top_k=2							)
       self.assertEqual(
           nested_simplify(__magic_name__,	decimals=4							),	[
               {'''score''': 0.4251, '''answer''': '''us-001''', '''start''': 16, '''end''': 16},
               {'''score''': 0.0819, '''answer''': '''1110212019''', '''start''': 23, '''end''': 23},
           ],	)

       UpperCamelCase__							:       Tuple      =   dqa_pipeline(
           [{'''image''': image, '''question''': question}, {'''image''': image, '''question''': question}],	top_k=2							)
       self.assertEqual(
           nested_simplify(__magic_name__,	decimals=4							),	[
               [
                   {'''score''': 0.4251, '''answer''': '''us-001''', '''start''': 16, '''end''': 16},
                   {'''score''': 0.0819, '''answer''': '''1110212019''', '''start''': 23, '''end''': 23},
               ]
           ]
           * 2,	)

       UpperCamelCase__							:       str      =   list(zip(*apply_tesseract(load_image(__magic_name__							),	__magic_name__,	''''''							)							)							)

       # This model should also work if `image` is set to None
       UpperCamelCase__							:       Any      =   dqa_pipeline({'''image''': None, '''word_boxes''': word_boxes, '''question''': question},	top_k=2							)
       self.assertEqual(
           nested_simplify(__magic_name__,	decimals=4							),	[
               {'''score''': 0.4251, '''answer''': '''us-001''', '''start''': 16, '''end''': 16},
               {'''score''': 0.0819, '''answer''': '''1110212019''', '''start''': 23, '''end''': 23},
           ],	)




   @slow
   @require_torch
   @require_pytesseract
   @require_vision
   def    UpperCamelCase__						(					self							)				->   Union[str, Any]:






       """simple docstring"""
       UpperCamelCase__							:       List[Any]      =   AutoTokenizer.from_pretrained(
           '''impira/layoutlm-document-qa''',	revision='''3dc6de3''',	add_prefix_space=__magic_name__							)
       UpperCamelCase__							:       int      =   pipeline(
           '''document-question-answering''',	model='''impira/layoutlm-document-qa''',	tokenizer=__magic_name__,	revision='''3dc6de3''',	max_seq_len=50,	)
       UpperCamelCase__							:       List[str]      =   INVOICE_URL
       UpperCamelCase__							:       Union[str, Any]      =   '''What is the invoice number?'''

       UpperCamelCase__							:       Dict      =   dqa_pipeline(image=__magic_name__,	question=__magic_name__,	top_k=2							)
       self.assertEqual(
           nested_simplify(__magic_name__,	decimals=4							),	[
               {'''score''': 0.9999, '''answer''': '''us-001''', '''start''': 16, '''end''': 16},
               {'''score''': 0.9998, '''answer''': '''us-001''', '''start''': 16, '''end''': 16},
           ],	)

       UpperCamelCase__							:       Tuple      =   dqa_pipeline(
           [{'''image''': image, '''question''': question}, {'''image''': image, '''question''': question}],	top_k=2							)
       self.assertEqual(
           nested_simplify(__magic_name__,	decimals=4							),	[
               [
                   {'''score''': 0.9999, '''answer''': '''us-001''', '''start''': 16, '''end''': 16},
                   {'''score''': 0.9998, '''answer''': '''us-001''', '''start''': 16, '''end''': 16},
               ]
           ]
           * 2,	)

       UpperCamelCase__							:       Tuple      =   list(zip(*apply_tesseract(load_image(__magic_name__							),	__magic_name__,	''''''							)							)							)

       # This model should also work if `image` is set to None
       UpperCamelCase__							:       Dict      =   dqa_pipeline({'''image''': None, '''word_boxes''': word_boxes, '''question''': question},	top_k=2							)
       self.assertEqual(
           nested_simplify(__magic_name__,	decimals=4							),	[
               {'''score''': 0.9999, '''answer''': '''us-001''', '''start''': 16, '''end''': 16},
               {'''score''': 0.9998, '''answer''': '''us-001''', '''start''': 16, '''end''': 16},
           ],	)




   @slow
   @require_torch
   def    UpperCamelCase__						(					self							)				->   Optional[int]:






       """simple docstring"""
       UpperCamelCase__							:       str      =   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''',	)

       UpperCamelCase__							:       List[str]      =   INVOICE_URL
       UpperCamelCase__							:       int      =   '''What is the invoice number?'''
       UpperCamelCase__							:       Tuple      =   dqa_pipeline(image=__magic_name__,	question=__magic_name__,	top_k=2							)
       self.assertEqual(nested_simplify(__magic_name__,	decimals=4							),	[{'''answer''': '''us-001'''}]							)




   @require_tf
   @unittest.skip('''Document question answering not implemented in TF'''							)
   def    UpperCamelCase__						(					self							)				->   int:






       """simple docstring"""
       pass








import logging
from dataclasses import dataclass, field
from pathlib import Path
from typing import Optional, Union

from .generation.configuration_utils import GenerationConfig
from .training_args import TrainingArguments
from .utils import add_start_docstrings


UpperCAmelCase_  							=				logging.getLogger(__name__)






@dataclass
@add_start_docstrings(TrainingArguments.__doc__       )
class 					lowercase__ (			__lowerCamelCase       ):

   '''simple docstring'''


   a		:							bool     	=	field(default=__lowerCamelCase    ,       metadata={"help": "Whether to use SortishSampler or not."}       )
   a		:							bool     	=	field(
       default=__lowerCamelCase    ,       metadata={"help": "Whether to use generate to calculate generative metrics (ROUGE, BLEU)."}       )
   a		:							Optional[int]     	=	field(
       default=__lowerCamelCase    ,       metadata={
           "help": (
               "The `max_length` to use on each evaluation loop when `predict_with_generate=True`. Will default "
               "to the `max_length` value of the model configuration."
           )
       }    ,       )
   a		:							Optional[int]     	=	field(
       default=__lowerCamelCase    ,       metadata={
           "help": (
               "The `num_beams` to use on each evaluation loop when `predict_with_generate=True`. Will default "
               "to the `num_beams` value of the model configuration."
           )
       }    ,       )
   a		:							Optional[Union[str, Path, GenerationConfig]]     	=	field(
       default=__lowerCamelCase    ,       metadata={
           "help": "Model id, file path or url pointing to a GenerationConfig json file, to use during prediction."
       }    ,       )




   def    UpperCamelCase__						(					self							)				->   str:






       """simple docstring"""
       UpperCamelCase__							:       Tuple      =   super().to_dict()
       for k, v in d.items():
           if isinstance(__magic_name__,	__magic_name__							):
               UpperCamelCase__							:       Tuple      =   v.to_dict()
       return d

