
"""simple docstring"""


import json
import os
import sys
import tempfile
import unittest
from pathlib import Path
from shutil import copyfile

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

import transformers
from transformers import (
    CONFIG_MAPPING,
    FEATURE_EXTRACTOR_MAPPING,
    PROCESSOR_MAPPING,
    TOKENIZER_MAPPING,
    AutoConfig,
    AutoFeatureExtractor,
    AutoProcessor,
    AutoTokenizer,
    BertTokenizer,
    ProcessorMixin,
    WavaVecaConfig,
    WavaVecaFeatureExtractor,
    WavaVecaProcessor,
)
from transformers.testing_utils import TOKEN, USER, get_tests_dir, is_staging_test
from transformers.tokenization_utils import TOKENIZER_CONFIG_FILE
from transformers.utils import FEATURE_EXTRACTOR_NAME, is_tokenizers_available


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

from test_module.custom_configuration import CustomConfig  # noqa E402
from test_module.custom_feature_extraction import CustomFeatureExtractor  # noqa E402
from test_module.custom_processing import CustomProcessor  # noqa E402
from test_module.custom_tokenization import CustomTokenizer  # noqa E402


_lowercase							      = get_tests_dir('''fixtures/dummy_feature_extractor_config.json''')
_lowercase							      = get_tests_dir('''fixtures/vocab.json''')
_lowercase							      = get_tests_dir('''fixtures''')







