






'''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 							__SCREAMING_SNAKE_CASE       :




       @staticmethod
       def  __UpperCamelCase							(  *lowerCamelCase ,   **lowerCamelCase      )							->Optional[Any]:



          '''simple docstring'''
          pass







 def    __UpperCAmelCase	(				SCREAMING_SNAKE_CASE__:	Tuple    )  ->			Union[str, Any]:

    """simple docstring"""
    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      :       Optional[Any]      			=      (
    """https://huggingface.co/spaces/impira/docquery/resolve/2f6c96314dc84dfda62d40de9da55f2f5165d403/invoice.png"""
)
@is_pipeline_test
@require_torch
@require_vision
class 							__SCREAMING_SNAKE_CASE       (							unittest.TestCase     ):
      __a  					=MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING




      @require_pytesseract
      @require_vision
      def  __UpperCamelCase							(  self ,   lowerCamelCase ,   lowerCamelCase ,   lowerCamelCase      )							->str:



         '''simple docstring'''
         __a				     =    pipeline(
             'document-question-answering' ,   model=lowerCamelCase ,   tokenizer=lowerCamelCase ,   image_processor=lowerCamelCase      )

         __a				     =    INVOICE_URL
         __a				     =    list(zip(*apply_tesseract(load_image(lowerCamelCase      ) ,   lowerCamelCase ,   ''      )      )      )
         __a				     =    'What is the placebo?'
         __a				     =    [
             {
                 'image': load_image(lowerCamelCase      ),
                 'question': question,
             },
             {
                 'image': image,
                 'question': question,
             },
             {
                 'image': image,
                 'question': question,
                 'word_boxes': word_boxes,
             },
         ]
         return dqa_pipeline, examples




      def  __UpperCamelCase							(  self ,   lowerCamelCase ,   lowerCamelCase      )							->Any:



         '''simple docstring'''
         __a				     =    dqa_pipeline(lowerCamelCase ,   top_k=2      )
         self.assertEqual(
             lowerCamelCase ,   [
                 [
                     {'score': ANY(lowerCamelCase      ), 'answer': ANY(lowerCamelCase      ), 'start': ANY(lowerCamelCase      ), 'end': ANY(lowerCamelCase      )},
                     {'score': ANY(lowerCamelCase      ), 'answer': ANY(lowerCamelCase      ), 'start': ANY(lowerCamelCase      ), 'end': ANY(lowerCamelCase      )},
                 ]
             ]
             * 3 ,   )




      @require_torch
      @require_detectrona
      @require_pytesseract
      def  __UpperCamelCase							(  self      )							->str:



         '''simple docstring'''
         __a				     =    pipeline('document-question-answering' ,   model='hf-internal-testing/tiny-random-layoutlmv2'      )
         __a				     =    INVOICE_URL
         __a				     =    'How many cats are there?'

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

         __a				     =    dqa_pipeline({'image': image, 'question': question} ,   top_k=2      )
         self.assertEqual(nested_simplify(lowerCamelCase ,   decimals=4      ) ,   lowerCamelCase      )

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

         # We can optionnally pass directly the words and bounding boxes
         __a				     =    './tests/fixtures/tests_samples/COCO/000000039769.png'
         __a				     =    []
         __a				     =    []
         __a				     =    dqa_pipeline(image=lowerCamelCase ,   question=lowerCamelCase ,   words=lowerCamelCase ,   boxes=lowerCamelCase ,   top_k=2      )
         self.assertEqual(lowerCamelCase ,   []      )




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



         '''simple docstring'''
         __a				     =    pipeline(
             'document-question-answering' ,   model='tiennvcs/layoutlmv2-base-uncased-finetuned-docvqa' ,   revision='9977165' ,   )
         __a				     =    INVOICE_URL
         __a				     =    'What is the invoice number?'

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

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

         __a				     =    dqa_pipeline(
             [{'image': image, 'question': question}, {'image': image, 'question': question}] ,   top_k=2      )
         self.assertEqual(
             nested_simplify(lowerCamelCase ,   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      )							->List[str]:



         '''simple docstring'''
         __a				     =    pipeline(
             'document-question-answering' ,   model='tiennvcs/layoutlmv2-base-uncased-finetuned-docvqa' ,   revision='9977165' ,   max_seq_len=50 ,   )
         __a				     =    INVOICE_URL
         __a				     =    'What is the invoice number?'

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

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

         __a				     =    dqa_pipeline(
             [{'image': image, 'question': question}, {'image': image, 'question': question}] ,   top_k=2      )
         self.assertEqual(
             nested_simplify(lowerCamelCase ,   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      )							->Dict:



         '''simple docstring'''
         __a				     =    AutoTokenizer.from_pretrained(
             'impira/layoutlm-document-qa' ,   revision='3dc6de3' ,   add_prefix_space=lowerCamelCase      )
         __a				     =    pipeline(
             'document-question-answering' ,   model='impira/layoutlm-document-qa' ,   tokenizer=lowerCamelCase ,   revision='3dc6de3' ,   )
         __a				     =    INVOICE_URL
         __a				     =    'What is the invoice number?'

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

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

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

         __a				     =    list(zip(*apply_tesseract(load_image(lowerCamelCase      ) ,   lowerCamelCase ,   ''      )      )      )

         # This model should also work if `image` is set to None
         __a				     =    dqa_pipeline({'image': None, 'word_boxes': word_boxes, 'question': question} ,   top_k=2      )
         self.assertEqual(
             nested_simplify(lowerCamelCase ,   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      )							->int:



         '''simple docstring'''
         __a				     =    AutoTokenizer.from_pretrained(
             'impira/layoutlm-document-qa' ,   revision='3dc6de3' ,   add_prefix_space=lowerCamelCase      )
         __a				     =    pipeline(
             'document-question-answering' ,   model='impira/layoutlm-document-qa' ,   tokenizer=lowerCamelCase ,   revision='3dc6de3' ,   max_seq_len=50 ,   )
         __a				     =    INVOICE_URL
         __a				     =    'What is the invoice number?'

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

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

         __a				     =    list(zip(*apply_tesseract(load_image(lowerCamelCase      ) ,   lowerCamelCase ,   ''      )      )      )

         # This model should also work if `image` is set to None
         __a				     =    dqa_pipeline({'image': None, 'word_boxes': word_boxes, 'question': question} ,   top_k=2      )
         self.assertEqual(
             nested_simplify(lowerCamelCase ,   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      )							->int:



         '''simple docstring'''
         __a				     =    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' ,   )

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






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



         '''simple docstring'''
         pass







'''simple docstring'''



from maths.prime_factors import prime_factors



def    __UpperCAmelCase	(				SCREAMING_SNAKE_CASE__:	int    )  ->			int:

   """simple docstring"""
   if not isinstance(SCREAMING_SNAKE_CASE__,					SCREAMING_SNAKE_CASE__    ):
      __a				     =    f"""Input value of [number={number}] must be an integer"""
      raise TypeError(SCREAMING_SNAKE_CASE__    )
   if number < 1:
      raise ValueError('Input must be a positive integer'    )
   return -1 if len(prime_factors(SCREAMING_SNAKE_CASE__    )    ) % 2 else 1


if __name__ == "__main__":
 import doctest

 doctest.testmod()