



"""simple docstring"""


import argparse
import json
import os

import fairseq
import torch
from fairseq.data import Dictionary

from transformers import (
    HubertConfig,
    HubertForCTC,
    HubertModel,
    WavaVecaCTCTokenizer,
    WavaVecaFeatureExtractor,
    WavaVecaProcessor,
    logging,
)


logging.set_verbosity_info()
__A   :							Optional[int]									=   logging.get_logger(__name__)

__A   :							int									=   {
    "post_extract_proj": "feature_projection.projection",
    "encoder.pos_conv.0": "encoder.pos_conv_embed.conv",
    "self_attn.k_proj": "encoder.layers.*.attention.k_proj",
    "self_attn.v_proj": "encoder.layers.*.attention.v_proj",
    "self_attn.q_proj": "encoder.layers.*.attention.q_proj",
    "self_attn.out_proj": "encoder.layers.*.attention.out_proj",
    "self_attn_layer_norm": "encoder.layers.*.layer_norm",
    "fc1": "encoder.layers.*.feed_forward.intermediate_dense",
    "fc2": "encoder.layers.*.feed_forward.output_dense",
    "final_layer_norm": "encoder.layers.*.final_layer_norm",
    "encoder.layer_norm": "encoder.layer_norm",
    "w2v_model.layer_norm": "feature_projection.layer_norm",
    "w2v_encoder.proj": "lm_head",
    "mask_emb": "masked_spec_embed",
}







def  lowercase	(      _SCREAMING_SNAKE_CASE   :						List[Any]					,     _SCREAMING_SNAKE_CASE   :						Dict					,     _SCREAMING_SNAKE_CASE   :						Union[str, Any]					,     _SCREAMING_SNAKE_CASE   :						Union[str, Any]					,     _SCREAMING_SNAKE_CASE   :						Optional[Any]				):






				'''simple docstring'''



				for attribute in key.split('''.'''				):
								_UpperCAmelCase					=    getattr(_SCREAMING_SNAKE_CASE					,     _SCREAMING_SNAKE_CASE				)

				if weight_type is not None:
								_UpperCAmelCase					=    getattr(_SCREAMING_SNAKE_CASE					,     _SCREAMING_SNAKE_CASE				).shape
				else:
								_UpperCAmelCase					=    hf_pointer.shape

				assert hf_shape == value.shape, (
				    f'Shape of hf {key + "." + weight_type if weight_type is not None else ""} is {hf_shape}, but should be'
				    f' {value.shape} for {full_name}'
				)

				if weight_type == "weight":
								_UpperCAmelCase					=    value
				elif weight_type == "weight_g":
								_UpperCAmelCase					=    value
				elif weight_type == "weight_v":
								_UpperCAmelCase					=    value
				elif weight_type == "bias":
								_UpperCAmelCase					=    value
				else:
								_UpperCAmelCase					=    value

				logger.info(f'{key + "." + weight_type if weight_type is not None else ""} was initialized from {full_name}.'				)







