



import argparse
import json
import pickle
from pathlib import Path

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

from transformers import MaskFormerConfig, MaskFormerForInstanceSegmentation, MaskFormerImageProcessor, SwinConfig
from transformers.utils import logging


logging.set_verbosity_info()
a_			=					logging.get_logger(__name__)





def 		a__			(		_UpperCamelCase			: str							):
   __lowerCamelCase													=    SwinConfig.from_pretrained(
       '''microsoft/swin-tiny-patch4-window7-224''' ,out_features=['''stage1''', '''stage2''', '''stage3''', '''stage4''']							)
   __lowerCamelCase													=    MaskFormerConfig(backbone_config=_UpperCamelCase							)

   __lowerCamelCase													=    '''huggingface/label-files'''
   if "ade20k-full" in model_name:
      # this should be ok
      __lowerCamelCase													=    8_47
      __lowerCamelCase													=    '''maskformer-ade20k-full-id2label.json'''
   elif "ade" in model_name:
      # this should be ok
      __lowerCamelCase													=    1_50
      __lowerCamelCase													=    '''ade20k-id2label.json'''
   elif "coco-stuff" in model_name:
      # this should be ok
      __lowerCamelCase													=    1_71
      __lowerCamelCase													=    '''maskformer-coco-stuff-id2label.json'''
   elif "coco" in model_name:
      # TODO
      __lowerCamelCase													=    1_33
      __lowerCamelCase													=    '''coco-panoptic-id2label.json'''
   elif "cityscapes" in model_name:
      # this should be ok
      __lowerCamelCase													=    19
      __lowerCamelCase													=    '''cityscapes-id2label.json'''
   elif "vistas" in model_name:
      # this should be ok
      __lowerCamelCase													=    65
      __lowerCamelCase													=    '''mapillary-vistas-id2label.json'''

   __lowerCamelCase													=    json.load(open(hf_hub_download(_UpperCamelCase ,_UpperCamelCase ,repo_type='''dataset'''							) ,'''r'''							)							)
   __lowerCamelCase													=    {int(_UpperCamelCase							): v for k, v in idalabel.items()}

   return config