class  lowerCAmelCase_ (					unittest.TestCase			):



						'''simple docstring'''


						_lowerCamelCase:			str					=			['''[UNK]''', '''[CLS]''', '''[SEP]''', '''[PAD]''', '''[MASK]''', '''bla''', '''blou''']


						def   _SCREAMING_SNAKE_CASE					(       self   :					Union[str, Any]					)   ->      Dict:
							A        =      0


						def   _SCREAMING_SNAKE_CASE					(       self   :					Tuple					)   ->      List[str]:
							A        =      AutoProcessor.from_pretrained('facebook/wav2vec2-base-960h'					)
							self.assertIsInstance(A_     ,A_					)


						def   _SCREAMING_SNAKE_CASE					(       self   :					Any					)   ->      str:
							with tempfile.TemporaryDirectory() as tmpdirname:
								A        =      WavaVecaConfig()
								A        =      AutoProcessor.from_pretrained('facebook/wav2vec2-base-960h'					)

								# save in new folder
								model_config.save_pretrained(A_					)
								processor.save_pretrained(A_					)

								A        =      AutoProcessor.from_pretrained(A_					)

							self.assertIsInstance(A_     ,A_					)


						def   _SCREAMING_SNAKE_CASE					(       self   :					Union[str, Any]					)   ->      Tuple:
							with tempfile.TemporaryDirectory() as tmpdirname:
								# copy relevant files
								copyfile(A_     ,os.path.join(A_     ,A_					)					)
								copyfile(A_     ,os.path.join(A_     ,'vocab.json'					)					)

								A        =      AutoProcessor.from_pretrained(A_					)

							self.assertIsInstance(A_     ,A_					)


						def   _SCREAMING_SNAKE_CASE					(       self   :					Union[str, Any]					)   ->      int:
							with tempfile.TemporaryDirectory() as tmpdirname:
								A        =      WavaVecaFeatureExtractor()
								A        =      AutoTokenizer.from_pretrained('facebook/wav2vec2-base-960h'					)

								A        =      WavaVecaProcessor(A_     ,A_					)

								# save in new folder
								processor.save_pretrained(A_					)

								# drop `processor_class` in tokenizer
								with open(os.path.join(A_     ,A_					)     ,'r'					) as f:
									A        =      json.load(A_					)
									config_dict.pop('processor_class'					)

								with open(os.path.join(A_     ,A_					)     ,'w'					) as f:
									f.write(json.dumps(A_					)					)

								A        =      AutoProcessor.from_pretrained(A_					)

							self.assertIsInstance(A_     ,A_					)


						def   _SCREAMING_SNAKE_CASE					(       self   :					Any					)   ->      Optional[Any]:
							with tempfile.TemporaryDirectory() as tmpdirname:
								A        =      WavaVecaFeatureExtractor()
								A        =      AutoTokenizer.from_pretrained('facebook/wav2vec2-base-960h'					)

								A        =      WavaVecaProcessor(A_     ,A_					)

								# save in new folder
								processor.save_pretrained(A_					)

								# drop `processor_class` in feature extractor
								with open(os.path.join(A_     ,A_					)     ,'r'					) as f:
									A        =      json.load(A_					)
									config_dict.pop('processor_class'					)

								with open(os.path.join(A_     ,A_					)     ,'w'					) as f:
									f.write(json.dumps(A_					)					)

								A        =      AutoProcessor.from_pretrained(A_					)

							self.assertIsInstance(A_     ,A_					)


						def   _SCREAMING_SNAKE_CASE					(       self   :					List[str]					)   ->      List[Any]:
							with tempfile.TemporaryDirectory() as tmpdirname:
								A        =      WavaVecaConfig(processor_class='Wav2Vec2Processor'					)
								model_config.save_pretrained(A_					)
								# copy relevant files
								copyfile(A_     ,os.path.join(A_     ,'vocab.json'					)					)
								# create emtpy sample processor
								with open(os.path.join(A_     ,A_					)     ,'w'					) as f:
									f.write('{}'					)

								A        =      AutoProcessor.from_pretrained(A_					)

							self.assertIsInstance(A_     ,A_					)


						def   _SCREAMING_SNAKE_CASE					(       self   :					Dict					)   ->      List[str]:
							# If remote code is not set, we will time out when asking whether to load the model.
							with self.assertRaises(A_					):
								A        =      AutoProcessor.from_pretrained('hf-internal-testing/test_dynamic_processor'					)
							# If remote code is disabled, we can't load this config.
							with self.assertRaises(A_					):
								A        =      AutoProcessor.from_pretrained(
								    'hf-internal-testing/test_dynamic_processor'     ,trust_remote_code=A_					)

							A        =      AutoProcessor.from_pretrained('hf-internal-testing/test_dynamic_processor'     ,trust_remote_code=A_					)
							self.assertTrue(processor.special_attribute_present					)
							self.assertEqual(processor.__class__.__name__     ,'NewProcessor'					)

							A        =      processor.feature_extractor
							self.assertTrue(feature_extractor.special_attribute_present					)
							self.assertEqual(feature_extractor.__class__.__name__     ,'NewFeatureExtractor'					)

							A        =      processor.tokenizer
							self.assertTrue(tokenizer.special_attribute_present					)
							if is_tokenizers_available():
								self.assertEqual(tokenizer.__class__.__name__     ,'NewTokenizerFast'					)

								# Test we can also load the slow version
								A        =      AutoProcessor.from_pretrained(
								    'hf-internal-testing/test_dynamic_processor'     ,trust_remote_code=A_     ,use_fast=A_					)
								A        =      new_processor.tokenizer
								self.assertTrue(new_tokenizer.special_attribute_present					)
								self.assertEqual(new_tokenizer.__class__.__name__     ,'NewTokenizer'					)
							else:
								self.assertEqual(tokenizer.__class__.__name__     ,'NewTokenizer'					)


						def   _SCREAMING_SNAKE_CASE					(       self   :					List[Any]					)   ->      Any:
							try:
								AutoConfig.register('custom'     ,A_					)
								AutoFeatureExtractor.register(A_     ,A_					)
								AutoTokenizer.register(A_     ,slow_tokenizer_class=A_					)
								AutoProcessor.register(A_     ,A_					)
								# Trying to register something existing in the Transformers library will raise an error
								with self.assertRaises(A_					):
									AutoProcessor.register(A_     ,A_					)

								# Now that the config is registered, it can be used as any other config with the auto-API
								A        =      CustomFeatureExtractor.from_pretrained(A_					)

								with tempfile.TemporaryDirectory() as tmp_dir:
									A        =      os.path.join(A_     ,'vocab.txt'					)
									with open(A_     ,'w'     ,encoding='utf-8'					) as vocab_writer:
										vocab_writer.write(''.join([x + '\n' for x in self.vocab_tokens]					)					)
									A        =      CustomTokenizer(A_					)

								A        =      CustomProcessor(A_     ,A_					)

								with tempfile.TemporaryDirectory() as tmp_dir:
									processor.save_pretrained(A_					)
									A        =      AutoProcessor.from_pretrained(A_					)
									self.assertIsInstance(A_     ,A_					)

							finally:
								if "custom" in CONFIG_MAPPING._extra_content:
									del CONFIG_MAPPING._extra_content["custom"]
								if CustomConfig in FEATURE_EXTRACTOR_MAPPING._extra_content:
									del FEATURE_EXTRACTOR_MAPPING._extra_content[CustomConfig]
								if CustomConfig in TOKENIZER_MAPPING._extra_content:
									del TOKENIZER_MAPPING._extra_content[CustomConfig]
								if CustomConfig in PROCESSOR_MAPPING._extra_content:
									del PROCESSOR_MAPPING._extra_content[CustomConfig]


						def   _SCREAMING_SNAKE_CASE					(       self   :					str					)   ->      Union[str, Any]:







							class  lowerCAmelCase_ (					_lowercase			):



													'''simple docstring'''


													_lowerCamelCase:			List[str]					=			False







							class  lowerCAmelCase_ (					_lowercase			):



													'''simple docstring'''


													_lowerCamelCase:			str					=			False







							class  lowerCAmelCase_ (					_lowercase			):



													'''simple docstring'''


													_lowerCamelCase:			Tuple					=			'''AutoFeatureExtractor'''
													_lowerCamelCase:			Tuple					=			'''AutoTokenizer'''
													_lowerCamelCase:			Optional[Any]					=			False

							try:
								AutoConfig.register('custom'     ,A_					)
								AutoFeatureExtractor.register(A_     ,A_					)
								AutoTokenizer.register(A_     ,slow_tokenizer_class=A_					)
								AutoProcessor.register(A_     ,A_					)
								# If remote code is not set, the default is to use local classes.
								A        =      AutoProcessor.from_pretrained('hf-internal-testing/test_dynamic_processor'					)
								self.assertEqual(processor.__class__.__name__     ,'NewProcessor'					)
								self.assertFalse(processor.special_attribute_present					)
								self.assertFalse(processor.feature_extractor.special_attribute_present					)
								self.assertFalse(processor.tokenizer.special_attribute_present					)

								# If remote code is disabled, we load the local ones.
								A        =      AutoProcessor.from_pretrained(
								    'hf-internal-testing/test_dynamic_processor'     ,trust_remote_code=A_					)
								self.assertEqual(processor.__class__.__name__     ,'NewProcessor'					)
								self.assertFalse(processor.special_attribute_present					)
								self.assertFalse(processor.feature_extractor.special_attribute_present					)
								self.assertFalse(processor.tokenizer.special_attribute_present					)

								# If remote is enabled, we load from the Hub.
								A        =      AutoProcessor.from_pretrained(
								    'hf-internal-testing/test_dynamic_processor'     ,trust_remote_code=A_					)
								self.assertEqual(processor.__class__.__name__     ,'NewProcessor'					)
								self.assertTrue(processor.special_attribute_present					)
								self.assertTrue(processor.feature_extractor.special_attribute_present					)
								self.assertTrue(processor.tokenizer.special_attribute_present					)

							finally:
								if "custom" in CONFIG_MAPPING._extra_content:
									del CONFIG_MAPPING._extra_content["custom"]
								if CustomConfig in FEATURE_EXTRACTOR_MAPPING._extra_content:
									del FEATURE_EXTRACTOR_MAPPING._extra_content[CustomConfig]
								if CustomConfig in TOKENIZER_MAPPING._extra_content:
									del TOKENIZER_MAPPING._extra_content[CustomConfig]
								if CustomConfig in PROCESSOR_MAPPING._extra_content:
									del PROCESSOR_MAPPING._extra_content[CustomConfig]


						def   _SCREAMING_SNAKE_CASE					(       self   :					Optional[Any]					)   ->      Optional[int]:
							A        =      AutoProcessor.from_pretrained('hf-internal-testing/tiny-random-bert'					)
							self.assertEqual(processor.__class__.__name__     ,'BertTokenizerFast'					)




						def   _SCREAMING_SNAKE_CASE					(       self   :					List[str]					)   ->      Optional[int]:
							A        =      AutoProcessor.from_pretrained('hf-internal-testing/tiny-random-convnext'					)
							self.assertEqual(processor.__class__.__name__     ,'ConvNextImageProcessor'					)