def  lowercase	(      _SCREAMING_SNAKE_CASE   :						int					,     _SCREAMING_SNAKE_CASE   :						Tuple					,     _SCREAMING_SNAKE_CASE   :						List[Any]				):






				'''simple docstring'''



				_UpperCAmelCase					=    []
				_UpperCAmelCase					=    fairseq_model.state_dict()

				_UpperCAmelCase					=    hf_model.hubert.feature_extractor if is_finetuned else hf_model.feature_extractor

				for name, value in fairseq_dict.items():
								_UpperCAmelCase					=    False
								if "conv_layers" in name:
												load_conv_layer(
												    _SCREAMING_SNAKE_CASE					,     _SCREAMING_SNAKE_CASE					,     _SCREAMING_SNAKE_CASE					,     _SCREAMING_SNAKE_CASE					,     hf_model.config.feat_extract_norm == '''group'''					,     )
												_UpperCAmelCase					=    True
								else:
												for key, mapped_key in MAPPING.items():
																_UpperCAmelCase					=    '''hubert.''' + mapped_key if (is_finetuned and mapped_key != '''lm_head''') else mapped_key

																if key in name or (key.split('''w2v_model.'''				)[-1] == name.split('''.'''				)[0] and not is_finetuned):
																				_UpperCAmelCase					=    True
																				if "*" in mapped_key:
																								_UpperCAmelCase					=    name.split(_SCREAMING_SNAKE_CASE				)[0].split('''.'''				)[-2]
																								_UpperCAmelCase					=    mapped_key.replace('''*'''					,     _SCREAMING_SNAKE_CASE				)
																				if "weight_g" in name:
																								_UpperCAmelCase					=    '''weight_g'''
																				elif "weight_v" in name:
																								_UpperCAmelCase					=    '''weight_v'''
																				elif "weight" in name:
																								_UpperCAmelCase					=    '''weight'''
																				elif "bias" in name:
																								_UpperCAmelCase					=    '''bias'''
																				else:
																								_UpperCAmelCase					=    None
																				set_recursively(_SCREAMING_SNAKE_CASE					,     _SCREAMING_SNAKE_CASE					,     _SCREAMING_SNAKE_CASE					,     _SCREAMING_SNAKE_CASE					,     _SCREAMING_SNAKE_CASE				)
																continue
								if not is_used:
												unused_weights.append(_SCREAMING_SNAKE_CASE				)

				logger.warning(f'Unused weights: {unused_weights}'				)







def  lowercase	(      _SCREAMING_SNAKE_CASE   :						str					,     _SCREAMING_SNAKE_CASE   :						Any					,     _SCREAMING_SNAKE_CASE   :						List[str]					,     _SCREAMING_SNAKE_CASE   :						int					,     _SCREAMING_SNAKE_CASE   :						Optional[Any]				):






				'''simple docstring'''



				_UpperCAmelCase					=    full_name.split('''conv_layers.'''				)[-1]
				_UpperCAmelCase					=    name.split('''.'''				)
				_UpperCAmelCase					=    int(items[0]				)
				_UpperCAmelCase					=    int(items[1]				)

				if type_id == 0:
								if "bias" in name:
												assert value.shape == feature_extractor.conv_layers[layer_id].conv.bias.data.shape, (
												    f'{full_name} has size {value.shape}, but'
												    f' {feature_extractor.conv_layers[layer_id].conv.bias.data.shape} was found.'
												)
												_UpperCAmelCase					=    value
												logger.info(f'Feat extract conv layer {layer_id} was initialized from {full_name}.'				)
								elif "weight" in name:
												assert value.shape == feature_extractor.conv_layers[layer_id].conv.weight.data.shape, (
												    f'{full_name} has size {value.shape}, but'
												    f' {feature_extractor.conv_layers[layer_id].conv.weight.data.shape} was found.'
												)
												_UpperCAmelCase					=    value
												logger.info(f'Feat extract conv layer {layer_id} was initialized from {full_name}.'				)
				elif (type_id == 2 and not use_group_norm) or (type_id == 2 and layer_id == 0 and use_group_norm):
								if "bias" in name:
												assert value.shape == feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape, (
												    f'{full_name} has size {value.shape}, but {feature_extractor[layer_id].layer_norm.bias.data.shape} was'
												    " found."
												)
												_UpperCAmelCase					=    value
												logger.info(f'Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.'				)
								elif "weight" in name:
												assert value.shape == feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape, (
												    f'{full_name} has size {value.shape}, but'
												    f' {feature_extractor[layer_id].layer_norm.weight.data.shape} was found.'
												)
												_UpperCAmelCase					=    value
												logger.info(f'Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.'				)
				else:
								unused_weights.append(_SCREAMING_SNAKE_CASE				)







