
"""simple docstring"""




import argparse
import json
from pathlib import Path

import requests
import torch
from huggingface_hub import hf_hub_download
from PIL import Image

from transformers import (
    MobileViTConfig,
    MobileViTForImageClassification,
    MobileViTForSemanticSegmentation,
    MobileViTImageProcessor,
)
from transformers.utils import logging


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

def lowercase_						(     _snake_case		):
							SCREAMING_SNAKE_CASE__		: Optional[Any]     =     MobileViTConfig()

							# size of the architecture
							if "mobilevit_s" in mobilevit_name:
														SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     [144, 192, 240]
														SCREAMING_SNAKE_CASE__		: Any     =     [16, 32, 64, 96, 128, 160, 640]
							elif "mobilevit_xs" in mobilevit_name:
														SCREAMING_SNAKE_CASE__		: Any     =     [96, 120, 144]
														SCREAMING_SNAKE_CASE__		: List[str]     =     [16, 32, 48, 64, 80, 96, 384]
							elif "mobilevit_xxs" in mobilevit_name:
														SCREAMING_SNAKE_CASE__		: Dict     =     [64, 80, 96]
														SCREAMING_SNAKE_CASE__		: Any     =     [16, 16, 24, 48, 64, 80, 320]
														SCREAMING_SNAKE_CASE__		: List[str]     =     0.05
														SCREAMING_SNAKE_CASE__		: List[Any]     =     2.0

							if mobilevit_name.startswith("""deeplabv3_"""		):
														SCREAMING_SNAKE_CASE__		: str     =     512
														SCREAMING_SNAKE_CASE__		: Optional[int]     =     16
														SCREAMING_SNAKE_CASE__		: Optional[int]     =     21
														SCREAMING_SNAKE_CASE__		: Optional[Any]     =     """pascal-voc-id2label.json"""
							else:
														SCREAMING_SNAKE_CASE__		: int     =     1_000
														SCREAMING_SNAKE_CASE__		: Optional[int]     =     """imagenet-1k-id2label.json"""

							SCREAMING_SNAKE_CASE__		: Any     =     """huggingface/label-files"""
							SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     json.load(open(hf_hub_download(_snake_case     ,_snake_case     ,repo_type="""dataset"""		)     ,"""r"""		)		)
							SCREAMING_SNAKE_CASE__		: Dict     =     {int(_snake_case		): v for k, v in idalabel.items()}
							SCREAMING_SNAKE_CASE__		: List[Any]     =     idalabel
							SCREAMING_SNAKE_CASE__		: int     =     {v: k for k, v in idalabel.items()}

							return config