def 		a__			(		_UpperCamelCase			: Optional[int]							):
   __lowerCamelCase													=    []
   # stem
   # fmt: off
   rename_keys.append(('''backbone.patch_embed.proj.weight''', '''model.pixel_level_module.encoder.model.embeddings.patch_embeddings.projection.weight''')							)
   rename_keys.append(('''backbone.patch_embed.proj.bias''', '''model.pixel_level_module.encoder.model.embeddings.patch_embeddings.projection.bias''')							)
   rename_keys.append(('''backbone.patch_embed.norm.weight''', '''model.pixel_level_module.encoder.model.embeddings.norm.weight''')							)
   rename_keys.append(('''backbone.patch_embed.norm.bias''', '''model.pixel_level_module.encoder.model.embeddings.norm.bias''')							)
   # stages
   for i in range(len(config.backbone_config.depths							)							):
      for j in range(config.backbone_config.depths[i]							):
         rename_keys.append((F"""backbone.layers.{i}.blocks.{j}.norm1.weight""", F"""model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.layernorm_before.weight""")							)
         rename_keys.append((F"""backbone.layers.{i}.blocks.{j}.norm1.bias""", F"""model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.layernorm_before.bias""")							)
         rename_keys.append((F"""backbone.layers.{i}.blocks.{j}.attn.relative_position_bias_table""", F"""model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.attention.self.relative_position_bias_table""")							)
         rename_keys.append((F"""backbone.layers.{i}.blocks.{j}.attn.relative_position_index""", F"""model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.attention.self.relative_position_index""")							)
         rename_keys.append((F"""backbone.layers.{i}.blocks.{j}.attn.proj.weight""", F"""model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.attention.output.dense.weight""")							)
         rename_keys.append((F"""backbone.layers.{i}.blocks.{j}.attn.proj.bias""", F"""model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.attention.output.dense.bias""")							)
         rename_keys.append((F"""backbone.layers.{i}.blocks.{j}.norm2.weight""", F"""model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.layernorm_after.weight""")							)
         rename_keys.append((F"""backbone.layers.{i}.blocks.{j}.norm2.bias""", F"""model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.layernorm_after.bias""")							)
         rename_keys.append((F"""backbone.layers.{i}.blocks.{j}.mlp.fc1.weight""", F"""model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.intermediate.dense.weight""")							)
         rename_keys.append((F"""backbone.layers.{i}.blocks.{j}.mlp.fc1.bias""", F"""model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.intermediate.dense.bias""")							)
         rename_keys.append((F"""backbone.layers.{i}.blocks.{j}.mlp.fc2.weight""", F"""model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.output.dense.weight""")							)
         rename_keys.append((F"""backbone.layers.{i}.blocks.{j}.mlp.fc2.bias""", F"""model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.output.dense.bias""")							)

      if i < 3:
         rename_keys.append((F"""backbone.layers.{i}.downsample.reduction.weight""", F"""model.pixel_level_module.encoder.model.encoder.layers.{i}.downsample.reduction.weight""")							)
         rename_keys.append((F"""backbone.layers.{i}.downsample.norm.weight""", F"""model.pixel_level_module.encoder.model.encoder.layers.{i}.downsample.norm.weight""")							)
         rename_keys.append((F"""backbone.layers.{i}.downsample.norm.bias""", F"""model.pixel_level_module.encoder.model.encoder.layers.{i}.downsample.norm.bias""")							)
      rename_keys.append((F"""backbone.norm{i}.weight""", F"""model.pixel_level_module.encoder.hidden_states_norms.{i}.weight""")							)
      rename_keys.append((F"""backbone.norm{i}.bias""", F"""model.pixel_level_module.encoder.hidden_states_norms.{i}.bias""")							)

   # FPN
   rename_keys.append(('''sem_seg_head.layer_4.weight''', '''model.pixel_level_module.decoder.fpn.stem.0.weight''')							)
   rename_keys.append(('''sem_seg_head.layer_4.norm.weight''', '''model.pixel_level_module.decoder.fpn.stem.1.weight''')							)
   rename_keys.append(('''sem_seg_head.layer_4.norm.bias''', '''model.pixel_level_module.decoder.fpn.stem.1.bias''')							)
   for source_index, target_index in zip(range(3 ,0 ,-1							) ,range(0 ,3							)							):
      rename_keys.append((F"""sem_seg_head.adapter_{source_index}.weight""", F"""model.pixel_level_module.decoder.fpn.layers.{target_index}.proj.0.weight""")							)
      rename_keys.append((F"""sem_seg_head.adapter_{source_index}.norm.weight""", F"""model.pixel_level_module.decoder.fpn.layers.{target_index}.proj.1.weight""")							)
      rename_keys.append((F"""sem_seg_head.adapter_{source_index}.norm.bias""", F"""model.pixel_level_module.decoder.fpn.layers.{target_index}.proj.1.bias""")							)
      rename_keys.append((F"""sem_seg_head.layer_{source_index}.weight""", F"""model.pixel_level_module.decoder.fpn.layers.{target_index}.block.0.weight""")							)
      rename_keys.append((F"""sem_seg_head.layer_{source_index}.norm.weight""", F"""model.pixel_level_module.decoder.fpn.layers.{target_index}.block.1.weight""")							)
      rename_keys.append((F"""sem_seg_head.layer_{source_index}.norm.bias""", F"""model.pixel_level_module.decoder.fpn.layers.{target_index}.block.1.bias""")							)
   rename_keys.append(('''sem_seg_head.mask_features.weight''', '''model.pixel_level_module.decoder.mask_projection.weight''')							)
   rename_keys.append(('''sem_seg_head.mask_features.bias''', '''model.pixel_level_module.decoder.mask_projection.bias''')							)

   # Transformer decoder
   for idx in range(config.decoder_config.decoder_layers							):
      # self-attention out projection
      rename_keys.append((F"""sem_seg_head.predictor.transformer.decoder.layers.{idx}.self_attn.out_proj.weight""", F"""model.transformer_module.decoder.layers.{idx}.self_attn.out_proj.weight""")							)
      rename_keys.append((F"""sem_seg_head.predictor.transformer.decoder.layers.{idx}.self_attn.out_proj.bias""", F"""model.transformer_module.decoder.layers.{idx}.self_attn.out_proj.bias""")							)
      # cross-attention out projection
      rename_keys.append((F"""sem_seg_head.predictor.transformer.decoder.layers.{idx}.multihead_attn.out_proj.weight""", F"""model.transformer_module.decoder.layers.{idx}.encoder_attn.out_proj.weight""")							)
      rename_keys.append((F"""sem_seg_head.predictor.transformer.decoder.layers.{idx}.multihead_attn.out_proj.bias""", F"""model.transformer_module.decoder.layers.{idx}.encoder_attn.out_proj.bias""")							)
      # MLP 1
      rename_keys.append((F"""sem_seg_head.predictor.transformer.decoder.layers.{idx}.linear1.weight""", F"""model.transformer_module.decoder.layers.{idx}.fc1.weight""")							)
      rename_keys.append((F"""sem_seg_head.predictor.transformer.decoder.layers.{idx}.linear1.bias""", F"""model.transformer_module.decoder.layers.{idx}.fc1.bias""")							)
      # MLP 2
      rename_keys.append((F"""sem_seg_head.predictor.transformer.decoder.layers.{idx}.linear2.weight""", F"""model.transformer_module.decoder.layers.{idx}.fc2.weight""")							)
      rename_keys.append((F"""sem_seg_head.predictor.transformer.decoder.layers.{idx}.linear2.bias""", F"""model.transformer_module.decoder.layers.{idx}.fc2.bias""")							)
      # layernorm 1 (self-attention layernorm)
      rename_keys.append((F"""sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm1.weight""", F"""model.transformer_module.decoder.layers.{idx}.self_attn_layer_norm.weight""")							)
      rename_keys.append((F"""sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm1.bias""", F"""model.transformer_module.decoder.layers.{idx}.self_attn_layer_norm.bias""")							)
      # layernorm 2 (cross-attention layernorm)
      rename_keys.append((F"""sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm2.weight""", F"""model.transformer_module.decoder.layers.{idx}.encoder_attn_layer_norm.weight""")							)
      rename_keys.append((F"""sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm2.bias""", F"""model.transformer_module.decoder.layers.{idx}.encoder_attn_layer_norm.bias""")							)
      # layernorm 3 (final layernorm)
      rename_keys.append((F"""sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm3.weight""", F"""model.transformer_module.decoder.layers.{idx}.final_layer_norm.weight""")							)
      rename_keys.append((F"""sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm3.bias""", F"""model.transformer_module.decoder.layers.{idx}.final_layer_norm.bias""")							)

   rename_keys.append(('''sem_seg_head.predictor.transformer.decoder.norm.weight''', '''model.transformer_module.decoder.layernorm.weight''')							)
   rename_keys.append(('''sem_seg_head.predictor.transformer.decoder.norm.bias''', '''model.transformer_module.decoder.layernorm.bias''')							)

   # heads on top
   rename_keys.append(('''sem_seg_head.predictor.query_embed.weight''', '''model.transformer_module.queries_embedder.weight''')							)

   rename_keys.append(('''sem_seg_head.predictor.input_proj.weight''', '''model.transformer_module.input_projection.weight''')							)
   rename_keys.append(('''sem_seg_head.predictor.input_proj.bias''', '''model.transformer_module.input_projection.bias''')							)

   rename_keys.append(('''sem_seg_head.predictor.class_embed.weight''', '''class_predictor.weight''')							)
   rename_keys.append(('''sem_seg_head.predictor.class_embed.bias''', '''class_predictor.bias''')							)

   for i in range(3							):
      rename_keys.append((F"""sem_seg_head.predictor.mask_embed.layers.{i}.weight""", F"""mask_embedder.{i}.0.weight""")							)
      rename_keys.append((F"""sem_seg_head.predictor.mask_embed.layers.{i}.bias""", F"""mask_embedder.{i}.0.bias""")							)
   # fmt: on

   return rename_keys