@is_staging_test
class  lowerCAmelCase_ (					unittest.TestCase			):



						'''simple docstring'''


						_lowerCamelCase:			Union[str, Any]					=			['''[UNK]''', '''[CLS]''', '''[SEP]''', '''[PAD]''', '''[MASK]''', '''bla''', '''blou''']


						@classmethod
						def   _SCREAMING_SNAKE_CASE					(       cls   :					Union[str, Any]					)   ->      Optional[Any]:
							A        =      TOKEN
							HfFolder.save_token(A_					)


						@classmethod
						def   _SCREAMING_SNAKE_CASE					(       cls   :					List[Any]					)   ->      Union[str, Any]:
							try:
								delete_repo(token=cls._token     ,repo_id='test-processor'					)
							except HTTPError:
								pass

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

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


						def   _SCREAMING_SNAKE_CASE					(       self   :					Dict					)   ->      Dict:
							A        =      WavaVecaProcessor.from_pretrained(A_					)
							with tempfile.TemporaryDirectory() as tmp_dir:
								processor.save_pretrained(
								    os.path.join(A_     ,'test-processor'					)     ,push_to_hub=A_     ,use_auth_token=self._token					)

								A        =      WavaVecaProcessor.from_pretrained(F'{USER}/test-processor'					)
								for k, v in processor.feature_extractor.__dict__.items():
									self.assertEqual(A_     ,getattr(new_processor.feature_extractor     ,A_					)					)
								self.assertDictEqual(new_processor.tokenizer.get_vocab()     ,processor.tokenizer.get_vocab()					)


						def   _SCREAMING_SNAKE_CASE					(       self   :					int					)   ->      Optional[int]:
							A        =      WavaVecaProcessor.from_pretrained(A_					)

							with tempfile.TemporaryDirectory() as tmp_dir:
								processor.save_pretrained(
								    os.path.join(A_     ,'test-processor-org'					)     ,push_to_hub=A_     ,use_auth_token=self._token     ,organization='valid_org'     ,)

								A        =      WavaVecaProcessor.from_pretrained('valid_org/test-processor-org'					)
								for k, v in processor.feature_extractor.__dict__.items():
									self.assertEqual(A_     ,getattr(new_processor.feature_extractor     ,A_					)					)
								self.assertDictEqual(new_processor.tokenizer.get_vocab()     ,processor.tokenizer.get_vocab()					)




						def   _SCREAMING_SNAKE_CASE					(       self   :					str					)   ->      Optional[Any]:
							CustomFeatureExtractor.register_for_auto_class()
							CustomTokenizer.register_for_auto_class()
							CustomProcessor.register_for_auto_class()

							A        =      CustomFeatureExtractor.from_pretrained(A_					)

							with tempfile.TemporaryDirectory() as tmp_dir:
								A        =      os.path.join(A_     ,'vocab.txt'					)
								with open(A_     ,'w'     ,encoding='utf-8'					) as vocab_writer:
									vocab_writer.write(''.join([x + '\n' for x in self.vocab_tokens]					)					)
								A        =      CustomTokenizer(A_					)

							A        =      CustomProcessor(A_     ,A_					)

							with tempfile.TemporaryDirectory() as tmp_dir:
								create_repo(F'{USER}/test-dynamic-processor'     ,token=self._token					)
								A        =      Repository(A_     ,clone_from=F'{USER}/test-dynamic-processor'     ,token=self._token					)
								processor.save_pretrained(A_					)

								# This has added the proper auto_map field to the feature extractor config
								self.assertDictEqual(
								    processor.feature_extractor.auto_map     ,{
								        'AutoFeatureExtractor': 'custom_feature_extraction.CustomFeatureExtractor',
								        'AutoProcessor': 'custom_processing.CustomProcessor',
								    }     ,)

								# This has added the proper auto_map field to the tokenizer config
								with open(os.path.join(A_     ,'tokenizer_config.json'					)					) as f:
									A        =      json.load(A_					)
								self.assertDictEqual(
								    tokenizer_config['auto_map']     ,{
								        'AutoTokenizer': ['custom_tokenization.CustomTokenizer', None],
								        'AutoProcessor': 'custom_processing.CustomProcessor',
								    }     ,)

								# The code has been copied from fixtures
								self.assertTrue(os.path.isfile(os.path.join(A_     ,'custom_feature_extraction.py'					)					)					)
								self.assertTrue(os.path.isfile(os.path.join(A_     ,'custom_tokenization.py'					)					)					)
								self.assertTrue(os.path.isfile(os.path.join(A_     ,'custom_processing.py'					)					)					)

								repo.push_to_hub()

							A        =      AutoProcessor.from_pretrained(F'{USER}/test-dynamic-processor'     ,trust_remote_code=A_					)
							# Can't make an isinstance check because the new_processor is from the CustomProcessor class of a dynamic module
							self.assertEqual(new_processor.__class__.__name__     ,'CustomProcessor'					)



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 		__magic_name__(       *lowerCAmelCase__			:Union[str, Any]			,			**lowerCAmelCase__			:str	)		->			Union[str, Any]:
																pass




						def        _UpperCamelCase							(      lowercase__      ):
												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        _lowercase      (			unittest.TestCase       ):






				'''simple docstring'''



				SCREAMING_SNAKE_CASE__				:			Tuple						=		MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING


				@require_pytesseract
				@require_vision
				def 		__magic_name__(       self			:Any			,			lowerCAmelCase__			:List[str]			,			lowerCAmelCase__			:Optional[Any]			,			lowerCAmelCase__			:Any	)		->			Any:
										__SCREAMING_SNAKE_CASE						:     Optional[int]					=		pipeline(
										    '''document-question-answering'''			,			model=lowerCAmelCase__			,			tokenizer=lowerCAmelCase__			,			image_processor=lowerCAmelCase__	)

										__SCREAMING_SNAKE_CASE						:     Dict					=		INVOICE_URL
										__SCREAMING_SNAKE_CASE						:     Optional[Any]					=		list(zip(*apply_tesseract(load_image(lowerCAmelCase__	)			,			lowerCAmelCase__			,			''''''	)	)	)
										__SCREAMING_SNAKE_CASE						:     str					=		'''What is the placebo?'''
										__SCREAMING_SNAKE_CASE						:     str					=		[
										    {
										        '''image''': load_image(lowerCAmelCase__	),
										        '''question''': question,
										    },
										    {
										        '''image''': image,
										        '''question''': question,
										    },
										    {
										        '''image''': image,
										        '''question''': question,
										        '''word_boxes''': word_boxes,
										    },
										]
										return dqa_pipeline, examples


				def 		__magic_name__(       self			:Optional[Any]			,			lowerCAmelCase__			:Tuple			,			lowerCAmelCase__			:Tuple	)		->			str:
										__SCREAMING_SNAKE_CASE						:     Any					=		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 		__magic_name__(       self			:Dict	)		->			List[str]:
										__SCREAMING_SNAKE_CASE						:     Tuple					=		pipeline('''document-question-answering'''			,			model='''hf-internal-testing/tiny-random-layoutlmv2'''	)
										__SCREAMING_SNAKE_CASE						:     Dict					=		INVOICE_URL
										__SCREAMING_SNAKE_CASE						:     int					=		'''How many cats are there?'''

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

										__SCREAMING_SNAKE_CASE						:     Dict					=		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
										__SCREAMING_SNAKE_CASE						:     Any					=		'''./tests/fixtures/tests_samples/COCO/000000039769.png'''
										__SCREAMING_SNAKE_CASE						:     List[Any]					=		dqa_pipeline(image=lowerCAmelCase__			,			question=lowerCAmelCase__			,			top_k=2	)
										self.assertEqual(lowerCAmelCase__			,			[]	)

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


				@slow
				@require_torch
				@require_detectrona
				@require_pytesseract
				def 		__magic_name__(       self			:int	)		->			Optional[Any]:
										__SCREAMING_SNAKE_CASE						:     List[Any]					=		pipeline(
										    '''document-question-answering'''			,			model='''tiennvcs/layoutlmv2-base-uncased-finetuned-docvqa'''			,			revision='''9977165'''			,			)
										__SCREAMING_SNAKE_CASE						:     Dict					=		INVOICE_URL
										__SCREAMING_SNAKE_CASE						:     Any					=		'''What is the invoice number?'''

										__SCREAMING_SNAKE_CASE						:     Any					=		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},
										    ]			,			)

										__SCREAMING_SNAKE_CASE						:     Tuple					=		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},
										    ]			,			)

										__SCREAMING_SNAKE_CASE						:     List[Any]					=		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 		__magic_name__(       self			:Optional[Any]	)		->			Any:
										__SCREAMING_SNAKE_CASE						:     int					=		pipeline(
										    '''document-question-answering'''			,			model='''tiennvcs/layoutlmv2-base-uncased-finetuned-docvqa'''			,			revision='''9977165'''			,			max_seq_len=50			,			)
										__SCREAMING_SNAKE_CASE						:     Union[str, Any]					=		INVOICE_URL
										__SCREAMING_SNAKE_CASE						:     Tuple					=		'''What is the invoice number?'''

										__SCREAMING_SNAKE_CASE						:     List[str]					=		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},
										    ]			,			)

										__SCREAMING_SNAKE_CASE						:     int					=		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},
										    ]			,			)

										__SCREAMING_SNAKE_CASE						:     str					=		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 		__magic_name__(       self			:int	)		->			List[Any]:
										__SCREAMING_SNAKE_CASE						:     List[Any]					=		AutoTokenizer.from_pretrained(
										    '''impira/layoutlm-document-qa'''			,			revision='''3dc6de3'''			,			add_prefix_space=lowerCAmelCase__	)
										__SCREAMING_SNAKE_CASE						:     Dict					=		pipeline(
										    '''document-question-answering'''			,			model='''impira/layoutlm-document-qa'''			,			tokenizer=lowerCAmelCase__			,			revision='''3dc6de3'''			,			)
										__SCREAMING_SNAKE_CASE						:     Union[str, Any]					=		INVOICE_URL
										__SCREAMING_SNAKE_CASE						:     str					=		'''What is the invoice number?'''

										__SCREAMING_SNAKE_CASE						:     Dict					=		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},
										    ]			,			)

										__SCREAMING_SNAKE_CASE						:     Union[str, Any]					=		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},
										    ]			,			)

										__SCREAMING_SNAKE_CASE						:     Union[str, Any]					=		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			,			)

										__SCREAMING_SNAKE_CASE						:     Optional[int]					=		list(zip(*apply_tesseract(load_image(lowerCAmelCase__	)			,			lowerCAmelCase__			,			''''''	)	)	)

										# This model should also work if `image` is set to None
										__SCREAMING_SNAKE_CASE						:     str					=		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 		__magic_name__(       self			:str	)		->			Dict:
										__SCREAMING_SNAKE_CASE						:     Optional[int]					=		AutoTokenizer.from_pretrained(
										    '''impira/layoutlm-document-qa'''			,			revision='''3dc6de3'''			,			add_prefix_space=lowerCAmelCase__	)
										__SCREAMING_SNAKE_CASE						:     Tuple					=		pipeline(
										    '''document-question-answering'''			,			model='''impira/layoutlm-document-qa'''			,			tokenizer=lowerCAmelCase__			,			revision='''3dc6de3'''			,			max_seq_len=50			,			)
										__SCREAMING_SNAKE_CASE						:     List[str]					=		INVOICE_URL
										__SCREAMING_SNAKE_CASE						:     Dict					=		'''What is the invoice number?'''

										__SCREAMING_SNAKE_CASE						:     List[Any]					=		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},
										    ]			,			)

										__SCREAMING_SNAKE_CASE						:     Optional[int]					=		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			,			)

										__SCREAMING_SNAKE_CASE						:     List[str]					=		list(zip(*apply_tesseract(load_image(lowerCAmelCase__	)			,			lowerCAmelCase__			,			''''''	)	)	)

										# This model should also work if `image` is set to None
										__SCREAMING_SNAKE_CASE						:     List[Any]					=		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 		__magic_name__(       self			:Union[str, Any]	)		->			Tuple:
										__SCREAMING_SNAKE_CASE						:     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'''			,			)

										__SCREAMING_SNAKE_CASE						:     Union[str, Any]					=		INVOICE_URL
										__SCREAMING_SNAKE_CASE						:     Optional[int]					=		'''What is the invoice number?'''
										__SCREAMING_SNAKE_CASE						:     Tuple					=		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 		__magic_name__(       self			:Union[str, Any]	)		->			Tuple:
										pass