def lowercase_						(     _snake_case     ,_snake_case=False		):
							for i in range(1     ,6		):
														if f'''layer_{i}.''' in name:
																					SCREAMING_SNAKE_CASE__		: Any     =     name.replace(f'''layer_{i}.'''     ,f'''encoder.layer.{i - 1}.'''		)

							if "conv_1." in name:
														SCREAMING_SNAKE_CASE__		: int     =     name.replace("""conv_1."""     ,"""conv_stem."""		)
							if ".block." in name:
														SCREAMING_SNAKE_CASE__		: List[Any]     =     name.replace(""".block."""     ,"""."""		)

							if "exp_1x1" in name:
														SCREAMING_SNAKE_CASE__		: int     =     name.replace("""exp_1x1"""     ,"""expand_1x1"""		)
							if "red_1x1" in name:
														SCREAMING_SNAKE_CASE__		: str     =     name.replace("""red_1x1"""     ,"""reduce_1x1"""		)
							if ".local_rep.conv_3x3." in name:
														SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     name.replace(""".local_rep.conv_3x3."""     ,""".conv_kxk."""		)
							if ".local_rep.conv_1x1." in name:
														SCREAMING_SNAKE_CASE__		: List[Any]     =     name.replace(""".local_rep.conv_1x1."""     ,""".conv_1x1."""		)
							if ".norm." in name:
														SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     name.replace(""".norm."""     ,""".normalization."""		)
							if ".conv." in name:
														SCREAMING_SNAKE_CASE__		: Optional[Any]     =     name.replace(""".conv."""     ,""".convolution."""		)
							if ".conv_proj." in name:
														SCREAMING_SNAKE_CASE__		: List[str]     =     name.replace(""".conv_proj."""     ,""".conv_projection."""		)

							for i in range(0     ,2		):
														for j in range(0     ,4		):
																					if f'''.{i}.{j}.''' in name:
																												SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     name.replace(f'''.{i}.{j}.'''     ,f'''.{i}.layer.{j}.'''		)

							for i in range(2     ,6		):
														for j in range(0     ,4		):
																					if f'''.{i}.{j}.''' in name:
																												SCREAMING_SNAKE_CASE__		: Optional[Any]     =     name.replace(f'''.{i}.{j}.'''     ,f'''.{i}.'''		)
																												if "expand_1x1" in name:
																																			SCREAMING_SNAKE_CASE__		: Any     =     name.replace("""expand_1x1"""     ,"""downsampling_layer.expand_1x1"""		)
																												if "conv_3x3" in name:
																																			SCREAMING_SNAKE_CASE__		: Dict     =     name.replace("""conv_3x3"""     ,"""downsampling_layer.conv_3x3"""		)
																												if "reduce_1x1" in name:
																																			SCREAMING_SNAKE_CASE__		: Optional[int]     =     name.replace("""reduce_1x1"""     ,"""downsampling_layer.reduce_1x1"""		)

							for i in range(2     ,5		):
														if f'''.global_rep.{i}.weight''' in name:
																					SCREAMING_SNAKE_CASE__		: List[Any]     =     name.replace(f'''.global_rep.{i}.weight'''     ,""".layernorm.weight"""		)
														if f'''.global_rep.{i}.bias''' in name:
																					SCREAMING_SNAKE_CASE__		: List[str]     =     name.replace(f'''.global_rep.{i}.bias'''     ,""".layernorm.bias"""		)

							if ".global_rep." in name:
														SCREAMING_SNAKE_CASE__		: Tuple     =     name.replace(""".global_rep."""     ,""".transformer."""		)
							if ".pre_norm_mha.0." in name:
														SCREAMING_SNAKE_CASE__		: List[str]     =     name.replace(""".pre_norm_mha.0."""     ,""".layernorm_before."""		)
							if ".pre_norm_mha.1.out_proj." in name:
														SCREAMING_SNAKE_CASE__		: List[str]     =     name.replace(""".pre_norm_mha.1.out_proj."""     ,""".attention.output.dense."""		)
							if ".pre_norm_ffn.0." in name:
														SCREAMING_SNAKE_CASE__		: Optional[int]     =     name.replace(""".pre_norm_ffn.0."""     ,""".layernorm_after."""		)
							if ".pre_norm_ffn.1." in name:
														SCREAMING_SNAKE_CASE__		: List[Any]     =     name.replace(""".pre_norm_ffn.1."""     ,""".intermediate.dense."""		)
							if ".pre_norm_ffn.4." in name:
														SCREAMING_SNAKE_CASE__		: Optional[int]     =     name.replace(""".pre_norm_ffn.4."""     ,""".output.dense."""		)
							if ".transformer." in name:
														SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     name.replace(""".transformer."""     ,""".transformer.layer."""		)

							if ".aspp_layer." in name:
														SCREAMING_SNAKE_CASE__		: Any     =     name.replace(""".aspp_layer."""     ,"""."""		)
							if ".aspp_pool." in name:
														SCREAMING_SNAKE_CASE__		: Optional[Any]     =     name.replace(""".aspp_pool."""     ,"""."""		)
							if "seg_head." in name:
														SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     name.replace("""seg_head."""     ,"""segmentation_head."""		)
							if "segmentation_head.classifier.classifier." in name:
														SCREAMING_SNAKE_CASE__		: Any     =     name.replace("""segmentation_head.classifier.classifier."""     ,"""segmentation_head.classifier."""		)

							if "classifier.fc." in name:
														SCREAMING_SNAKE_CASE__		: List[str]     =     name.replace("""classifier.fc."""     ,"""classifier."""		)
							elif (not base_model) and ("segmentation_head." not in name):
														SCREAMING_SNAKE_CASE__		: Tuple     =     """mobilevit.""" + name

							return name