def 		a__			(		_UpperCamelCase			: List[str] ,_UpperCamelCase			: Optional[int] ,_UpperCamelCase			: Dict							):
   __lowerCamelCase													=    dct.pop(_UpperCamelCase							)
   __lowerCamelCase													=    val





def 		a__			(		_UpperCamelCase			: int ,_UpperCamelCase			: Optional[int]							):
   __lowerCamelCase													=    [int(backbone_config.embed_dim * 2**i							) for i in range(len(backbone_config.depths							)							)]
   for i in range(len(backbone_config.depths							)							):
      __lowerCamelCase													=    num_features[i]
      for j in range(backbone_config.depths[i]							):
         # fmt: off
         # read in weights + bias of input projection layer (in original implementation, this is a single matrix + bias)
         __lowerCamelCase													=    state_dict.pop(F"""backbone.layers.{i}.blocks.{j}.attn.qkv.weight"""							)
         __lowerCamelCase													=    state_dict.pop(F"""backbone.layers.{i}.blocks.{j}.attn.qkv.bias"""							)
         # next, add query, keys and values (in that order) to the state dict
         __lowerCamelCase													=    in_proj_weight[:dim, :]
         __lowerCamelCase													=    in_proj_bias[: dim]
         __lowerCamelCase													=    in_proj_weight[
             dim : dim * 2, :
         ]
         __lowerCamelCase													=    in_proj_bias[
             dim : dim * 2
         ]
         __lowerCamelCase													=    in_proj_weight[
             -dim :, :
         ]
         __lowerCamelCase													=    in_proj_bias[-dim :]
         # fmt: on





