





import itertools
import json
import os
import unittest

from transformers import AddedToken, LongformerTokenizer, LongformerTokenizerFast
from transformers.models.longformer.tokenization_longformer import VOCAB_FILES_NAMES
from transformers.testing_utils import require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin

@require_tokenizers
class 		SCREAMING_SNAKE_CASE__				(       _UpperCAmelCase						,      unittest.TestCase  ):
      A_						:				Tuple							=    LongformerTokenizer
      A_						:				Any							=    True
      A_						:				Tuple							=    LongformerTokenizerFast
      A_						:				Dict							=    True


      def    a (self       :      Optional[int]      ):





         """simple docstring"""



         super().setUp()

         # Adapted from Sennrich et al. 2015 and https://github.com/rsennrich/subword-nmt
         __snake_case							       =   [
             '''l''',
             '''o''',
             '''w''',
             '''e''',
             '''r''',
             '''s''',
             '''t''',
             '''i''',
             '''d''',
             '''n''',
             '''\u0120''',
             '''\u0120l''',
             '''\u0120n''',
             '''\u0120lo''',
             '''\u0120low''',
             '''er''',
             '''\u0120lowest''',
             '''\u0120newer''',
             '''\u0120wider''',
             '''<unk>''',
         ]
         __snake_case							       =   dict(zip(a__				,			range(len(a__      )      )      )      )
         __snake_case							       =   ['''#version: 0.2''', '''\u0120 l''', '''\u0120l o''', '''\u0120lo w''', '''e r''', '''''']
         __snake_case							       =   {'''unk_token''': '''<unk>'''}

         __snake_case							       =   os.path.join(self.tmpdirname				,			VOCAB_FILES_NAMES['''vocab_file''']      )
         __snake_case							       =   os.path.join(self.tmpdirname				,			VOCAB_FILES_NAMES['''merges_file''']      )
         with open(self.vocab_file				,			'''w'''				,			encoding='''utf-8'''      ) as fp:
            fp.write(json.dumps(a__      ) + '''\n'''      )
         with open(self.merges_file				,			'''w'''				,			encoding='''utf-8'''      ) as fp:
            fp.write('''\n'''.join(a__      )      )


      def    a (self       :      Dict				,			**a__       :      Optional[int]      ):





         """simple docstring"""



         kwargs.update(self.special_tokens_map      )
         return self.tokenizer_class.from_pretrained(self.tmpdirname				,			**a__      )


      def    a (self       :      Any				,			**a__       :      Optional[Any]      ):





         """simple docstring"""



         kwargs.update(self.special_tokens_map      )
         return self.rust_tokenizer_class.from_pretrained(self.tmpdirname				,			**a__      )


      def    a (self       :      Optional[int]				,			a__       :      Dict      ):





         """simple docstring"""



         __snake_case							       =   '''lower newer'''
         __snake_case							       =   '''lower newer'''
         return input_text, output_text


      def    a (self       :      Optional[int]      ):





         """simple docstring"""



         __snake_case							       =   self.tokenizer_class(self.vocab_file				,			self.merges_file				,			**self.special_tokens_map      )
         __snake_case							       =   '''lower newer'''
         __snake_case							       =   ['''l''', '''o''', '''w''', '''er''', '''\u0120''', '''n''', '''e''', '''w''', '''er''']
         __snake_case							       =   tokenizer.tokenize(a__      )  # , add_prefix_space=True)
         self.assertListEqual(a__				,			a__      )

         __snake_case							       =   tokens + [tokenizer.unk_token]
         __snake_case							       =   [0, 1, 2, 15, 10, 9, 3, 2, 15, 19]
         self.assertListEqual(tokenizer.convert_tokens_to_ids(a__      )				,			a__      )


      def    a (self       :      Dict      ):





         """simple docstring"""



         __snake_case							       =   self.get_tokenizer()

         self.assertListEqual(tokenizer.encode('''Hello world!'''				,			add_special_tokens=a__      )				,			[0, 3_1414, 232, 328, 2]      )
         self.assertListEqual(
             tokenizer.encode('''Hello world! cécé herlolip 418'''				,			add_special_tokens=a__      )				,			[0, 3_1414, 232, 328, 740, 1140, 1_2695, 69, 4_6078, 1588, 2]				,			)


      @slow
      def    a (self       :      Any      ):





         """simple docstring"""



         __snake_case							       =   self.tokenizer_class.from_pretrained('''allenai/longformer-base-4096'''      )

         __snake_case							       =   tokenizer.encode('''sequence builders'''				,			add_special_tokens=a__      )
         __snake_case							       =   tokenizer.encode('''multi-sequence build'''				,			add_special_tokens=a__      )

         __snake_case							       =   tokenizer.encode(
             '''sequence builders'''				,			add_special_tokens=a__				,			add_prefix_space=a__      )
         __snake_case							       =   tokenizer.encode(
             '''sequence builders'''				,			'''multi-sequence build'''				,			add_special_tokens=a__				,			add_prefix_space=a__      )

         __snake_case							       =   tokenizer.build_inputs_with_special_tokens(a__      )
         __snake_case							       =   tokenizer.build_inputs_with_special_tokens(a__				,			a__      )

         assert encoded_sentence == encoded_text_from_decode
         assert encoded_pair == encoded_pair_from_decode


      def    a (self       :      Dict      ):





         """simple docstring"""



         __snake_case							       =   self.get_tokenizer()

         __snake_case							       =   '''Encode this sequence.'''
         __snake_case							       =   tokenizer.byte_encoder[''' '''.encode('''utf-8'''      )[0]]

         # Testing encoder arguments
         __snake_case							       =   tokenizer.encode(a__				,			add_special_tokens=a__				,			add_prefix_space=a__      )
         __snake_case							       =   tokenizer.convert_ids_to_tokens(encoded[0]      )[0]
         self.assertNotEqual(a__				,			a__      )

         __snake_case							       =   tokenizer.encode(a__				,			add_special_tokens=a__				,			add_prefix_space=a__      )
         __snake_case							       =   tokenizer.convert_ids_to_tokens(encoded[0]      )[0]
         self.assertEqual(a__				,			a__      )

         tokenizer.add_special_tokens({'''bos_token''': '''<s>'''}      )
         __snake_case							       =   tokenizer.encode(a__				,			add_special_tokens=a__      )
         __snake_case							       =   tokenizer.convert_ids_to_tokens(encoded[1]      )[0]
         self.assertNotEqual(a__				,			a__      )

         # Testing spaces after special tokens
         __snake_case							       =   '''<mask>'''
         tokenizer.add_special_tokens(
             {'''mask_token''': AddedToken(a__				,			lstrip=a__				,			rstrip=a__      )}      )  # mask token has a left space
         __snake_case							       =   tokenizer.convert_tokens_to_ids(a__      )

         __snake_case							       =   '''Encode <mask> sequence'''
         __snake_case							       =   '''Encode <mask>sequence'''

         __snake_case							       =   tokenizer.encode(a__      )
         __snake_case							       =   encoded.index(a__      )
         __snake_case							       =   tokenizer.convert_ids_to_tokens(encoded[mask_loc + 1]      )[0]
         self.assertEqual(a__				,			a__      )

         __snake_case							       =   tokenizer.encode(a__      )
         __snake_case							       =   encoded.index(a__      )
         __snake_case							       =   tokenizer.convert_ids_to_tokens(encoded[mask_loc + 1]      )[0]
         self.assertNotEqual(a__				,			a__      )


      def    a (self       :      Tuple      ):





         """simple docstring"""



         pass


      def    a (self       :      str      ):





         """simple docstring"""



         for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
            with self.subTest(f"""{tokenizer.__class__.__name__} ({pretrained_name})"""      ):
               __snake_case							       =   self.rust_tokenizer_class.from_pretrained(a__				,			**a__      )
               __snake_case							       =   self.tokenizer_class.from_pretrained(a__				,			**a__      )
               __snake_case							       =   '''A, <mask> AllenNLP sentence.'''
               __snake_case							       =   tokenizer_r.encode_plus(a__				,			add_special_tokens=a__				,			return_token_type_ids=a__      )
               __snake_case							       =   tokenizer_p.encode_plus(a__				,			add_special_tokens=a__				,			return_token_type_ids=a__      )

               # token_type_ids should put 0 everywhere
               self.assertEqual(sum(tokens_r['''token_type_ids''']      )				,			sum(tokens_p['''token_type_ids''']      )      )

               # attention_mask should put 1 everywhere, so sum over length should be 1
               self.assertEqual(
                   sum(tokens_r['''attention_mask''']      ) / len(tokens_r['''attention_mask''']      )				,			sum(tokens_p['''attention_mask''']      ) / len(tokens_p['''attention_mask''']      )				,			)

               __snake_case							       =   tokenizer_r.convert_ids_to_tokens(tokens_r['''input_ids''']      )
               __snake_case							       =   tokenizer_p.convert_ids_to_tokens(tokens_p['''input_ids''']      )

               # Rust correctly handles the space before the mask while python doesnt
               self.assertSequenceEqual(tokens_p['''input_ids''']				,			[0, 250, 6, 5_0264, 3823, 487, 2_1992, 3645, 4, 2]      )
               self.assertSequenceEqual(tokens_r['''input_ids''']				,			[0, 250, 6, 5_0264, 3823, 487, 2_1992, 3645, 4, 2]      )

               self.assertSequenceEqual(
                   a__				,			['''<s>''', '''A''', ''',''', '''<mask>''', '''ĠAllen''', '''N''', '''LP''', '''Ġsentence''', '''.''', '''</s>''']      )
               self.assertSequenceEqual(
                   a__				,			['''<s>''', '''A''', ''',''', '''<mask>''', '''ĠAllen''', '''N''', '''LP''', '''Ġsentence''', '''.''', '''</s>''']      )


      def    a (self       :      str      ):





         """simple docstring"""



         for trim_offsets, add_prefix_space in itertools.product([True, False]				,			repeat=2      ):
            __snake_case							       =   self.rust_tokenizer_class.from_pretrained(
                self.tmpdirname				,			use_fast=a__				,			add_prefix_space=a__				,			trim_offsets=a__      )

            __snake_case							       =   json.loads(tokenizer_r.backend_tokenizer.pre_tokenizer.__getstate__()      )
            __snake_case							       =   json.loads(tokenizer_r.backend_tokenizer.post_processor.__getstate__()      )

            self.assertEqual(pre_tokenizer_state['''add_prefix_space''']				,			a__      )

            self.assertEqual(post_processor_state['''add_prefix_space''']				,			a__      )
            self.assertEqual(post_processor_state['''trim_offsets''']				,			a__      )


      def    a (self       :      Optional[int]      ):





         """simple docstring"""



         for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
            with self.subTest(f"""{tokenizer.__class__.__name__} ({pretrained_name})"""      ):
               __snake_case							       =   '''hello'''  # `hello` is a token in the vocabulary of `pretrained_name`
               __snake_case							       =   f"""{text_of_1_token} {text_of_1_token}"""

               __snake_case							       =   self.rust_tokenizer_class.from_pretrained(
                   a__				,			use_fast=a__				,			add_prefix_space=a__				,			trim_offsets=a__      )
               __snake_case							       =   tokenizer_r(a__				,			return_offsets_mapping=a__				,			add_special_tokens=a__      )
               self.assertEqual(encoding.offset_mapping[0]				,			(0, len(a__      ))      )
               self.assertEqual(
                   encoding.offset_mapping[1]				,			(len(a__      ) + 1, len(a__      ) + 1 + len(a__      ))				,			)

               __snake_case							       =   self.rust_tokenizer_class.from_pretrained(
                   a__				,			use_fast=a__				,			add_prefix_space=a__				,			trim_offsets=a__      )
               __snake_case							       =   tokenizer_r(a__				,			return_offsets_mapping=a__				,			add_special_tokens=a__      )
               self.assertEqual(encoding.offset_mapping[0]				,			(0, len(a__      ))      )
               self.assertEqual(
                   encoding.offset_mapping[1]				,			(len(a__      ) + 1, len(a__      ) + 1 + len(a__      ))				,			)

               __snake_case							       =   self.rust_tokenizer_class.from_pretrained(
                   a__				,			use_fast=a__				,			add_prefix_space=a__				,			trim_offsets=a__      )
               __snake_case							       =   tokenizer_r(a__				,			return_offsets_mapping=a__				,			add_special_tokens=a__      )
               self.assertEqual(encoding.offset_mapping[0]				,			(0, len(a__      ))      )
               self.assertEqual(
                   encoding.offset_mapping[1]				,			(len(a__      ), len(a__      ) + 1 + len(a__      ))				,			)

               __snake_case							       =   self.rust_tokenizer_class.from_pretrained(
                   a__				,			use_fast=a__				,			add_prefix_space=a__				,			trim_offsets=a__      )
               __snake_case							       =   tokenizer_r(a__				,			return_offsets_mapping=a__				,			add_special_tokens=a__      )
               self.assertEqual(encoding.offset_mapping[0]				,			(0, len(a__      ))      )
               self.assertEqual(
                   encoding.offset_mapping[1]				,			(len(a__      ), len(a__      ) + 1 + len(a__      ))				,			)

               __snake_case							       =   f""" {text}"""

               # tokenizer_r = self.rust_tokenizer_class.from_pretrained(
               #     pretrained_name, use_fast=True, add_prefix_space=True, trim_offsets=True
               # )
               # encoding = tokenizer_r(text, return_offsets_mapping=True, add_special_tokens=False)
               # self.assertEqual(encoding.offset_mapping[0], (1, 1 + len(text_of_1_token)))
               # self.assertEqual(
               #     encoding.offset_mapping[1],
               #     (1 + len(text_of_1_token) + 1, 1 + len(text_of_1_token) + 1 + len(text_of_1_token)),
               # )

               __snake_case							       =   self.rust_tokenizer_class.from_pretrained(
                   a__				,			use_fast=a__				,			add_prefix_space=a__				,			trim_offsets=a__      )
               __snake_case							       =   tokenizer_r(a__				,			return_offsets_mapping=a__				,			add_special_tokens=a__      )
               self.assertEqual(encoding.offset_mapping[0]				,			(1, 1 + len(a__      ))      )
               self.assertEqual(
                   encoding.offset_mapping[1]				,			(1 + len(a__      ) + 1, 1 + len(a__      ) + 1 + len(a__      ))				,			)

               __snake_case							       =   self.rust_tokenizer_class.from_pretrained(
                   a__				,			use_fast=a__				,			add_prefix_space=a__				,			trim_offsets=a__      )
               __snake_case							       =   tokenizer_r(a__				,			return_offsets_mapping=a__				,			add_special_tokens=a__      )
               self.assertEqual(encoding.offset_mapping[0]				,			(0, 1 + len(a__      ))      )
               self.assertEqual(
                   encoding.offset_mapping[1]				,			(1 + len(a__      ), 1 + len(a__      ) + 1 + len(a__      ))				,			)

               __snake_case							       =   self.rust_tokenizer_class.from_pretrained(
                   a__				,			use_fast=a__				,			add_prefix_space=a__				,			trim_offsets=a__      )
               __snake_case							       =   tokenizer_r(a__				,			return_offsets_mapping=a__				,			add_special_tokens=a__      )
               self.assertEqual(encoding.offset_mapping[0]				,			(0, 1 + len(a__      ))      )
               self.assertEqual(
                   encoding.offset_mapping[1]				,			(1 + len(a__      ), 1 + len(a__      ) + 1 + len(a__      ))				,			)








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    a (*a__       :      List[str]				,			**a__       :      List[str]      ):





             """simple docstring"""



             pass






    def lowerCamelCase__    (							snake_case_	:  int       )      ->				Optional[int]:
       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.
