
import argparse
import json
from pathlib import Path

import torch
import torchaudio
from datasets import load_dataset
from huggingface_hub import hf_hub_download

from transformers import ASTConfig, ASTFeatureExtractor, ASTForAudioClassification
from transformers.utils import logging


logging.set_verbosity_info()
__lowerCAmelCase					:			str			      =		logging.get_logger(__name__)


def     UpperCAmelCase_  (						__lowerCAmelCase	) ->						int:
    __lowercase		:			Dict	    =       ASTConfig()

    if "10-10" in model_name:
        pass
    elif "speech-commands" in model_name:
        __lowercase		:			str	    =       128
    elif "12-12" in model_name:
        __lowercase		:			List[Any]	    =       12
        __lowercase		:			Optional[int]	    =       12
    elif "14-14" in model_name:
        __lowercase		:			Any	    =       14
        __lowercase		:			Optional[Any]	    =       14
    elif "16-16" in model_name:
        __lowercase		:			int	    =       16
        __lowercase		:			List[str]	    =       16
    else:
        raise ValueError('''Model not supported'''	)

    __lowercase		:			Optional[Any]	    =       '''huggingface/label-files'''
    if "speech-commands" in model_name:
        __lowercase		:			Optional[int]	    =       35
        __lowercase		:			Tuple	    =       '''speech-commands-v2-id2label.json'''
    else:
        __lowercase		:			Tuple	    =       527
        __lowercase		:			Optional[int]	    =       '''audioset-id2label.json'''

    __lowercase		:			List[str]	    =       json.load(open(hf_hub_download(A_	,					A_	,					repo_type='''dataset'''	)	,					'''r'''	)	)
    __lowercase		:			int	    =       {int(A_	): v for k, v in idalabel.items()}
    __lowercase		:			int	    =       idalabel
    __lowercase		:			Union[str, Any]	    =       {v: k for k, v in idalabel.items()}

    return config


def     UpperCAmelCase_  (						__lowerCAmelCase	) ->						int:





    if "module.v" in name:
        __lowercase		:			int	    =       name.replace('''module.v'''	,					'''audio_spectrogram_transformer'''	)
    if "cls_token" in name:
        __lowercase		:			Optional[int]	    =       name.replace('''cls_token'''	,					'''embeddings.cls_token'''	)
    if "dist_token" in name:
        __lowercase		:			Optional[Any]	    =       name.replace('''dist_token'''	,					'''embeddings.distillation_token'''	)
    if "pos_embed" in name:
        __lowercase		:			Optional[Any]	    =       name.replace('''pos_embed'''	,					'''embeddings.position_embeddings'''	)
    if "patch_embed.proj" in name:
        __lowercase		:			Optional[int]	    =       name.replace('''patch_embed.proj'''	,					'''embeddings.patch_embeddings.projection'''	)
    # transformer blocks
    if "blocks" in name:
        __lowercase		:			Union[str, Any]	    =       name.replace('''blocks'''	,					'''encoder.layer'''	)
    if "attn.proj" in name:
        __lowercase		:			Optional[Any]	    =       name.replace('''attn.proj'''	,					'''attention.output.dense'''	)
    if "attn" in name:
        __lowercase		:			Dict	    =       name.replace('''attn'''	,					'''attention.self'''	)
    if "norm1" in name:
        __lowercase		:			Dict	    =       name.replace('''norm1'''	,					'''layernorm_before'''	)
    if "norm2" in name:
        __lowercase		:			Optional[Any]	    =       name.replace('''norm2'''	,					'''layernorm_after'''	)
    if "mlp.fc1" in name:
        __lowercase		:			str	    =       name.replace('''mlp.fc1'''	,					'''intermediate.dense'''	)
    if "mlp.fc2" in name:
        __lowercase		:			Dict	    =       name.replace('''mlp.fc2'''	,					'''output.dense'''	)
    # final layernorm
    if "audio_spectrogram_transformer.norm" in name:
        __lowercase		:			Optional[Any]	    =       name.replace('''audio_spectrogram_transformer.norm'''	,					'''audio_spectrogram_transformer.layernorm'''	)
    # classifier head
    if "module.mlp_head.0" in name:
        __lowercase		:			List[str]	    =       name.replace('''module.mlp_head.0'''	,					'''classifier.layernorm'''	)
    if "module.mlp_head.1" in name:
        __lowercase		:			List[Any]	    =       name.replace('''module.mlp_head.1'''	,					'''classifier.dense'''	)

    return name