def 		a__			(		_UpperCamelCase			: Optional[Any] ,_UpperCamelCase			: List[str]							):
   # fmt: off
   __lowerCamelCase													=    config.decoder_config.hidden_size
   for idx in range(config.decoder_config.decoder_layers							):
      # read in weights + bias of self-attention input projection layer (in the original implementation, this is a single matrix + bias)
      __lowerCamelCase													=    state_dict.pop(F"""sem_seg_head.predictor.transformer.decoder.layers.{idx}.self_attn.in_proj_weight"""							)
      __lowerCamelCase													=    state_dict.pop(F"""sem_seg_head.predictor.transformer.decoder.layers.{idx}.self_attn.in_proj_bias"""							)
      # next, add query, keys and values (in that order) to the state dict
      __lowerCamelCase													=    in_proj_weight[: hidden_size, :]
      __lowerCamelCase													=    in_proj_bias[:config.hidden_size]
      __lowerCamelCase													=    in_proj_weight[hidden_size : hidden_size * 2, :]
      __lowerCamelCase													=    in_proj_bias[hidden_size : hidden_size * 2]
      __lowerCamelCase													=    in_proj_weight[-hidden_size :, :]
      __lowerCamelCase													=    in_proj_bias[-hidden_size :]
      # read in weights + bias of cross-attention input projection layer (in the original implementation, this is a single matrix + bias)
      __lowerCamelCase													=    state_dict.pop(F"""sem_seg_head.predictor.transformer.decoder.layers.{idx}.multihead_attn.in_proj_weight"""							)
      __lowerCamelCase													=    state_dict.pop(F"""sem_seg_head.predictor.transformer.decoder.layers.{idx}.multihead_attn.in_proj_bias"""							)
      # next, add query, keys and values (in that order) to the state dict
      __lowerCamelCase													=    in_proj_weight[: hidden_size, :]
      __lowerCamelCase													=    in_proj_bias[:config.hidden_size]
      __lowerCamelCase													=    in_proj_weight[hidden_size : hidden_size * 2, :]
      __lowerCamelCase													=    in_proj_bias[hidden_size : hidden_size * 2]
      __lowerCamelCase													=    in_proj_weight[-hidden_size :, :]
      __lowerCamelCase													=    in_proj_bias[-hidden_size :]
   # fmt: on





def 		a__			(		):
   __lowerCamelCase													=    '''http://images.cocodataset.org/val2017/000000039769.jpg'''
   __lowerCamelCase													=    Image.open(requests.get(_UpperCamelCase ,stream=_UpperCamelCase							).raw							)
   return im