def lowercase_						(     _snake_case     ,_snake_case     ,_snake_case=False		):
							if base_model:
														SCREAMING_SNAKE_CASE__		: Dict     =     """"""
							else:
														SCREAMING_SNAKE_CASE__		: int     =     """mobilevit."""

							for key in orig_state_dict.copy().keys():
														SCREAMING_SNAKE_CASE__		: int     =     orig_state_dict.pop(_snake_case		)

														if key[:8] == "encoder.":
																					SCREAMING_SNAKE_CASE__		: Dict     =     key[8:]

														if "qkv" in key:
																					SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     key.split("""."""		)
																					SCREAMING_SNAKE_CASE__		: Optional[Any]     =     int(key_split[0][6:]		) - 1
																					SCREAMING_SNAKE_CASE__		: Tuple     =     int(key_split[3]		)
																					SCREAMING_SNAKE_CASE__		: List[Any]     =     model.get_submodule(f'''{model_prefix}encoder.layer.{layer_num}'''		)
																					SCREAMING_SNAKE_CASE__		: Dict     =     layer.transformer.layer[transformer_num].attention.attention.all_head_size
																					SCREAMING_SNAKE_CASE__		: Tuple     =     (
																					    f'''{model_prefix}encoder.layer.{layer_num}.transformer.layer.{transformer_num}.attention.attention.'''
																					)
																					if "weight" in key:
																												SCREAMING_SNAKE_CASE__		: List[str]     =     val[:dim, :]
																												SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     val[dim : dim * 2, :]
																												SCREAMING_SNAKE_CASE__		: List[Any]     =     val[-dim:, :]
																					else:
																												SCREAMING_SNAKE_CASE__		: str     =     val[:dim]
																												SCREAMING_SNAKE_CASE__		: Tuple     =     val[dim : dim * 2]
																												SCREAMING_SNAKE_CASE__		: str     =     val[-dim:]
														else:
																					SCREAMING_SNAKE_CASE__		: Optional[int]     =     val

							return orig_state_dict

def lowercase_						(     ):
							SCREAMING_SNAKE_CASE__		: int     =     """http://images.cocodataset.org/val2017/000000039769.jpg"""
							SCREAMING_SNAKE_CASE__		: str     =     Image.open(requests.get(_snake_case     ,stream=_snake_case		).raw		)
							return im