snake_case_				=			(
    'https://huggingface.co/spaces/impira/docquery/resolve/2f6c96314dc84dfda62d40de9da55f2f5165d403/invoice.png'
)

@is_pipeline_test
@require_torch
@require_vision
class 		SCREAMING_SNAKE_CASE__				(       unittest.TestCase  ):
      A_						:				Optional[Any]							=    MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING


      @require_pytesseract
      @require_vision
      def    a (self       :      List[Any]				,			a__       :      Tuple				,			a__       :      Union[str, Any]				,			a__       :      Any      ):





         """simple docstring"""



         __snake_case							       =   pipeline(
             '''document-question-answering'''				,			model=a__				,			tokenizer=a__				,			image_processor=a__      )

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


      def    a (self       :      Union[str, Any]				,			a__       :      Optional[int]				,			a__       :      Dict      ):





         """simple docstring"""



         __snake_case							       =   dqa_pipeline(a__				,			top_k=2      )
         self.assertEqual(
             a__				,			[
                 [
                     {'''score''': ANY(a__      ), '''answer''': ANY(a__      ), '''start''': ANY(a__      ), '''end''': ANY(a__      )},
                     {'''score''': ANY(a__      ), '''answer''': ANY(a__      ), '''start''': ANY(a__      ), '''end''': ANY(a__      )},
                 ]
             ]
             * 3				,			)


      @require_torch
      @require_detectrona
      @require_pytesseract
      def    a (self       :      Dict      ):





         """simple docstring"""



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

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

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

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

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


      @slow
      @require_torch
      @require_detectrona
      @require_pytesseract
      def    a (self       :      str      ):





         """simple docstring"""



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

         __snake_case							       =   dqa_pipeline(image=a__				,			question=a__				,			top_k=2      )
         self.assertEqual(
             nested_simplify(a__				,			decimals=4      )				,			[
                 {'''score''': 0.9_9_4_4, '''answer''': '''us-001''', '''start''': 16, '''end''': 16},
                 {'''score''': 0.0_0_0_9, '''answer''': '''us-001''', '''start''': 16, '''end''': 16},
             ]				,			)

         __snake_case							       =   dqa_pipeline({'''image''': image, '''question''': question}				,			top_k=2      )
         self.assertEqual(
             nested_simplify(a__				,			decimals=4      )				,			[
                 {'''score''': 0.9_9_4_4, '''answer''': '''us-001''', '''start''': 16, '''end''': 16},
                 {'''score''': 0.0_0_0_9, '''answer''': '''us-001''', '''start''': 16, '''end''': 16},
             ]				,			)

         __snake_case							       =   dqa_pipeline(
             [{'''image''': image, '''question''': question}, {'''image''': image, '''question''': question}]				,			top_k=2      )
         self.assertEqual(
             nested_simplify(a__				,			decimals=4      )				,			[
                 [
                     {'''score''': 0.9_9_4_4, '''answer''': '''us-001''', '''start''': 16, '''end''': 16},
                     {'''score''': 0.0_0_0_9, '''answer''': '''us-001''', '''start''': 16, '''end''': 16},
                 ],
             ]
             * 2				,			)


      @slow
      @require_torch
      @require_detectrona
      @require_pytesseract
      def    a (self       :      List[Any]      ):





         """simple docstring"""



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

         __snake_case							       =   dqa_pipeline(image=a__				,			question=a__				,			top_k=2      )
         self.assertEqual(
             nested_simplify(a__				,			decimals=4      )				,			[
                 {'''score''': 0.9_9_7_4, '''answer''': '''1110212019''', '''start''': 23, '''end''': 23},
                 {'''score''': 0.9_9_4_8, '''answer''': '''us-001''', '''start''': 16, '''end''': 16},
             ]				,			)

         __snake_case							       =   dqa_pipeline({'''image''': image, '''question''': question}				,			top_k=2      )
         self.assertEqual(
             nested_simplify(a__				,			decimals=4      )				,			[
                 {'''score''': 0.9_9_7_4, '''answer''': '''1110212019''', '''start''': 23, '''end''': 23},
                 {'''score''': 0.9_9_4_8, '''answer''': '''us-001''', '''start''': 16, '''end''': 16},
             ]				,			)

         __snake_case							       =   dqa_pipeline(
             [{'''image''': image, '''question''': question}, {'''image''': image, '''question''': question}]				,			top_k=2      )
         self.assertEqual(
             nested_simplify(a__				,			decimals=4      )				,			[
                 [
                     {'''score''': 0.9_9_7_4, '''answer''': '''1110212019''', '''start''': 23, '''end''': 23},
                     {'''score''': 0.9_9_4_8, '''answer''': '''us-001''', '''start''': 16, '''end''': 16},
                 ]
             ]
             * 2				,			)


      @slow
      @require_torch
      @require_pytesseract
      @require_vision
      def    a (self       :      Tuple      ):





         """simple docstring"""



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

         __snake_case							       =   dqa_pipeline(image=a__				,			question=a__				,			top_k=2      )
         self.assertEqual(
             nested_simplify(a__				,			decimals=4      )				,			[
                 {'''score''': 0.4_2_5_1, '''answer''': '''us-001''', '''start''': 16, '''end''': 16},
                 {'''score''': 0.0_8_1_9, '''answer''': '''1110212019''', '''start''': 23, '''end''': 23},
             ]				,			)

         __snake_case							       =   dqa_pipeline({'''image''': image, '''question''': question}				,			top_k=2      )
         self.assertEqual(
             nested_simplify(a__				,			decimals=4      )				,			[
                 {'''score''': 0.4_2_5_1, '''answer''': '''us-001''', '''start''': 16, '''end''': 16},
                 {'''score''': 0.0_8_1_9, '''answer''': '''1110212019''', '''start''': 23, '''end''': 23},
             ]				,			)

         __snake_case							       =   dqa_pipeline(
             [{'''image''': image, '''question''': question}, {'''image''': image, '''question''': question}]				,			top_k=2      )
         self.assertEqual(
             nested_simplify(a__				,			decimals=4      )				,			[
                 [
                     {'''score''': 0.4_2_5_1, '''answer''': '''us-001''', '''start''': 16, '''end''': 16},
                     {'''score''': 0.0_8_1_9, '''answer''': '''1110212019''', '''start''': 23, '''end''': 23},
                 ]
             ]
             * 2				,			)

         __snake_case							       =   list(zip(*apply_tesseract(load_image(a__      )				,			a__				,			''''''      )      )      )

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


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





         """simple docstring"""



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

         __snake_case							       =   dqa_pipeline(image=a__				,			question=a__				,			top_k=2      )
         self.assertEqual(
             nested_simplify(a__				,			decimals=4      )				,			[
                 {'''score''': 0.9_9_9_9, '''answer''': '''us-001''', '''start''': 16, '''end''': 16},
                 {'''score''': 0.9_9_9_8, '''answer''': '''us-001''', '''start''': 16, '''end''': 16},
             ]				,			)

         __snake_case							       =   dqa_pipeline(
             [{'''image''': image, '''question''': question}, {'''image''': image, '''question''': question}]				,			top_k=2      )
         self.assertEqual(
             nested_simplify(a__				,			decimals=4      )				,			[
                 [
                     {'''score''': 0.9_9_9_9, '''answer''': '''us-001''', '''start''': 16, '''end''': 16},
                     {'''score''': 0.9_9_9_8, '''answer''': '''us-001''', '''start''': 16, '''end''': 16},
                 ]
             ]
             * 2				,			)

         __snake_case							       =   list(zip(*apply_tesseract(load_image(a__      )				,			a__				,			''''''      )      )      )

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


      @slow
      @require_torch
      def    a (self       :      Tuple      ):





         """simple docstring"""



         __snake_case							       =   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'''				,			)

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


      @require_tf
      @unittest.skip('''Document question answering not implemented in TF'''      )
      def    a (self       :      List[str]      ):





         """simple docstring"""



         pass

