





'''simple docstring'''




import json
import os
import shutil
import sys
import tempfile
import unittest
import unittest.mock as mock
from pathlib import Path

from huggingface_hub import HfFolder, delete_repo
from requests.exceptions import HTTPError

from transformers import AutoConfig, BertConfig, GPTaConfig
from transformers.configuration_utils import PretrainedConfig
from transformers.testing_utils import TOKEN, USER, is_staging_test


sys.path.append(str(Path(__file__).parent.parent / '''utils'''))

from test_module.custom_configuration import CustomConfig  # noqa E402


lowercase__       : List[Any]         =       {
    '''return_dict''': False,
    '''output_hidden_states''': True,
    '''output_attentions''': True,
    '''torchscript''': True,
    '''torch_dtype''': '''float16''',
    '''use_bfloat16''': True,
    '''tf_legacy_loss''': True,
    '''pruned_heads''': {'''a''': 1},
    '''tie_word_embeddings''': False,
    '''is_decoder''': True,
    '''cross_attention_hidden_size''': 1_28,
    '''add_cross_attention''': True,
    '''tie_encoder_decoder''': True,
    '''max_length''': 50,
    '''min_length''': 3,
    '''do_sample''': True,
    '''early_stopping''': True,
    '''num_beams''': 3,
    '''num_beam_groups''': 3,
    '''diversity_penalty''': 0.5,
    '''temperature''': 2.0,
    '''top_k''': 10,
    '''top_p''': 0.7,
    '''typical_p''': 0.2,
    '''repetition_penalty''': 0.8,
    '''length_penalty''': 0.8,
    '''no_repeat_ngram_size''': 5,
    '''encoder_no_repeat_ngram_size''': 5,
    '''bad_words_ids''': [1, 2, 3],
    '''num_return_sequences''': 3,
    '''chunk_size_feed_forward''': 5,
    '''output_scores''': True,
    '''return_dict_in_generate''': True,
    '''forced_bos_token_id''': 2,
    '''forced_eos_token_id''': 3,
    '''remove_invalid_values''': True,
    '''architectures''': ['''BertModel'''],
    '''finetuning_task''': '''translation''',
    '''id2label''': {0: '''label'''},
    '''label2id''': {'''label''': '''0'''},
    '''tokenizer_class''': '''BertTokenizerFast''',
    '''prefix''': '''prefix''',
    '''bos_token_id''': 6,
    '''pad_token_id''': 7,
    '''eos_token_id''': 8,
    '''sep_token_id''': 9,
    '''decoder_start_token_id''': 10,
    '''exponential_decay_length_penalty''': (5, 1.01),
    '''suppress_tokens''': [0, 1],
    '''begin_suppress_tokens''': 2,
    '''task_specific_params''': {'''translation''': '''some_params'''},
    '''problem_type''': '''regression''',
}