@torch.no_grad()
def lowercase_						(     _snake_case     ,_snake_case     ,_snake_case     ,_snake_case=False		):
							SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     get_mobilevit_config(_snake_case		)

							# load original state_dict
							SCREAMING_SNAKE_CASE__		: List[str]     =     torch.load(_snake_case     ,map_location="""cpu"""		)

							# load 🤗 model
							if mobilevit_name.startswith("""deeplabv3_"""		):
														SCREAMING_SNAKE_CASE__		: int     =     MobileViTForSemanticSegmentation(_snake_case		).eval()
							else:
														SCREAMING_SNAKE_CASE__		: Optional[Any]     =     MobileViTForImageClassification(_snake_case		).eval()

							SCREAMING_SNAKE_CASE__		: List[Any]     =     convert_state_dict(_snake_case     ,_snake_case		)
							model.load_state_dict(_snake_case		)

							# Check outputs on an image, prepared by MobileViTImageProcessor
							SCREAMING_SNAKE_CASE__		: Optional[Any]     =     MobileViTImageProcessor(crop_size=config.image_size     ,size=config.image_size + 32		)
							SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     image_processor(images=prepare_img()     ,return_tensors="""pt"""		)
							SCREAMING_SNAKE_CASE__		: Optional[int]     =     model(**_snake_case		)
							SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     outputs.logits

							if mobilevit_name.startswith("""deeplabv3_"""		):
														assert logits.shape == (1, 21, 32, 32)

														if mobilevit_name == "deeplabv3_mobilevit_s":
																					SCREAMING_SNAKE_CASE__		: Any     =     torch.tensor(
																					    [
																					        [[6.2065, 6.1292, 6.2070], [6.1079, 6.1254, 6.1747], [6.0042, 6.1071, 6.1034]],
																					        [[-6.9253, -6.8653, -7.0398], [-7.3218, -7.3983, -7.3670], [-7.1961, -7.2482, -7.1569]],
																					        [[-4.4723, -4.4348, -4.3769], [-5.3629, -5.4632, -5.4598], [-5.1587, -5.3402, -5.5059]],
																					    ]		)
														elif mobilevit_name == "deeplabv3_mobilevit_xs":
																					SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     torch.tensor(
																					    [
																					        [[5.4449, 5.5733, 5.6314], [5.1815, 5.3930, 5.5963], [5.1656, 5.4333, 5.4853]],
																					        [[-9.4423, -9.7766, -9.6714], [-9.1581, -9.5720, -9.5519], [-9.1006, -9.6458, -9.5703]],
																					        [[-7.7721, -7.3716, -7.1583], [-8.4599, -8.0624, -7.7944], [-8.4172, -7.8366, -7.5025]],
																					    ]		)
														elif mobilevit_name == "deeplabv3_mobilevit_xxs":
																					SCREAMING_SNAKE_CASE__		: List[Any]     =     torch.tensor(
																					    [
																					        [[6.9811, 6.9743, 7.3123], [7.1777, 7.1931, 7.3938], [7.5633, 7.8050, 7.8901]],
																					        [[-10.5536, -10.2332, -10.2924], [-10.2336, -9.8624, -9.5964], [-10.8840, -10.8158, -10.6659]],
																					        [[-3.4938, -3.0631, -2.8620], [-3.4205, -2.8135, -2.6875], [-3.4179, -2.7945, -2.8750]],
																					    ]		)
														else:
																					raise ValueError(f'''Unknown mobilevit_name: {mobilevit_name}'''		)

														assert torch.allclose(logits[0, :3, :3, :3]     ,_snake_case     ,atol=1E-4		)
							else:
														assert logits.shape == (1, 1_000)

														if mobilevit_name == "mobilevit_s":
																					SCREAMING_SNAKE_CASE__		: List[Any]     =     torch.tensor([-0.9866, 0.2392, -1.1241]		)
														elif mobilevit_name == "mobilevit_xs":
																					SCREAMING_SNAKE_CASE__		: Any     =     torch.tensor([-2.4761, -0.9399, -1.9587]		)
														elif mobilevit_name == "mobilevit_xxs":
																					SCREAMING_SNAKE_CASE__		: str     =     torch.tensor([-1.9364, -1.2327, -0.4653]		)
														else:
																					raise ValueError(f'''Unknown mobilevit_name: {mobilevit_name}'''		)

														assert torch.allclose(logits[0, :3]     ,_snake_case     ,atol=1E-4		)

							Path(_snake_case		).mkdir(exist_ok=_snake_case		)
							print(f'''Saving model {mobilevit_name} to {pytorch_dump_folder_path}'''		)
							model.save_pretrained(_snake_case		)
							print(f'''Saving image processor to {pytorch_dump_folder_path}'''		)
							image_processor.save_pretrained(_snake_case		)

							if push_to_hub:
														SCREAMING_SNAKE_CASE__		: str     =     {
														    """mobilevit_s""": """mobilevit-small""",
														    """mobilevit_xs""": """mobilevit-x-small""",
														    """mobilevit_xxs""": """mobilevit-xx-small""",
														    """deeplabv3_mobilevit_s""": """deeplabv3-mobilevit-small""",
														    """deeplabv3_mobilevit_xs""": """deeplabv3-mobilevit-x-small""",
														    """deeplabv3_mobilevit_xxs""": """deeplabv3-mobilevit-xx-small""",
														}

														print("""Pushing to the hub..."""		)
														SCREAMING_SNAKE_CASE__		: Dict     =     model_mapping[mobilevit_name]
														image_processor.push_to_hub(_snake_case     ,organization="""apple"""		)
														model.push_to_hub(_snake_case     ,organization="""apple"""		)