@torch.no_grad()
def 		a__			(		_UpperCamelCase			: str ,_UpperCamelCase			: str ,_UpperCamelCase			: str ,_UpperCamelCase			: bool = False							):
   __lowerCamelCase													=    get_maskformer_config(_UpperCamelCase							)

   # load original state_dict
   with open(_UpperCamelCase ,'''rb'''							) as f:
      __lowerCamelCase													=    pickle.load(_UpperCamelCase							)
   __lowerCamelCase													=    data['''model''']

   # for name, param in state_dict.items():
   #     print(name, param.shape)

   # rename keys
   __lowerCamelCase													=    create_rename_keys(_UpperCamelCase							)
   for src, dest in rename_keys:
      rename_key(_UpperCamelCase ,_UpperCamelCase ,_UpperCamelCase							)
   read_in_swin_q_k_v(_UpperCamelCase ,config.backbone_config							)
   read_in_decoder_q_k_v(_UpperCamelCase ,_UpperCamelCase							)

   # update to torch tensors
   for key, value in state_dict.items():
      __lowerCamelCase													=    torch.from_numpy(_UpperCamelCase							)

   # load 🤗 model
   __lowerCamelCase													=    MaskFormerForInstanceSegmentation(_UpperCamelCase							)
   model.eval()

   for name, param in model.named_parameters():
      print(_UpperCamelCase ,param.shape							)

   __lowerCamelCase							,__lowerCamelCase													=    model.load_state_dict(_UpperCamelCase ,strict=_UpperCamelCase							)
   assert missing_keys == [
       "model.pixel_level_module.encoder.model.layernorm.weight",
       "model.pixel_level_module.encoder.model.layernorm.bias",
   ]
   assert len(_UpperCamelCase							) == 0, F"""Unexpected keys: {unexpected_keys}"""

   # verify results
   __lowerCamelCase													=    prepare_img()
   if "vistas" in model_name:
      __lowerCamelCase													=    65
   elif "cityscapes" in model_name:
      __lowerCamelCase													=    6_55_35
   else:
      __lowerCamelCase													=    2_55
   __lowerCamelCase													=    True if '''ade''' in model_name else False
   __lowerCamelCase													=    MaskFormerImageProcessor(ignore_index=_UpperCamelCase ,reduce_labels=_UpperCamelCase							)

   __lowerCamelCase													=    image_processor(_UpperCamelCase ,return_tensors='''pt'''							)

   __lowerCamelCase													=    model(**_UpperCamelCase							)

   print('''Logits:''' ,outputs.class_queries_logits[0, :3, :3]							)

   if model_name == "maskformer-swin-tiny-ade":
      __lowerCamelCase													=    torch.tensor(
          [[3.6_353, -4.4_770, -2.6_065], [0.5_081, -4.2_394, -3.5_343], [2.1_909, -5.0_353, -1.9_323]]							)
   assert torch.allclose(outputs.class_queries_logits[0, :3, :3] ,_UpperCamelCase ,atol=1e-4							)
   print('''Looks ok!'''							)

   if pytorch_dump_folder_path is not None:
      print(F"""Saving model and image processor to {pytorch_dump_folder_path}"""							)
      Path(_UpperCamelCase							).mkdir(exist_ok=_UpperCamelCase							)
      model.save_pretrained(_UpperCamelCase							)
      image_processor.save_pretrained(_UpperCamelCase							)

   if push_to_hub:
      print('''Pushing model and image processor to the hub...'''							)
      model.push_to_hub(F"""nielsr/{model_name}"""							)
      image_processor.push_to_hub(F"""nielsr/{model_name}"""							)