@is_staging_test
class 					SCREAMING_SNAKE_CASE       (unittest.TestCase				):


     @classmethod
     def 				SCREAMING_SNAKE_CASE    (		cls):

          '''simple docstring'''






          __A		:					Any						=			TOKEN
          HfFolder.save_token(snake_case__)


     @classmethod
     def 				SCREAMING_SNAKE_CASE    (		cls):

          '''simple docstring'''






          try:
               delete_repo(token=cls._token		,      repo_id='test-config')
          except HTTPError:
               pass

          try:
               delete_repo(token=cls._token		,      repo_id='valid_org/test-config-org')
          except HTTPError:
               pass

          try:
               delete_repo(token=cls._token		,      repo_id='test-dynamic-config')
          except HTTPError:
               pass


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          __A		:					Optional[Any]						=			BertConfig(
              vocab_size=99		,      hidden_size=32		,      num_hidden_layers=5		,      num_attention_heads=4		,      intermediate_size=37)
          config.push_to_hub('test-config'		,      use_auth_token=self._token)

          __A		:					List[str]						=			BertConfig.from_pretrained(F'{USER}/test-config')
          for k, v in config.to_dict().items():
               if k != "transformers_version":
                    self.assertEqual(snake_case__		,      getattr(snake_case__		,      snake_case__))

        # Reset repo
          delete_repo(token=self._token		,      repo_id='test-config')

          # Push to hub via save_pretrained
          with tempfile.TemporaryDirectory() as tmp_dir:
               config.save_pretrained(snake_case__		,      repo_id='test-config'		,      push_to_hub=snake_case__		,      use_auth_token=self._token)

          __A		:					Optional[int]						=			BertConfig.from_pretrained(F'{USER}/test-config')
          for k, v in config.to_dict().items():
               if k != "transformers_version":
                    self.assertEqual(snake_case__		,      getattr(snake_case__		,      snake_case__))


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          __A		:					Any						=			BertConfig(
              vocab_size=99		,      hidden_size=32		,      num_hidden_layers=5		,      num_attention_heads=4		,      intermediate_size=37)
          config.push_to_hub('valid_org/test-config-org'		,      use_auth_token=self._token)

          __A		:					str						=			BertConfig.from_pretrained('valid_org/test-config-org')
          for k, v in config.to_dict().items():
               if k != "transformers_version":
                    self.assertEqual(snake_case__		,      getattr(snake_case__		,      snake_case__))

        # Reset repo
          delete_repo(token=self._token		,      repo_id='valid_org/test-config-org')

          # Push to hub via save_pretrained
          with tempfile.TemporaryDirectory() as tmp_dir:
               config.save_pretrained(
                   snake_case__		,      repo_id='valid_org/test-config-org'		,      push_to_hub=snake_case__		,      use_auth_token=self._token)

          __A		:					str						=			BertConfig.from_pretrained('valid_org/test-config-org')
          for k, v in config.to_dict().items():
               if k != "transformers_version":
                    self.assertEqual(snake_case__		,      getattr(snake_case__		,      snake_case__))


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          CustomConfig.register_for_auto_class()
          __A		:					Optional[int]						=			CustomConfig(attribute=42)

          config.push_to_hub('test-dynamic-config'		,      use_auth_token=self._token)

          # This has added the proper auto_map field to the config
          self.assertDictEqual(config.auto_map		,      {'AutoConfig': 'custom_configuration.CustomConfig'})

          __A		:					str						=			AutoConfig.from_pretrained(F'{USER}/test-dynamic-config'		,      trust_remote_code=snake_case__)
          # Can't make an isinstance check because the new_config is from the FakeConfig class of a dynamic module
          self.assertEqual(new_config.__class__.__name__		,      'CustomConfig')
          self.assertEqual(new_config.attribute		,      42)