if __name__ == "__main__":
					UpperCAmelCase__   :					List[str]												=				argparse.ArgumentParser()
					# Required parameters
					parser.add_argument(
					    '--mobilevit_name',
					    default='mobilevit_s',
					    type=str,
					    help=(
					        'Name of the MobileViT model you\'d like to convert. Should be one of \'mobilevit_s\', \'mobilevit_xs\','
					        ' \'mobilevit_xxs\', \'deeplabv3_mobilevit_s\', \'deeplabv3_mobilevit_xs\', \'deeplabv3_mobilevit_xxs\'.'
					    ),
					)
					parser.add_argument(
					    '--checkpoint_path', required=True, type=str, help='Path to the original state dict (.pt file).'
					)
					parser.add_argument(
					    '--pytorch_dump_folder_path', required=True, type=str, help='Path to the output PyTorch model directory.'
					)
					parser.add_argument(
					    '--push_to_hub', action='store_true', help='Whether or not to push the converted model to the 🤗 hub.'
					)

					UpperCAmelCase__   :					Union[str, Any]												=				parser.parse_args()
					convert_movilevit_checkpoint(
					    args.mobilevit_name, args.checkpoint_path, args.pytorch_dump_folder_path, args.push_to_hub
					)






"""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 			lowerCAmelCase_		:


									"""simple docstring"""



									@staticmethod
									def 			__magic_name__					(*SCREAMING_SNAKE_CASE__     , **SCREAMING_SNAKE_CASE__					)      ->	Union[str, Any]:



																"""simple docstring"""




																pass






					def lowercase_						(     _snake_case		):
												return None


# This is a pinned image from a specific revision of a document question answering space, hosted by HuggingFace,
# so we can expect it to be available.
UpperCAmelCase__   :					str												=				(
    'https://huggingface.co/spaces/impira/docquery/resolve/2f6c96314dc84dfda62d40de9da55f2f5165d403/invoice.png'
)



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


				"""simple docstring"""



				__UpperCamelCase   :		List[Any]       =     MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING



				@require_pytesseract
				@require_vision
				def 			__magic_name__					(self     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					)      ->	Optional[Any]:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: List[str]     =     pipeline(
											    """document-question-answering"""     , model=SCREAMING_SNAKE_CASE__     , tokenizer=SCREAMING_SNAKE_CASE__     , image_processor=SCREAMING_SNAKE_CASE__					)

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



				def 			__magic_name__					(self     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					)      ->	List[Any]:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: Tuple     =     dqa_pipeline(SCREAMING_SNAKE_CASE__     , top_k=2					)
											self.assertEqual(
											    SCREAMING_SNAKE_CASE__     , [
											        [
											            {"""score""": ANY(SCREAMING_SNAKE_CASE__					), """answer""": ANY(SCREAMING_SNAKE_CASE__					), """start""": ANY(SCREAMING_SNAKE_CASE__					), """end""": ANY(SCREAMING_SNAKE_CASE__					)},
											            {"""score""": ANY(SCREAMING_SNAKE_CASE__					), """answer""": ANY(SCREAMING_SNAKE_CASE__					), """start""": ANY(SCREAMING_SNAKE_CASE__					), """end""": ANY(SCREAMING_SNAKE_CASE__					)},
											        ]
											    ]
											    * 3     , )



				@require_torch
				@require_detectrona
				@require_pytesseract
				def 			__magic_name__					(self					)      ->	List[Any]:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: List[Any]     =     pipeline("""document-question-answering"""     , model="""hf-internal-testing/tiny-random-layoutlmv2"""					)
											SCREAMING_SNAKE_CASE__		: str     =     INVOICE_URL
											SCREAMING_SNAKE_CASE__		: Any     =     """How many cats are there?"""

											SCREAMING_SNAKE_CASE__		: Optional[Any]     =     [
											    {"""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__		: Any     =     dqa_pipeline(image=SCREAMING_SNAKE_CASE__     , question=SCREAMING_SNAKE_CASE__     , top_k=2					)
											self.assertEqual(nested_simplify(SCREAMING_SNAKE_CASE__     , decimals=4					)     , SCREAMING_SNAKE_CASE__					)

											SCREAMING_SNAKE_CASE__		: str     =     dqa_pipeline({"""image""": image, """question""": question}     , top_k=2					)
											self.assertEqual(nested_simplify(SCREAMING_SNAKE_CASE__     , decimals=4					)     , SCREAMING_SNAKE_CASE__					)

											# This image does not detect ANY text in it, meaning layoutlmv2 should fail.
											# Empty answer probably
											SCREAMING_SNAKE_CASE__		: Optional[int]     =     """./tests/fixtures/tests_samples/COCO/000000039769.png"""
											SCREAMING_SNAKE_CASE__		: List[str]     =     dqa_pipeline(image=SCREAMING_SNAKE_CASE__     , question=SCREAMING_SNAKE_CASE__     , top_k=2					)
											self.assertEqual(SCREAMING_SNAKE_CASE__     , []					)

											# We can optionnally pass directly the words and bounding boxes
											SCREAMING_SNAKE_CASE__		: Tuple     =     """./tests/fixtures/tests_samples/COCO/000000039769.png"""
											SCREAMING_SNAKE_CASE__		: Dict     =     []
											SCREAMING_SNAKE_CASE__		: Any     =     []
											SCREAMING_SNAKE_CASE__		: Dict     =     dqa_pipeline(image=SCREAMING_SNAKE_CASE__     , question=SCREAMING_SNAKE_CASE__     , words=SCREAMING_SNAKE_CASE__     , boxes=SCREAMING_SNAKE_CASE__     , top_k=2					)
											self.assertEqual(SCREAMING_SNAKE_CASE__     , []					)



				@slow
				@require_torch
				@require_detectrona
				@require_pytesseract
				def 			__magic_name__					(self					)      ->	List[str]:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: List[str]     =     pipeline(
											    """document-question-answering"""     , model="""tiennvcs/layoutlmv2-base-uncased-finetuned-docvqa"""     , revision="""9977165"""     , )
											SCREAMING_SNAKE_CASE__		: str     =     INVOICE_URL
											SCREAMING_SNAKE_CASE__		: Optional[int]     =     """What is the invoice number?"""

											SCREAMING_SNAKE_CASE__		: List[str]     =     dqa_pipeline(image=SCREAMING_SNAKE_CASE__     , question=SCREAMING_SNAKE_CASE__     , top_k=2					)
											self.assertEqual(
											    nested_simplify(SCREAMING_SNAKE_CASE__     , 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(SCREAMING_SNAKE_CASE__     , 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__		: Optional[int]     =     dqa_pipeline(
											    [{"""image""": image, """question""": question}, {"""image""": image, """question""": question}]     , top_k=2					)
											self.assertEqual(
											    nested_simplify(SCREAMING_SNAKE_CASE__     , 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					)      ->	List[str]:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: List[str]     =     pipeline(
											    """document-question-answering"""     , model="""tiennvcs/layoutlmv2-base-uncased-finetuned-docvqa"""     , revision="""9977165"""     , max_seq_len=50     , )
											SCREAMING_SNAKE_CASE__		: Optional[Any]     =     INVOICE_URL
											SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     """What is the invoice number?"""

											SCREAMING_SNAKE_CASE__		: int     =     dqa_pipeline(image=SCREAMING_SNAKE_CASE__     , question=SCREAMING_SNAKE_CASE__     , top_k=2					)
											self.assertEqual(
											    nested_simplify(SCREAMING_SNAKE_CASE__     , 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}     , top_k=2					)
											self.assertEqual(
											    nested_simplify(SCREAMING_SNAKE_CASE__     , decimals=4					)     , [
											        {"""score""": 0.9974, """answer""": """1110212019""", """start""": 23, """end""": 23},
											        {"""score""": 0.9948, """answer""": """us-001""", """start""": 16, """end""": 16},
											    ]     , )

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



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: Optional[int]     =     AutoTokenizer.from_pretrained(
											    """impira/layoutlm-document-qa"""     , revision="""3dc6de3"""     , add_prefix_space=SCREAMING_SNAKE_CASE__					)
											SCREAMING_SNAKE_CASE__		: Optional[int]     =     pipeline(
											    """document-question-answering"""     , model="""impira/layoutlm-document-qa"""     , tokenizer=SCREAMING_SNAKE_CASE__     , revision="""3dc6de3"""     , )
											SCREAMING_SNAKE_CASE__		: List[str]     =     INVOICE_URL
											SCREAMING_SNAKE_CASE__		: Any     =     """What is the invoice number?"""

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

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

											SCREAMING_SNAKE_CASE__		: Dict     =     dqa_pipeline(
											    [{"""image""": image, """question""": question}, {"""image""": image, """question""": question}]     , top_k=2					)
											self.assertEqual(
											    nested_simplify(SCREAMING_SNAKE_CASE__     , 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[Any]     =     list(zip(*apply_tesseract(load_image(SCREAMING_SNAKE_CASE__					)     , SCREAMING_SNAKE_CASE__     , """"""					)					)					)

											# This model should also work if `image` is set to None
											SCREAMING_SNAKE_CASE__		: Dict     =     dqa_pipeline({"""image""": None, """word_boxes""": word_boxes, """question""": question}     , top_k=2					)
											self.assertEqual(
											    nested_simplify(SCREAMING_SNAKE_CASE__     , 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					)      ->	List[str]:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: Any     =     AutoTokenizer.from_pretrained(
											    """impira/layoutlm-document-qa"""     , revision="""3dc6de3"""     , add_prefix_space=SCREAMING_SNAKE_CASE__					)
											SCREAMING_SNAKE_CASE__		: Dict     =     pipeline(
											    """document-question-answering"""     , model="""impira/layoutlm-document-qa"""     , tokenizer=SCREAMING_SNAKE_CASE__     , revision="""3dc6de3"""     , max_seq_len=50     , )
											SCREAMING_SNAKE_CASE__		: str     =     INVOICE_URL
											SCREAMING_SNAKE_CASE__		: Dict     =     """What is the invoice number?"""

											SCREAMING_SNAKE_CASE__		: Optional[int]     =     dqa_pipeline(image=SCREAMING_SNAKE_CASE__     , question=SCREAMING_SNAKE_CASE__     , top_k=2					)
											self.assertEqual(
											    nested_simplify(SCREAMING_SNAKE_CASE__     , 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__		: Union[str, Any]     =     dqa_pipeline(
											    [{"""image""": image, """question""": question}, {"""image""": image, """question""": question}]     , top_k=2					)
											self.assertEqual(
											    nested_simplify(SCREAMING_SNAKE_CASE__     , 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__		: Any     =     list(zip(*apply_tesseract(load_image(SCREAMING_SNAKE_CASE__					)     , SCREAMING_SNAKE_CASE__     , """"""					)					)					)

											# 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(SCREAMING_SNAKE_CASE__     , 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					)      ->	Optional[Any]:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: Tuple     =     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__		: List[Any]     =     """What is the invoice number?"""
											SCREAMING_SNAKE_CASE__		: int     =     dqa_pipeline(image=SCREAMING_SNAKE_CASE__     , question=SCREAMING_SNAKE_CASE__     , top_k=2					)
											self.assertEqual(nested_simplify(SCREAMING_SNAKE_CASE__     , decimals=4					)     , [{"""answer""": """us-001"""}]					)



				@require_tf
				@unittest.skip("""Document question answering not implemented in TF"""					)
				def 			__magic_name__					(self					)      ->	int:



											"""simple docstring"""




											pass