def     UpperCAmelCase_  (						__lowerCAmelCase	,					__lowerCAmelCase	) ->						Dict:





    for key in orig_state_dict.copy().keys():
        __lowercase		:			int	    =       orig_state_dict.pop(A_	)

        if "qkv" in key:
            __lowercase		:			Dict	    =       key.split('''.'''	)
            __lowercase		:			str	    =       int(key_split[3]	)
            __lowercase		:			Any	    =       config.hidden_size
            if "weight" in key:
                __lowercase		:			Optional[Any]	    =       val[:dim, :]
                __lowercase		:			str	    =       val[dim : dim * 2, :]
                __lowercase		:			str	    =       val[-dim:, :]
            else:
                __lowercase		:			Union[str, Any]	    =       val[:dim]
                __lowercase		:			Optional[Any]	    =       val[dim : dim * 2]
                __lowercase		:			Optional[int]	    =       val[-dim:]
        else:
            __lowercase		:			Optional[Any]	    =       val

    return orig_state_dict


def     UpperCAmelCase_  (						__lowerCAmelCase	) ->						Optional[Any]:
    __lowercase		:			int	    =       [
        '''module.v.head.weight''',
        '''module.v.head.bias''',
        '''module.v.head_dist.weight''',
        '''module.v.head_dist.bias''',
    ]
    for k in ignore_keys:
        state_dict.pop(A_	,					A_	)