class 					SCREAMING_SNAKE_CASE       (unittest.TestCase				):


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          __A		:					Dict						=			GPTaConfig()

          # attempt to modify each of int/float/bool/str config records and verify they were updated
          __A		:					Any						=			c.n_embd + 1  # int
          __A		:					Any						=			c.resid_pdrop + 1.0  # float
          __A		:					List[str]						=			not c.scale_attn_weights  # bool
          __A		:					int						=			c.summary_type + 'foo'  # str
          c.update_from_string(
              F'n_embd={n_embd},resid_pdrop={resid_pdrop},scale_attn_weights={scale_attn_weights},summary_type={summary_type}')
          self.assertEqual(snake_case__		,      c.n_embd		,      'mismatch for key: n_embd')
          self.assertEqual(snake_case__		,      c.resid_pdrop		,      'mismatch for key: resid_pdrop')
          self.assertEqual(snake_case__		,      c.scale_attn_weights		,      'mismatch for key: scale_attn_weights')
          self.assertEqual(snake_case__		,      c.summary_type		,      'mismatch for key: summary_type')


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          __A		:					List[Any]						=			PretrainedConfig()
          __A		:					Tuple						=			[key for key in base_config.__dict__ if key not in config_common_kwargs]
          # If this part of the test fails, you have arguments to addin config_common_kwargs above.
          self.assertListEqual(
              snake_case__		,      ['is_encoder_decoder', '_name_or_path', '_commit_hash', 'transformers_version'])
          __A		:					List[Any]						=			[key for key, value in config_common_kwargs.items() if value == getattr(snake_case__		,      snake_case__)]
          if len(snake_case__) > 0:
               raise ValueError(
                   'The following keys are set with the default values in'
                   ' `test_configuration_common.config_common_kwargs` pick another value for them:'
                   F' {", ".join(snake_case__)}.')


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          with self.assertRaises(snake_case__):
               # config is in subfolder, the following should not work without specifying the subfolder
               __A		:					Optional[int]						=			BertConfig.from_pretrained('hf-internal-testing/tiny-random-bert-subfolder')

          __A		:					Union[str, Any]						=			BertConfig.from_pretrained('hf-internal-testing/tiny-random-bert-subfolder'		,      subfolder='bert')

          self.assertIsNotNone(snake_case__)


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          __A		:					Dict						=			mock.Mock()
          __A		:					Optional[Any]						=			500
          __A		:					int						=			{}
          __A		:					int						=			HTTPError
          __A		:					str						=			{}

          # Download this model to make sure it's in the cache.
          __A		:					Dict						=			BertConfig.from_pretrained('hf-internal-testing/tiny-random-bert')

          # Under the mock environment we get a 500 error when trying to reach the model.
          with mock.patch('requests.Session.request'		,      return_value=snake_case__) as mock_head:
               __A		:					str						=			BertConfig.from_pretrained('hf-internal-testing/tiny-random-bert')
               # This check we did call the fake head request
               mock_head.assert_called()


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          __A		:					Optional[int]						=			BertConfig.from_pretrained(
              'https://huggingface.co/hf-internal-testing/tiny-random-bert/resolve/main/config.json')


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          __A		:					str						=			AutoConfig.from_pretrained('bert-base-cased')
          __A		:					List[Any]						=			['config.4.0.0.json']

          with tempfile.TemporaryDirectory() as tmp_dir:
               configuration.save_pretrained(snake_case__)
               __A		:					Tuple						=			2
               json.dump(configuration.to_dict()		,      open(os.path.join(snake_case__		,      'config.4.0.0.json')		,      'w'))

               # This should pick the new configuration file as the version of Transformers is > 4.0.0
               __A		:					Tuple						=			AutoConfig.from_pretrained(snake_case__)
               self.assertEqual(new_configuration.hidden_size		,      2)

               # Will need to be adjusted if we reach v42 and this test is still here.
               # Should pick the old configuration file as the version of Transformers is < 4.42.0
               __A		:					Dict						=			['config.42.0.0.json']
               __A		:					str						=			768
               configuration.save_pretrained(snake_case__)
               shutil.move(os.path.join(snake_case__		,      'config.4.0.0.json')		,      os.path.join(snake_case__		,      'config.42.0.0.json'))
               __A		:					int						=			AutoConfig.from_pretrained(snake_case__)
               self.assertEqual(new_configuration.hidden_size		,      768)


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          __A		:					Tuple						=			'hf-internal-testing/test-two-configs'

          import transformers as new_transformers

          __A		:					int						=			'v4.0.0'
          __A					,__A		:					List[Any]						=			new_transformers.models.auto.AutoConfig.from_pretrained(
              snake_case__		,      return_unused_kwargs=snake_case__)
          self.assertEqual(new_configuration.hidden_size		,      2)
          # This checks `_configuration_file` ia not kept in the kwargs by mistake.
          self.assertDictEqual(snake_case__		,      {})

          # Testing an older version by monkey-patching the version in the module it's used.
          import transformers as old_transformers

          __A		:					List[str]						=			'v3.0.0'
          __A		:					List[str]						=			old_transformers.models.auto.AutoConfig.from_pretrained(snake_case__)
          self.assertEqual(old_configuration.hidden_size		,      768)
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     lowerCAmelCase__     :


						'''simple docstring'''






						@staticmethod
						def   _snake_case       (       *snake_case__     :     Optional[int]     ,  **snake_case__     :     Tuple		)      ->	Optional[Any]:
								pass



				def 	lowerCamelCase					(	UpperCamelCase     :				str							)   ->    Tuple:
						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.