if __name__ == "__main__":
  a_			=					argparse.ArgumentParser()
  # Required parameters
  parser.add_argument(
      """--model_name""",
      default="""maskformer-swin-tiny-ade""",
      type=str,
      help=("""Name of the MaskFormer model you'd like to convert""",),
  )
  parser.add_argument(
      """--checkpoint_path""",
      default="""/Users/nielsrogge/Documents/MaskFormer_checkpoints/MaskFormer-Swin-tiny-ADE20k/model.pkl""",
      type=str,
      help="""Path to the original state dict (.pth file).""",
  )
  parser.add_argument(
      """--pytorch_dump_folder_path""", default=None, 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."""
  )

  a_			=					parser.parse_args()
  convert_maskformer_checkpoint(
      args.model_name, args.checkpoint_path, args.pytorch_dump_folder_path, args.push_to_hub
  )











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     :




   @staticmethod
   def        lowerCamelCase      (						*__UpperCAmelCase	,				**__UpperCAmelCase				):



      '''simple docstring'''
      pass





  def 		a__			(		_UpperCamelCase			: List[str]							):
     return None


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



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




 @require_pytesseract
 @require_vision
 def        lowerCamelCase      (						self	,				__UpperCAmelCase	,				__UpperCAmelCase	,				__UpperCAmelCase				):



    '''simple docstring'''
    __lowerCamelCase													=    pipeline(
        '''document-question-answering'''	,				model=__UpperCAmelCase	,				tokenizer=__UpperCAmelCase	,				image_processor=__UpperCAmelCase				)

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




 def        lowerCamelCase      (						self	,				__UpperCAmelCase	,				__UpperCAmelCase				):



    '''simple docstring'''
    __lowerCamelCase													=    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        lowerCamelCase      (						self				):



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

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

    __lowerCamelCase													=    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
    __lowerCamelCase													=    '''./tests/fixtures/tests_samples/COCO/000000039769.png'''
    __lowerCamelCase													=    dqa_pipeline(image=__UpperCAmelCase	,				question=__UpperCAmelCase	,				top_k=2				)
    self.assertEqual(__UpperCAmelCase	,				[]				)

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




 @slow
 @require_torch
 @require_detectrona
 @require_pytesseract
 def        lowerCamelCase      (						self				):



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

    __lowerCamelCase													=    dqa_pipeline(image=__UpperCAmelCase	,				question=__UpperCAmelCase	,				top_k=2				)
    self.assertEqual(
        nested_simplify(__UpperCAmelCase	,				decimals=4				)	,				[
            {'''score''': 0.9_944, '''answer''': '''us-001''', '''start''': 16, '''end''': 16},
            {'''score''': 0.0_009, '''answer''': '''us-001''', '''start''': 16, '''end''': 16},
        ]	,				)

    __lowerCamelCase													=    dqa_pipeline({'''image''': image, '''question''': question}	,				top_k=2				)
    self.assertEqual(
        nested_simplify(__UpperCAmelCase	,				decimals=4				)	,				[
            {'''score''': 0.9_944, '''answer''': '''us-001''', '''start''': 16, '''end''': 16},
            {'''score''': 0.0_009, '''answer''': '''us-001''', '''start''': 16, '''end''': 16},
        ]	,				)

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




 @slow
 @require_torch
 @require_detectrona
 @require_pytesseract
 def        lowerCamelCase      (						self				):



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

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

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

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




 @slow
 @require_torch
 @require_pytesseract
 @require_vision
 def        lowerCamelCase      (						self				):



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

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

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

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

    __lowerCamelCase													=    list(zip(*apply_tesseract(load_image(__UpperCAmelCase				)	,				__UpperCAmelCase	,				''''''				)				)				)

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




 @slow
 @require_torch
 @require_pytesseract
 @require_vision
 def        lowerCamelCase      (						self				):



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

    __lowerCamelCase													=    dqa_pipeline(image=__UpperCAmelCase	,				question=__UpperCAmelCase	,				top_k=2				)
    self.assertEqual(
        nested_simplify(__UpperCAmelCase	,				decimals=4				)	,				[
            {'''score''': 0.9_999, '''answer''': '''us-001''', '''start''': 16, '''end''': 16},
            {'''score''': 0.9_998, '''answer''': '''us-001''', '''start''': 16, '''end''': 16},
        ]	,				)

    __lowerCamelCase													=    dqa_pipeline(
        [{'''image''': image, '''question''': question}, {'''image''': image, '''question''': question}]	,				top_k=2				)
    self.assertEqual(
        nested_simplify(__UpperCAmelCase	,				decimals=4				)	,				[
            [
                {'''score''': 0.9_999, '''answer''': '''us-001''', '''start''': 16, '''end''': 16},
                {'''score''': 0.9_998, '''answer''': '''us-001''', '''start''': 16, '''end''': 16},
            ]
        ]
        * 2	,				)

    __lowerCamelCase													=    list(zip(*apply_tesseract(load_image(__UpperCAmelCase				)	,				__UpperCAmelCase	,				''''''				)				)				)

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




 @slow
 @require_torch
 def        lowerCamelCase      (						self				):



    '''simple docstring'''
    __lowerCamelCase													=    pipeline(
        '''document-question-answering'''	,				model='''naver-clova-ix/donut-base-finetuned-docvqa'''	,				tokenizer=AutoTokenizer.from_pretrained('''naver-clova-ix/donut-base-finetuned-docvqa'''				)	,				feature_extractor='''naver-clova-ix/donut-base-finetuned-docvqa'''	,				)

    __lowerCamelCase													=    INVOICE_URL
    __lowerCamelCase													=    '''What is the invoice number?'''
    __lowerCamelCase													=    dqa_pipeline(image=__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        lowerCamelCase      (						self				):



    '''simple docstring'''
    pass