@torch.no_grad()
def     UpperCAmelCase_  (						__lowerCAmelCase	,					__lowerCAmelCase	,					__lowerCAmelCase=False	) ->						List[Any]:
    __lowercase		:			str	    =       get_audio_spectrogram_transformer_config(A_	)

    __lowercase		:			Optional[int]	    =       {
        '''ast-finetuned-audioset-10-10-0.4593''': (
            '''https://www.dropbox.com/s/ca0b1v2nlxzyeb4/audioset_10_10_0.4593.pth?dl=1'''
        ),
        '''ast-finetuned-audioset-10-10-0.450''': (
            '''https://www.dropbox.com/s/1tv0hovue1bxupk/audioset_10_10_0.4495.pth?dl=1'''
        ),
        '''ast-finetuned-audioset-10-10-0.448''': (
            '''https://www.dropbox.com/s/6u5sikl4b9wo4u5/audioset_10_10_0.4483.pth?dl=1'''
        ),
        '''ast-finetuned-audioset-10-10-0.448-v2''': (
            '''https://www.dropbox.com/s/kt6i0v9fvfm1mbq/audioset_10_10_0.4475.pth?dl=1'''
        ),
        '''ast-finetuned-audioset-12-12-0.447''': (
            '''https://www.dropbox.com/s/snfhx3tizr4nuc8/audioset_12_12_0.4467.pth?dl=1'''
        ),
        '''ast-finetuned-audioset-14-14-0.443''': (
            '''https://www.dropbox.com/s/z18s6pemtnxm4k7/audioset_14_14_0.4431.pth?dl=1'''
        ),
        '''ast-finetuned-audioset-16-16-0.442''': (
            '''https://www.dropbox.com/s/mdsa4t1xmcimia6/audioset_16_16_0.4422.pth?dl=1'''
        ),
        '''ast-finetuned-speech-commands-v2''': (
            '''https://www.dropbox.com/s/q0tbqpwv44pquwy/speechcommands_10_10_0.9812.pth?dl=1'''
        ),
    }

    # load original state_dict
    __lowercase		:			List[Any]	    =       model_name_to_url[model_name]
    __lowercase		:			int	    =       torch.hub.load_state_dict_from_url(A_	,					map_location='''cpu'''	)
    # remove some keys
    remove_keys(A_	)
    # rename some keys
    __lowercase		:			int	    =       convert_state_dict(A_	,					A_	)

    # load 🤗 model
    __lowercase		:			List[Any]	    =       ASTForAudioClassification(A_	)
    model.eval()

    model.load_state_dict(A_	)

    # verify outputs on dummy input
    # source: https://github.com/YuanGongND/ast/blob/79e873b8a54d0a3b330dd522584ff2b9926cd581/src/run.py#L62
    __lowercase		:			Tuple	    =       -4.2677393 if '''speech-commands''' not in model_name else -6.845978
    __lowercase		:			Optional[Any]	    =       4.5689974 if '''speech-commands''' not in model_name else 5.5654526
    __lowercase		:			int	    =       1_024 if '''speech-commands''' not in model_name else 128
    __lowercase		:			str	    =       ASTFeatureExtractor(mean=A_	,					std=A_	,					max_length=A_	)

    if "speech-commands" in model_name:
        __lowercase		:			int	    =       load_dataset('''speech_commands'''	,					'''v0.02'''	,					split='''validation'''	)
        __lowercase		:			int	    =       dataset[0]['''audio''']['''array''']
    else:
        __lowercase		:			str	    =       hf_hub_download(
            repo_id='''nielsr/audio-spectogram-transformer-checkpoint'''	,					filename='''sample_audio.flac'''	,					repo_type='''dataset'''	,					)

        __lowercase    ,      __lowercase		:			List[str]	    =       torchaudio.load(A_	)
        __lowercase		:			Any	    =       waveform.squeeze().numpy()

    __lowercase		:			Dict	    =       feature_extractor(A_	,					sampling_rate=16_000	,					return_tensors='''pt'''	)

    # forward pass
    __lowercase		:			Union[str, Any]	    =       model(**A_	)
    __lowercase		:			List[str]	    =       outputs.logits

    if model_name == "ast-finetuned-audioset-10-10-0.4593":
        __lowercase		:			str	    =       torch.tensor([-0.8760, -7.0042, -8.6602]	)
    elif model_name == "ast-finetuned-audioset-10-10-0.450":
        __lowercase		:			Optional[int]	    =       torch.tensor([-1.1986, -7.0903, -8.2718]	)
    elif model_name == "ast-finetuned-audioset-10-10-0.448":
        __lowercase		:			Tuple	    =       torch.tensor([-2.6128, -8.0080, -9.4344]	)
    elif model_name == "ast-finetuned-audioset-10-10-0.448-v2":
        __lowercase		:			Tuple	    =       torch.tensor([-1.5080, -7.4534, -8.8917]	)
    elif model_name == "ast-finetuned-audioset-12-12-0.447":
        __lowercase		:			str	    =       torch.tensor([-0.5050, -6.5833, -8.0843]	)
    elif model_name == "ast-finetuned-audioset-14-14-0.443":
        __lowercase		:			Any	    =       torch.tensor([-0.3826, -7.0336, -8.2413]	)
    elif model_name == "ast-finetuned-audioset-16-16-0.442":
        __lowercase		:			Optional[Any]	    =       torch.tensor([-1.2113, -6.9101, -8.3470]	)
    elif model_name == "ast-finetuned-speech-commands-v2":
        __lowercase		:			Tuple	    =       torch.tensor([6.1589, -8.0566, -8.7984]	)
    else:
        raise ValueError('''Unknown model name'''	)
    if not torch.allclose(logits[0, :3]	,					A_	,					atol=1E-4	):
        raise ValueError('''Logits don\'t match'''	)
    print('''Looks ok!'''	)

    if pytorch_dump_folder_path is not None:
        Path(A_	).mkdir(exist_ok=A_	)
        print(F'Saving model {model_name} to {pytorch_dump_folder_path}'	)
        model.save_pretrained(A_	)
        print(F'Saving feature extractor to {pytorch_dump_folder_path}'	)
        feature_extractor.save_pretrained(A_	)

    if push_to_hub:
        print('''Pushing model and feature extractor to the hub...'''	)
        model.push_to_hub(F'MIT/{model_name}'	)
        feature_extractor.push_to_hub(F'MIT/{model_name}'	)