A						=			(
    'https://huggingface.co/spaces/impira/docquery/resolve/2f6c96314dc84dfda62d40de9da55f2f5165d403/invoice.png'
)





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


		'''simple docstring'''






		lowerCAmelCase_     =   MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING
		@require_pytesseract
		@require_vision
		def   _snake_case       (       self     :     str     ,  snake_case__     :     Optional[Any]     ,  snake_case__     :     Any     ,  snake_case__     :     Union[str, Any]		)      ->	Dict:
				_lowerCamelCase				   =  pipeline(
				    'document-question-answering'     ,  model=snake_case__     ,  tokenizer=snake_case__     ,  image_processor=snake_case__		)

				_lowerCamelCase				   =  INVOICE_URL
				_lowerCamelCase				   =  list(zip(*apply_tesseract(load_image(snake_case__		)     ,  snake_case__     ,  ''		)		)		)
				_lowerCamelCase				   =  'What is the placebo?'
				_lowerCamelCase				   =  [
				    {
				        'image': load_image(snake_case__		),
				        'question': question,
				    },
				    {
				        'image': image,
				        'question': question,
				    },
				    {
				        'image': image,
				        'question': question,
				        'word_boxes': word_boxes,
				    },
				]
				return dqa_pipeline, examples
		def   _snake_case       (       self     :     Union[str, Any]     ,  snake_case__     :     Union[str, Any]     ,  snake_case__     :     List[Any]		)      ->	Tuple:
				_lowerCamelCase				   =  dqa_pipeline(snake_case__     ,  top_k=2		)
				self.assertEqual(
				    snake_case__     ,  [
				        [
				            {'score': ANY(snake_case__		), 'answer': ANY(snake_case__		), 'start': ANY(snake_case__		), 'end': ANY(snake_case__		)},
				            {'score': ANY(snake_case__		), 'answer': ANY(snake_case__		), 'start': ANY(snake_case__		), 'end': ANY(snake_case__		)},
				        ]
				    ]
				    * 3     ,  )
		@require_torch
		@require_detectrona
		@require_pytesseract
		def   _snake_case       (       self     :     Union[str, Any]		)      ->	Optional[int]:
				_lowerCamelCase				   =  pipeline('document-question-answering'     ,  model='hf-internal-testing/tiny-random-layoutlmv2'		)
				_lowerCamelCase				   =  INVOICE_URL
				_lowerCamelCase				   =  'How many cats are there?'

				_lowerCamelCase				   =  [
				    {'score': 0.0001, 'answer': 'oy 2312/2019', 'start': 3_8, 'end': 3_9},
				    {'score': 0.0001, 'answer': 'oy 2312/2019 DUE', 'start': 3_8, 'end': 4_0},
				]
				_lowerCamelCase				   =  dqa_pipeline(image=snake_case__     ,  question=snake_case__     ,  top_k=2		)
				self.assertEqual(nested_simplify(snake_case__     ,  decimals=4		)     ,  snake_case__		)

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

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

				# We can optionnally pass directly the words and bounding boxes
				_lowerCamelCase				   =  './tests/fixtures/tests_samples/COCO/000000039769.png'
				_lowerCamelCase				   =  []
				_lowerCamelCase				   =  []
				_lowerCamelCase				   =  dqa_pipeline(image=snake_case__     ,  question=snake_case__     ,  words=snake_case__     ,  boxes=snake_case__     ,  top_k=2		)
				self.assertEqual(snake_case__     ,  []		)
		@slow
		@require_torch
		@require_detectrona
		@require_pytesseract
		def   _snake_case       (       self     :     Optional[int]		)      ->	List[Any]:
				_lowerCamelCase				   =  pipeline(
				    'document-question-answering'     ,  model='tiennvcs/layoutlmv2-base-uncased-finetuned-docvqa'     ,  revision='9977165'     ,  )
				_lowerCamelCase				   =  INVOICE_URL
				_lowerCamelCase				   =  'What is the invoice number?'

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

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

				_lowerCamelCase				   =  dqa_pipeline(
				    [{'image': image, 'question': question}, {'image': image, 'question': question}]     ,  top_k=2		)
				self.assertEqual(
				    nested_simplify(snake_case__     ,  decimals=4		)     ,  [
				        [
				            {'score': 0.9944, 'answer': 'us-001', 'start': 1_6, 'end': 1_6},
				            {'score': 0.0009, 'answer': 'us-001', 'start': 1_6, 'end': 1_6},
				        ],
				    ]
				    * 2     ,  )
		@slow
		@require_torch
		@require_detectrona
		@require_pytesseract
		def   _snake_case       (       self     :     int		)      ->	Optional[Any]:
				_lowerCamelCase				   =  pipeline(
				    'document-question-answering'     ,  model='tiennvcs/layoutlmv2-base-uncased-finetuned-docvqa'     ,  revision='9977165'     ,  max_seq_len=5_0     ,  )
				_lowerCamelCase				   =  INVOICE_URL
				_lowerCamelCase				   =  'What is the invoice number?'

				_lowerCamelCase				   =  dqa_pipeline(image=snake_case__     ,  question=snake_case__     ,  top_k=2		)
				self.assertEqual(
				    nested_simplify(snake_case__     ,  decimals=4		)     ,  [
				        {'score': 0.9974, 'answer': '1110212019', 'start': 2_3, 'end': 2_3},
				        {'score': 0.9948, 'answer': 'us-001', 'start': 1_6, 'end': 1_6},
				    ]     ,  )

				_lowerCamelCase				   =  dqa_pipeline({'image': image, 'question': question}     ,  top_k=2		)
				self.assertEqual(
				    nested_simplify(snake_case__     ,  decimals=4		)     ,  [
				        {'score': 0.9974, 'answer': '1110212019', 'start': 2_3, 'end': 2_3},
				        {'score': 0.9948, 'answer': 'us-001', 'start': 1_6, 'end': 1_6},
				    ]     ,  )

				_lowerCamelCase				   =  dqa_pipeline(
				    [{'image': image, 'question': question}, {'image': image, 'question': question}]     ,  top_k=2		)
				self.assertEqual(
				    nested_simplify(snake_case__     ,  decimals=4		)     ,  [
				        [
				            {'score': 0.9974, 'answer': '1110212019', 'start': 2_3, 'end': 2_3},
				            {'score': 0.9948, 'answer': 'us-001', 'start': 1_6, 'end': 1_6},
				        ]
				    ]
				    * 2     ,  )
		@slow
		@require_torch
		@require_pytesseract
		@require_vision
		def   _snake_case       (       self     :     int		)      ->	List[Any]:
				_lowerCamelCase				   =  AutoTokenizer.from_pretrained(
				    'impira/layoutlm-document-qa'     ,  revision='3dc6de3'     ,  add_prefix_space=snake_case__		)
				_lowerCamelCase				   =  pipeline(
				    'document-question-answering'     ,  model='impira/layoutlm-document-qa'     ,  tokenizer=snake_case__     ,  revision='3dc6de3'     ,  )
				_lowerCamelCase				   =  INVOICE_URL
				_lowerCamelCase				   =  'What is the invoice number?'

				_lowerCamelCase				   =  dqa_pipeline(image=snake_case__     ,  question=snake_case__     ,  top_k=2		)
				self.assertEqual(
				    nested_simplify(snake_case__     ,  decimals=4		)     ,  [
				        {'score': 0.4251, 'answer': 'us-001', 'start': 1_6, 'end': 1_6},
				        {'score': 0.0819, 'answer': '1110212019', 'start': 2_3, 'end': 2_3},
				    ]     ,  )

				_lowerCamelCase				   =  dqa_pipeline({'image': image, 'question': question}     ,  top_k=2		)
				self.assertEqual(
				    nested_simplify(snake_case__     ,  decimals=4		)     ,  [
				        {'score': 0.4251, 'answer': 'us-001', 'start': 1_6, 'end': 1_6},
				        {'score': 0.0819, 'answer': '1110212019', 'start': 2_3, 'end': 2_3},
				    ]     ,  )

				_lowerCamelCase				   =  dqa_pipeline(
				    [{'image': image, 'question': question}, {'image': image, 'question': question}]     ,  top_k=2		)
				self.assertEqual(
				    nested_simplify(snake_case__     ,  decimals=4		)     ,  [
				        [
				            {'score': 0.4251, 'answer': 'us-001', 'start': 1_6, 'end': 1_6},
				            {'score': 0.0819, 'answer': '1110212019', 'start': 2_3, 'end': 2_3},
				        ]
				    ]
				    * 2     ,  )

				_lowerCamelCase				   =  list(zip(*apply_tesseract(load_image(snake_case__		)     ,  snake_case__     ,  ''		)		)		)

				# This model should also work if `image` is set to None
				_lowerCamelCase				   =  dqa_pipeline({'image': None, 'word_boxes': word_boxes, 'question': question}     ,  top_k=2		)
				self.assertEqual(
				    nested_simplify(snake_case__     ,  decimals=4		)     ,  [
				        {'score': 0.4251, 'answer': 'us-001', 'start': 1_6, 'end': 1_6},
				        {'score': 0.0819, 'answer': '1110212019', 'start': 2_3, 'end': 2_3},
				    ]     ,  )
		@slow
		@require_torch
		@require_pytesseract
		@require_vision
		def   _snake_case       (       self     :     Dict		)      ->	List[str]:
				_lowerCamelCase				   =  AutoTokenizer.from_pretrained(
				    'impira/layoutlm-document-qa'     ,  revision='3dc6de3'     ,  add_prefix_space=snake_case__		)
				_lowerCamelCase				   =  pipeline(
				    'document-question-answering'     ,  model='impira/layoutlm-document-qa'     ,  tokenizer=snake_case__     ,  revision='3dc6de3'     ,  max_seq_len=5_0     ,  )
				_lowerCamelCase				   =  INVOICE_URL
				_lowerCamelCase				   =  'What is the invoice number?'

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

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

				_lowerCamelCase				   =  list(zip(*apply_tesseract(load_image(snake_case__		)     ,  snake_case__     ,  ''		)		)		)

				# This model should also work if `image` is set to None
				_lowerCamelCase				   =  dqa_pipeline({'image': None, 'word_boxes': word_boxes, 'question': question}     ,  top_k=2		)
				self.assertEqual(
				    nested_simplify(snake_case__     ,  decimals=4		)     ,  [
				        {'score': 0.9999, 'answer': 'us-001', 'start': 1_6, 'end': 1_6},
				        {'score': 0.9998, 'answer': 'us-001', 'start': 1_6, 'end': 1_6},
				    ]     ,  )
		@slow
		@require_torch
		def   _snake_case       (       self     :     Dict		)      ->	int:
				_lowerCamelCase				   =  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'     ,  )

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



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