@torch.no_grad()
def  lowercase	(      _SCREAMING_SNAKE_CASE   :						Tuple					,     _SCREAMING_SNAKE_CASE   :						Optional[Any]					,     _SCREAMING_SNAKE_CASE   :						Any=None					,     _SCREAMING_SNAKE_CASE   :						Dict=None					,     _SCREAMING_SNAKE_CASE   :						Dict=True				):






				'''simple docstring'''



				if config_path is not None:
								_UpperCAmelCase					=    HubertConfig.from_pretrained(_SCREAMING_SNAKE_CASE				)
				else:
								_UpperCAmelCase					=    HubertConfig()

				if is_finetuned:
								if dict_path:
												_UpperCAmelCase					=    Dictionary.load(_SCREAMING_SNAKE_CASE				)

												# important change bos & pad token id since CTC symbol is <pad> and
												# not <s> as in fairseq
												_UpperCAmelCase					=    target_dict.pad_index
												_UpperCAmelCase					=    target_dict.bos_index
												_UpperCAmelCase					=    target_dict.eos_index
												_UpperCAmelCase					=    len(target_dict.symbols				)
												_UpperCAmelCase					=    os.path.join(_SCREAMING_SNAKE_CASE					,     '''vocab.json'''				)
												if not os.path.isdir(_SCREAMING_SNAKE_CASE				):
																logger.error('''--pytorch_dump_folder_path ({}) should be a directory'''.format(_SCREAMING_SNAKE_CASE				)				)
																return
												os.makedirs(_SCREAMING_SNAKE_CASE					,     exist_ok=_SCREAMING_SNAKE_CASE				)
												with open(_SCREAMING_SNAKE_CASE					,     '''w'''					,     encoding='''utf-8'''				) as vocab_handle:
																json.dump(target_dict.indices					,     _SCREAMING_SNAKE_CASE				)
												_UpperCAmelCase					=    WavaVecaCTCTokenizer(
												    _SCREAMING_SNAKE_CASE					,     unk_token=target_dict.unk_word					,     pad_token=target_dict.pad_word					,     bos_token=target_dict.bos_word					,     eos_token=target_dict.eos_word					,     word_delimiter_token='''|'''					,     do_lower_case=_SCREAMING_SNAKE_CASE					,     )
												_UpperCAmelCase					=    True if config.feat_extract_norm == '''layer''' else False
												_UpperCAmelCase					=    WavaVecaFeatureExtractor(
												    feature_size=1					,     sampling_rate=1_6000					,     padding_value=0					,     do_normalize=_SCREAMING_SNAKE_CASE					,     return_attention_mask=_SCREAMING_SNAKE_CASE					,     )
												_UpperCAmelCase					=    WavaVecaProcessor(feature_extractor=_SCREAMING_SNAKE_CASE					,     tokenizer=_SCREAMING_SNAKE_CASE				)
												processor.save_pretrained(_SCREAMING_SNAKE_CASE				)

								_UpperCAmelCase					=    HubertForCTC(_SCREAMING_SNAKE_CASE				)
				else:
								_UpperCAmelCase					=    HubertModel(_SCREAMING_SNAKE_CASE				)

				if is_finetuned:
								_UpperCAmelCase		,						_UpperCAmelCase		,						_UpperCAmelCase					=    fairseq.checkpoint_utils.load_model_ensemble_and_task(
								    [checkpoint_path]					,     arg_overrides={'''data''': '''/'''.join(dict_path.split('''/'''				)[:-1]				)}				)
				else:
								_UpperCAmelCase		,						_UpperCAmelCase		,						_UpperCAmelCase					=    fairseq.checkpoint_utils.load_model_ensemble_and_task([checkpoint_path]				)

				_UpperCAmelCase					=    model[0].eval()

				recursively_load_weights(_SCREAMING_SNAKE_CASE					,     _SCREAMING_SNAKE_CASE					,     _SCREAMING_SNAKE_CASE				)

				hf_wavavec.save_pretrained(_SCREAMING_SNAKE_CASE				)


if __name__ == "__main__":
					__A   :							str									=   argparse.ArgumentParser()
					parser.add_argument("--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.")
					parser.add_argument("--checkpoint_path", default=None, type=str, help="Path to fairseq checkpoint")
					parser.add_argument("--dict_path", default=None, type=str, help="Path to dict of fine-tuned model")
					parser.add_argument("--config_path", default=None, type=str, help="Path to hf config.json of model to convert")
					parser.add_argument(
					    "--not_finetuned", action="store_true", help="Whether the model to convert is a fine-tuned model or not"
					)
					__A   :							Optional[int]									=   parser.parse_args()
					convert_hubert_checkpoint(
					    args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path, args.dict_path, not args.not_finetuned
					)