if __name__ == "__main__":
 __lowerCAmelCase					:			List[str]			      =		argparse.ArgumentParser()
 # Required parameters
 parser.add_argument(
     "--model_name",
     default="ast-finetuned-audioset-10-10-0.4593",
     type=str,
     help="Name of the Audio Spectrogram Transformer model you\'d like to convert.",
 )
 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."
 )

 __lowerCAmelCase					:			Any			      =		parser.parse_args()
 convert_audio_spectrogram_transformer_checkpoint(args.model_name, 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	:



       """simple docstring"""







       @staticmethod
       def 		snake_case_			(      *_snake_case		:       Union[str, Any]				,       **_snake_case		:       str				):
           pass






 def     UpperCAmelCase_  (						__lowerCAmelCase	) ->						Union[str, Any]:
     return None


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


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



      """simple docstring"""







      A__	:			int        =    MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING




      @require_pytesseract
      @require_vision
      def 		snake_case_			(      self		:       List[Any]				,       _snake_case		:       Any				,       _snake_case		:       Dict				,       _snake_case		:       Any				):
          __lowercase		:			List[str]	    =       pipeline(
              '''document-question-answering'''				,       model=_snake_case				,       tokenizer=_snake_case				,       image_processor=_snake_case				)

          __lowercase		:			int	    =       INVOICE_URL
          __lowercase		:			Optional[int]	    =       list(zip(*apply_tesseract(load_image(_snake_case				)				,       _snake_case				,       ''''''				)				)				)
          __lowercase		:			List[str]	    =       '''What is the placebo?'''
          __lowercase		:			Tuple	    =       [
              {
                  '''image''': load_image(_snake_case				),
                  '''question''': question,
              },
              {
                  '''image''': image,
                  '''question''': question,
              },
              {
                  '''image''': image,
                  '''question''': question,
                  '''word_boxes''': word_boxes,
              },
          ]
          return dqa_pipeline, examples




      def 		snake_case_			(      self		:       List[str]				,       _snake_case		:       int				,       _snake_case		:       List[Any]				):
          __lowercase		:			Optional[Any]	    =       dqa_pipeline(_snake_case				,       top_k=2				)
          self.assertEqual(
              _snake_case				,       [
                  [
                      {'''score''': ANY(_snake_case				), '''answer''': ANY(_snake_case				), '''start''': ANY(_snake_case				), '''end''': ANY(_snake_case				)},
                      {'''score''': ANY(_snake_case				), '''answer''': ANY(_snake_case				), '''start''': ANY(_snake_case				), '''end''': ANY(_snake_case				)},
                  ]
              ]
              * 3				,       )




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

          __lowercase		:			Optional[int]	    =       [
              {'''score''': 0.00_01, '''answer''': '''oy 2312/2019''', '''start''': 38, '''end''': 39},
              {'''score''': 0.00_01, '''answer''': '''oy 2312/2019 DUE''', '''start''': 38, '''end''': 40},
          ]
          __lowercase		:			Optional[Any]	    =       dqa_pipeline(image=_snake_case				,       question=_snake_case				,       top_k=2				)
          self.assertEqual(nested_simplify(_snake_case				,       decimals=4				)				,       _snake_case				)

          __lowercase		:			Optional[Any]	    =       dqa_pipeline({'''image''': image, '''question''': question}				,       top_k=2				)
          self.assertEqual(nested_simplify(_snake_case				,       decimals=4				)				,       _snake_case				)

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

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




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

          __lowercase		:			int	    =       dqa_pipeline(image=_snake_case				,       question=_snake_case				,       top_k=2				)
          self.assertEqual(
              nested_simplify(_snake_case				,       decimals=4				)				,       [
                  {'''score''': 0.99_44, '''answer''': '''us-001''', '''start''': 16, '''end''': 16},
                  {'''score''': 0.00_09, '''answer''': '''us-001''', '''start''': 16, '''end''': 16},
              ]				,       )

          __lowercase		:			Union[str, Any]	    =       dqa_pipeline({'''image''': image, '''question''': question}				,       top_k=2				)
          self.assertEqual(
              nested_simplify(_snake_case				,       decimals=4				)				,       [
                  {'''score''': 0.99_44, '''answer''': '''us-001''', '''start''': 16, '''end''': 16},
                  {'''score''': 0.00_09, '''answer''': '''us-001''', '''start''': 16, '''end''': 16},
              ]				,       )

          __lowercase		:			List[str]	    =       dqa_pipeline(
              [{'''image''': image, '''question''': question}, {'''image''': image, '''question''': question}]				,       top_k=2				)
          self.assertEqual(
              nested_simplify(_snake_case				,       decimals=4				)				,       [
                  [
                      {'''score''': 0.99_44, '''answer''': '''us-001''', '''start''': 16, '''end''': 16},
                      {'''score''': 0.00_09, '''answer''': '''us-001''', '''start''': 16, '''end''': 16},
                  ],
              ]
              * 2				,       )




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

          __lowercase		:			Any	    =       dqa_pipeline(image=_snake_case				,       question=_snake_case				,       top_k=2				)
          self.assertEqual(
              nested_simplify(_snake_case				,       decimals=4				)				,       [
                  {'''score''': 0.99_74, '''answer''': '''1110212019''', '''start''': 23, '''end''': 23},
                  {'''score''': 0.99_48, '''answer''': '''us-001''', '''start''': 16, '''end''': 16},
              ]				,       )

          __lowercase		:			Dict	    =       dqa_pipeline({'''image''': image, '''question''': question}				,       top_k=2				)
          self.assertEqual(
              nested_simplify(_snake_case				,       decimals=4				)				,       [
                  {'''score''': 0.99_74, '''answer''': '''1110212019''', '''start''': 23, '''end''': 23},
                  {'''score''': 0.99_48, '''answer''': '''us-001''', '''start''': 16, '''end''': 16},
              ]				,       )

          __lowercase		:			List[Any]	    =       dqa_pipeline(
              [{'''image''': image, '''question''': question}, {'''image''': image, '''question''': question}]				,       top_k=2				)
          self.assertEqual(
              nested_simplify(_snake_case				,       decimals=4				)				,       [
                  [
                      {'''score''': 0.99_74, '''answer''': '''1110212019''', '''start''': 23, '''end''': 23},
                      {'''score''': 0.99_48, '''answer''': '''us-001''', '''start''': 16, '''end''': 16},
                  ]
              ]
              * 2				,       )




      @slow
      @require_torch
      @require_pytesseract
      @require_vision
      def 		snake_case_			(      self		:       str				):
          __lowercase		:			List[Any]	    =       AutoTokenizer.from_pretrained(
              '''impira/layoutlm-document-qa'''				,       revision='''3dc6de3'''				,       add_prefix_space=_snake_case				)
          __lowercase		:			Union[str, Any]	    =       pipeline(
              '''document-question-answering'''				,       model='''impira/layoutlm-document-qa'''				,       tokenizer=_snake_case				,       revision='''3dc6de3'''				,       )
          __lowercase		:			Tuple	    =       INVOICE_URL
          __lowercase		:			Any	    =       '''What is the invoice number?'''

          __lowercase		:			Optional[Any]	    =       dqa_pipeline(image=_snake_case				,       question=_snake_case				,       top_k=2				)
          self.assertEqual(
              nested_simplify(_snake_case				,       decimals=4				)				,       [
                  {'''score''': 0.42_51, '''answer''': '''us-001''', '''start''': 16, '''end''': 16},
                  {'''score''': 0.08_19, '''answer''': '''1110212019''', '''start''': 23, '''end''': 23},
              ]				,       )

          __lowercase		:			List[Any]	    =       dqa_pipeline({'''image''': image, '''question''': question}				,       top_k=2				)
          self.assertEqual(
              nested_simplify(_snake_case				,       decimals=4				)				,       [
                  {'''score''': 0.42_51, '''answer''': '''us-001''', '''start''': 16, '''end''': 16},
                  {'''score''': 0.08_19, '''answer''': '''1110212019''', '''start''': 23, '''end''': 23},
              ]				,       )

          __lowercase		:			int	    =       dqa_pipeline(
              [{'''image''': image, '''question''': question}, {'''image''': image, '''question''': question}]				,       top_k=2				)
          self.assertEqual(
              nested_simplify(_snake_case				,       decimals=4				)				,       [
                  [
                      {'''score''': 0.42_51, '''answer''': '''us-001''', '''start''': 16, '''end''': 16},
                      {'''score''': 0.08_19, '''answer''': '''1110212019''', '''start''': 23, '''end''': 23},
                  ]
              ]
              * 2				,       )

          __lowercase		:			Union[str, Any]	    =       list(zip(*apply_tesseract(load_image(_snake_case				)				,       _snake_case				,       ''''''				)				)				)

          # This model should also work if `image` is set to None
          __lowercase		:			Union[str, Any]	    =       dqa_pipeline({'''image''': None, '''word_boxes''': word_boxes, '''question''': question}				,       top_k=2				)
          self.assertEqual(
              nested_simplify(_snake_case				,       decimals=4				)				,       [
                  {'''score''': 0.42_51, '''answer''': '''us-001''', '''start''': 16, '''end''': 16},
                  {'''score''': 0.08_19, '''answer''': '''1110212019''', '''start''': 23, '''end''': 23},
              ]				,       )




      @slow
      @require_torch
      @require_pytesseract
      @require_vision
      def 		snake_case_			(      self		:       List[str]				):
          __lowercase		:			Optional[int]	    =       AutoTokenizer.from_pretrained(
              '''impira/layoutlm-document-qa'''				,       revision='''3dc6de3'''				,       add_prefix_space=_snake_case				)
          __lowercase		:			List[str]	    =       pipeline(
              '''document-question-answering'''				,       model='''impira/layoutlm-document-qa'''				,       tokenizer=_snake_case				,       revision='''3dc6de3'''				,       max_seq_len=50				,       )
          __lowercase		:			Tuple	    =       INVOICE_URL
          __lowercase		:			Optional[int]	    =       '''What is the invoice number?'''

          __lowercase		:			Any	    =       dqa_pipeline(image=_snake_case				,       question=_snake_case				,       top_k=2				)
          self.assertEqual(
              nested_simplify(_snake_case				,       decimals=4				)				,       [
                  {'''score''': 0.99_99, '''answer''': '''us-001''', '''start''': 16, '''end''': 16},
                  {'''score''': 0.99_98, '''answer''': '''us-001''', '''start''': 16, '''end''': 16},
              ]				,       )

          __lowercase		:			Any	    =       dqa_pipeline(
              [{'''image''': image, '''question''': question}, {'''image''': image, '''question''': question}]				,       top_k=2				)
          self.assertEqual(
              nested_simplify(_snake_case				,       decimals=4				)				,       [
                  [
                      {'''score''': 0.99_99, '''answer''': '''us-001''', '''start''': 16, '''end''': 16},
                      {'''score''': 0.99_98, '''answer''': '''us-001''', '''start''': 16, '''end''': 16},
                  ]
              ]
              * 2				,       )

          __lowercase		:			int	    =       list(zip(*apply_tesseract(load_image(_snake_case				)				,       _snake_case				,       ''''''				)				)				)

          # This model should also work if `image` is set to None
          __lowercase		:			Tuple	    =       dqa_pipeline({'''image''': None, '''word_boxes''': word_boxes, '''question''': question}				,       top_k=2				)
          self.assertEqual(
              nested_simplify(_snake_case				,       decimals=4				)				,       [
                  {'''score''': 0.99_99, '''answer''': '''us-001''', '''start''': 16, '''end''': 16},
                  {'''score''': 0.99_98, '''answer''': '''us-001''', '''start''': 16, '''end''': 16},
              ]				,       )




      @slow
      @require_torch
      def 		snake_case_			(      self		:       List[Any]				):
          __lowercase		:			int	    =       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'''				,       )

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




      @require_tf
      @unittest.skip('''Document question answering not implemented in TF'''				)
      def 		snake_case_			(      self		:       int				):
          pass