"""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 			_a :
								"""simple docstring"""



								@staticmethod
								def  lowercase__						(		*__UpperCamelCase     :    Dict				,   **__UpperCamelCase     :    Optional[Any]   )->List[str]:
												pass







					def  lowercase	(      _SCREAMING_SNAKE_CASE   :						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.
__A   :							Dict										=   (
    "https://huggingface.co/spaces/impira/docquery/resolve/2f6c96314dc84dfda62d40de9da55f2f5165d403/invoice.png"
)
@is_pipeline_test
@require_torch
@require_vision
class 			_a (					unittest.TestCase):
			"""simple docstring"""
			UpperCamelCase__			      =	MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING



			@require_pytesseract
			@require_vision
			def  lowercase__						(		self     :    List[str]				,   __UpperCamelCase     :    Tuple				,   __UpperCamelCase     :    Any				,   __UpperCamelCase     :    str   )->Tuple:
							_UpperCAmelCase					=    pipeline(
							    '''document-question-answering'''				,   model=__UpperCamelCase				,   tokenizer=__UpperCamelCase				,   image_processor=__UpperCamelCase   )

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



			def  lowercase__						(		self     :    str				,   __UpperCamelCase     :    List[Any]				,   __UpperCamelCase     :    Optional[int]   )->Any:
							_UpperCAmelCase					=    dqa_pipeline(__UpperCamelCase				,   top_k=2   )
							self.assertEqual(
							    __UpperCamelCase				,   [
							        [
							            {'''score''': ANY(__UpperCamelCase   ), '''answer''': ANY(__UpperCamelCase   ), '''start''': ANY(__UpperCamelCase   ), '''end''': ANY(__UpperCamelCase   )},
							            {'''score''': ANY(__UpperCamelCase   ), '''answer''': ANY(__UpperCamelCase   ), '''start''': ANY(__UpperCamelCase   ), '''end''': ANY(__UpperCamelCase   )},
							        ]
							    ]
							    * 3				,   )



			@require_torch
			@require_detectrona
			@require_pytesseract
			def  lowercase__						(		self     :    str   )->Union[str, Any]:
							_UpperCAmelCase					=    pipeline('''document-question-answering'''				,   model='''hf-internal-testing/tiny-random-layoutlmv2'''   )
							_UpperCAmelCase					=    INVOICE_URL
							_UpperCAmelCase					=    '''How many cats are there?'''

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

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

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

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



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

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

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

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



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

							_UpperCAmelCase					=    dqa_pipeline(image=__UpperCamelCase				,   question=__UpperCamelCase				,   top_k=2   )
							self.assertEqual(
							    nested_simplify(__UpperCamelCase				,   decimals=4   )				,   [
							        {'''score''': 0.9_9_7_4, '''answer''': '''1110212019''', '''start''': 2_3, '''end''': 2_3},
							        {'''score''': 0.9_9_4_8, '''answer''': '''us-001''', '''start''': 1_6, '''end''': 1_6},
							    ]				,   )

							_UpperCAmelCase					=    dqa_pipeline({'''image''': image, '''question''': question}				,   top_k=2   )
							self.assertEqual(
							    nested_simplify(__UpperCamelCase				,   decimals=4   )				,   [
							        {'''score''': 0.9_9_7_4, '''answer''': '''1110212019''', '''start''': 2_3, '''end''': 2_3},
							        {'''score''': 0.9_9_4_8, '''answer''': '''us-001''', '''start''': 1_6, '''end''': 1_6},
							    ]				,   )

							_UpperCAmelCase					=    dqa_pipeline(
							    [{'''image''': image, '''question''': question}, {'''image''': image, '''question''': question}]				,   top_k=2   )
							self.assertEqual(
							    nested_simplify(__UpperCamelCase				,   decimals=4   )				,   [
							        [
							            {'''score''': 0.9_9_7_4, '''answer''': '''1110212019''', '''start''': 2_3, '''end''': 2_3},
							            {'''score''': 0.9_9_4_8, '''answer''': '''us-001''', '''start''': 1_6, '''end''': 1_6},
							        ]
							    ]
							    * 2				,   )



			@slow
			@require_torch
			@require_pytesseract
			@require_vision
			def  lowercase__						(		self     :    Dict   )->Tuple:
							_UpperCAmelCase					=    AutoTokenizer.from_pretrained(
							    '''impira/layoutlm-document-qa'''				,   revision='''3dc6de3'''				,   add_prefix_space=__UpperCamelCase   )
							_UpperCAmelCase					=    pipeline(
							    '''document-question-answering'''				,   model='''impira/layoutlm-document-qa'''				,   tokenizer=__UpperCamelCase				,   revision='''3dc6de3'''				,   )
							_UpperCAmelCase					=    INVOICE_URL
							_UpperCAmelCase					=    '''What is the invoice number?'''

							_UpperCAmelCase					=    dqa_pipeline(image=__UpperCamelCase				,   question=__UpperCamelCase				,   top_k=2   )
							self.assertEqual(
							    nested_simplify(__UpperCamelCase				,   decimals=4   )				,   [
							        {'''score''': 0.4_2_5_1, '''answer''': '''us-001''', '''start''': 1_6, '''end''': 1_6},
							        {'''score''': 0.0_8_1_9, '''answer''': '''1110212019''', '''start''': 2_3, '''end''': 2_3},
							    ]				,   )

							_UpperCAmelCase					=    dqa_pipeline({'''image''': image, '''question''': question}				,   top_k=2   )
							self.assertEqual(
							    nested_simplify(__UpperCamelCase				,   decimals=4   )				,   [
							        {'''score''': 0.4_2_5_1, '''answer''': '''us-001''', '''start''': 1_6, '''end''': 1_6},
							        {'''score''': 0.0_8_1_9, '''answer''': '''1110212019''', '''start''': 2_3, '''end''': 2_3},
							    ]				,   )

							_UpperCAmelCase					=    dqa_pipeline(
							    [{'''image''': image, '''question''': question}, {'''image''': image, '''question''': question}]				,   top_k=2   )
							self.assertEqual(
							    nested_simplify(__UpperCamelCase				,   decimals=4   )				,   [
							        [
							            {'''score''': 0.4_2_5_1, '''answer''': '''us-001''', '''start''': 1_6, '''end''': 1_6},
							            {'''score''': 0.0_8_1_9, '''answer''': '''1110212019''', '''start''': 2_3, '''end''': 2_3},
							        ]
							    ]
							    * 2				,   )

							_UpperCAmelCase					=    list(zip(*apply_tesseract(load_image(__UpperCamelCase   )				,   __UpperCamelCase				,   ''''''   )   )   )

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



			@slow
			@require_torch
			@require_pytesseract
			@require_vision
			def  lowercase__						(		self     :    List[str]   )->Any:
							_UpperCAmelCase					=    AutoTokenizer.from_pretrained(
							    '''impira/layoutlm-document-qa'''				,   revision='''3dc6de3'''				,   add_prefix_space=__UpperCamelCase   )
							_UpperCAmelCase					=    pipeline(
							    '''document-question-answering'''				,   model='''impira/layoutlm-document-qa'''				,   tokenizer=__UpperCamelCase				,   revision='''3dc6de3'''				,   max_seq_len=5_0				,   )
							_UpperCAmelCase					=    INVOICE_URL
							_UpperCAmelCase					=    '''What is the invoice number?'''

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

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

							_UpperCAmelCase					=    list(zip(*apply_tesseract(load_image(__UpperCamelCase   )				,   __UpperCamelCase				,   ''''''   )   )   )

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



			@slow
			@require_torch
			def  lowercase__						(		self     :    int   )->str:
							_UpperCAmelCase					=    pipeline(
							    '''document-question-answering'''				,   model='''naver-clova-ix/donut-base-finetuned-docvqa'''				,   tokenizer=AutoTokenizer.from_pretrained('''naver-clova-ix/donut-base-finetuned-docvqa'''   )				,   feature_extractor='''naver-clova-ix/donut-base-finetuned-docvqa'''				,   )

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



			@require_tf
			@unittest.skip('''Document question answering not implemented in TF'''   )
			def  lowercase__						(		self     :    Tuple   )->Union[str, Any]:
							pass



