

import gc
import random
import unittest

import numpy as np
import torch

from diffusers import (
    DDIMScheduler,
    KandinskyVaaControlnetPipeline,
    KandinskyVaaPriorPipeline,
    UNetaDConditionModel,
    VQModel,
)
from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference


enable_full_determinism()






class _UpperCamelCase							(							__A							,	unittest.TestCase   ):
			'''simple docstring'''







			lowerCamelCase__           =KandinskyVaaControlnetPipeline
			lowerCamelCase__           =['image_embeds', 'negative_image_embeds', 'hint']
			lowerCamelCase__           =['image_embeds', 'negative_image_embeds', 'hint']
			lowerCamelCase__           =[
			    'generator',
			    'height',
			    'width',
			    'latents',
			    'guidance_scale',
			    'num_inference_steps',
			    'return_dict',
			    'guidance_scale',
			    'num_images_per_prompt',
			    'output_type',
			    'return_dict',
			]
			lowerCamelCase__           =False
			@property
			def 							__UpperCamelCase (			self							: Dict	)							->       Optional[Any]:

				"""simple docstring"""

				return 32
			@property
			def 							__UpperCamelCase (			self							: Dict	)							->       Optional[Any]:

				"""simple docstring"""

				return 32
			@property
			def 							__UpperCamelCase (			self							: List[str]	)							->       Dict:

				"""simple docstring"""

				return self.time_input_dim
			@property
			def 							__UpperCamelCase (			self							: Tuple	)							->       Optional[Any]:

				"""simple docstring"""

				return self.time_input_dim * 4
			@property
			def 							__UpperCamelCase (			self							: Optional[int]	)							->       Dict:

				"""simple docstring"""

				return 100
			@property
			def 							__UpperCamelCase (			self							: Optional[Any]	)							->       Union[str, Any]:

				"""simple docstring"""

				torch.manual_seed(0	)

				SCREAMING_SNAKE_CASE   :      Optional[Any]				     =       {
				    "in_channels": 8,
				    # Out channels is double in channels because predicts mean and variance
				    "out_channels": 8,
				    "addition_embed_type": "image_hint",
				    "down_block_types": ("ResnetDownsampleBlock2D", "SimpleCrossAttnDownBlock2D"),
				    "up_block_types": ("SimpleCrossAttnUpBlock2D", "ResnetUpsampleBlock2D"),
				    "mid_block_type": "UNetMidBlock2DSimpleCrossAttn",
				    "block_out_channels": (self.block_out_channels_a, self.block_out_channels_a * 2),
				    "layers_per_block": 1,
				    "encoder_hid_dim": self.text_embedder_hidden_size,
				    "encoder_hid_dim_type": "image_proj",
				    "cross_attention_dim": self.cross_attention_dim,
				    "attention_head_dim": 4,
				    "resnet_time_scale_shift": "scale_shift",
				    "class_embed_type": None,
				}

				SCREAMING_SNAKE_CASE   :      List[str]				     =       UNetaDConditionModel(**a	)
				return model
			@property
			def 							__UpperCamelCase (			self							: Tuple	)							->       Any:

				"""simple docstring"""

				return {
				    "block_out_channels": [32, 32, 64, 64],
				    "down_block_types": [
				        "DownEncoderBlock2D",
				        "DownEncoderBlock2D",
				        "DownEncoderBlock2D",
				        "AttnDownEncoderBlock2D",
				    ],
				    "in_channels": 3,
				    "latent_channels": 4,
				    "layers_per_block": 1,
				    "norm_num_groups": 8,
				    "norm_type": "spatial",
				    "num_vq_embeddings": 12,
				    "out_channels": 3,
				    "up_block_types": ["AttnUpDecoderBlock2D", "UpDecoderBlock2D", "UpDecoderBlock2D", "UpDecoderBlock2D"],
				    "vq_embed_dim": 4,
				}
			@property
			def 							__UpperCamelCase (			self							: Tuple	)							->       List[str]:

				"""simple docstring"""

				torch.manual_seed(0	)
				SCREAMING_SNAKE_CASE   :      Dict				     =       VQModel(**self.dummy_movq_kwargs	)
				return model
			def 							__UpperCamelCase (			self							: Tuple	)							->       List[str]:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE   :      Optional[int]				     =       self.dummy_unet
				SCREAMING_SNAKE_CASE   :      Any				     =       self.dummy_movq

				SCREAMING_SNAKE_CASE   :      Optional[Any]				     =       DDIMScheduler(
				    num_train_timesteps=1000      ,      beta_schedule="linear"      ,      beta_start=0.0_0085      ,      beta_end=0.012      ,      clip_sample=a      ,      set_alpha_to_one=a      ,      steps_offset=1      ,      prediction_type="epsilon"      ,      thresholding=a      ,      )

				SCREAMING_SNAKE_CASE   :      Tuple				     =       {
				    "unet": unet,
				    "scheduler": scheduler,
				    "movq": movq,
				}
				return components
			def 							__UpperCamelCase (			self							: Union[str, Any]      ,      a							: Optional[Any]      ,      a							: Union[str, Any]=0	)							->       str:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE   :      str				     =       floats_tensor((1, self.text_embedder_hidden_size)      ,      rng=random.Random(a	)	).to(a	)
				SCREAMING_SNAKE_CASE   :      str				     =       floats_tensor((1, self.text_embedder_hidden_size)      ,      rng=random.Random(seed + 1	)	).to(
				    a	)

				# create hint
				SCREAMING_SNAKE_CASE   :      Tuple				     =       floats_tensor((1, 3, 64, 64)      ,      rng=random.Random(a	)	).to(a	)

				if str(a	).startswith("mps"	):
					SCREAMING_SNAKE_CASE   :      str				     =       torch.manual_seed(a	)
				else:
					SCREAMING_SNAKE_CASE   :      Optional[int]				     =       torch.Generator(device=a	).manual_seed(a	)
				SCREAMING_SNAKE_CASE   :      int				     =       {
				    "image_embeds": image_embeds,
				    "negative_image_embeds": negative_image_embeds,
				    "hint": hint,
				    "generator": generator,
				    "height": 64,
				    "width": 64,
				    "guidance_scale": 4.0,
				    "num_inference_steps": 2,
				    "output_type": "np",
				}
				return inputs






			def 							__UpperCamelCase (			self							: Dict	)							->       List[str]:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE   :      int				     =       "cpu"

				SCREAMING_SNAKE_CASE   :      int				     =       self.get_dummy_components()

				SCREAMING_SNAKE_CASE   :      Optional[int]				     =       self.pipeline_class(**a	)
				SCREAMING_SNAKE_CASE   :      Dict				     =       pipe.to(a	)

				pipe.set_progress_bar_config(disable=a	)

				SCREAMING_SNAKE_CASE   :      Dict				     =       pipe(**self.get_dummy_inputs(a	)	)
				SCREAMING_SNAKE_CASE   :      Tuple				     =       output.images

				SCREAMING_SNAKE_CASE   :      Optional[Any]				     =       pipe(
				    **self.get_dummy_inputs(a	)      ,      return_dict=a      ,      )[0]

				SCREAMING_SNAKE_CASE   :      List[str]				     =       image[0, -3:, -3:, -1]
				SCREAMING_SNAKE_CASE   :      Tuple				     =       image_from_tuple[0, -3:, -3:, -1]

				assert image.shape == (1, 64, 64, 3)

				SCREAMING_SNAKE_CASE   :      Dict				     =       np.array(
				    [0.695_9826, 0.86_8279, 0.755_8092, 0.6876_9467, 0.8580_5804, 0.6597_7496, 0.4488_5302, 0.595_9111, 0.425_1595]	)

				assert (
				    np.abs(image_slice.flatten() - expected_slice	).max() < 1e-2
				), F" expected_slice {expected_slice}, but got {image_slice.flatten()}"

				assert (
				    np.abs(image_from_tuple_slice.flatten() - expected_slice	).max() < 1e-2
				), F" expected_slice {expected_slice}, but got {image_from_tuple_slice.flatten()}"






@slow
@require_torch_gpu
class _UpperCamelCase							(							unittest.TestCase   ):
			'''simple docstring'''







			def 							__UpperCamelCase (			self							: Any	)							->       Tuple:

				"""simple docstring"""

				super().tearDown()
				gc.collect()
				torch.cuda.empty_cache()






			def 							__UpperCamelCase (			self							: List[str]	)							->       List[Any]:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE   :      Union[str, Any]				     =       load_numpy(
				    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
				    "/kandinskyv22/kandinskyv22_controlnet_robotcat_fp16.npy"	)

				SCREAMING_SNAKE_CASE   :      Union[str, Any]				     =       load_image(
				    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
				    "/kandinskyv22/hint_image_cat.png"	)
				SCREAMING_SNAKE_CASE   :      List[Any]				     =       torch.from_numpy(np.array(a	)	).float() / 255.0
				SCREAMING_SNAKE_CASE   :      List[str]				     =       hint.permute(2      ,      0      ,      1	).unsqueeze(0	)

				SCREAMING_SNAKE_CASE   :      Optional[Any]				     =       KandinskyVaaPriorPipeline.from_pretrained(
				    "kandinsky-community/kandinsky-2-2-prior"      ,      torch_dtype=torch.floataa	)
				pipe_prior.to(a	)

				SCREAMING_SNAKE_CASE   :      List[Any]				     =       KandinskyVaaControlnetPipeline.from_pretrained(
				    "kandinsky-community/kandinsky-2-2-controlnet-depth"      ,      torch_dtype=torch.floataa	)
				SCREAMING_SNAKE_CASE   :      List[str]				     =       pipeline.to(a	)
				pipeline.set_progress_bar_config(disable=a	)

				SCREAMING_SNAKE_CASE   :      Optional[int]				     =       "A robot, 4k photo"

				SCREAMING_SNAKE_CASE   :      Optional[Any]				     =       torch.Generator(device="cuda"	).manual_seed(0	)
				SCREAMING_SNAKE_CASE     ,SCREAMING_SNAKE_CASE   :      Optional[int]				     =       pipe_prior(
				    a      ,      generator=a      ,      num_inference_steps=5      ,      negative_prompt=""      ,      ).to_tuple()

				SCREAMING_SNAKE_CASE   :      Optional[int]				     =       torch.Generator(device="cuda"	).manual_seed(0	)
				SCREAMING_SNAKE_CASE   :      Union[str, Any]				     =       pipeline(
				    image_embeds=a      ,      negative_image_embeds=a      ,      hint=a      ,      generator=a      ,      num_inference_steps=100      ,      output_type="np"      ,      )

				SCREAMING_SNAKE_CASE   :      Any				     =       output.images[0]

				assert image.shape == (512, 512, 3)

				assert_mean_pixel_difference(a      ,      a	)


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 _UpperCamelCase							:
						'''simple docstring'''







						@staticmethod
						def 							__UpperCamelCase (			*a							: Any      ,      **a							: Optional[int]	)							->       Optional[Any]:

							"""simple docstring"""

							pass

			def  lowerCamelCase__ (					_a):
				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 _UpperCamelCase							(							unittest.TestCase   ):
			'''simple docstring'''







			lowerCamelCase__           =MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING
			@require_pytesseract
			@require_vision
			def 							__UpperCamelCase (			self							: Tuple      ,      a							: Union[str, Any]      ,      a							: Any      ,      a							: Optional[Any]	)							->       List[str]:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE   :      int				     =       pipeline(
				    "document-question-answering"      ,      model=a      ,      tokenizer=a      ,      image_processor=a	)

				SCREAMING_SNAKE_CASE   :      Dict				     =       INVOICE_URL
				SCREAMING_SNAKE_CASE   :      int				     =       list(zip(*apply_tesseract(load_image(a	)      ,      a      ,      ""	)	)	)
				SCREAMING_SNAKE_CASE   :      Union[str, Any]				     =       "What is the placebo?"
				SCREAMING_SNAKE_CASE   :      List[str]				     =       [
				    {
				        "image": load_image(a	),
				        "question": question,
				    },
				    {
				        "image": image,
				        "question": question,
				    },
				    {
				        "image": image,
				        "question": question,
				        "word_boxes": word_boxes,
				    },
				]
				return dqa_pipeline, examples
			def 							__UpperCamelCase (			self							: List[str]      ,      a							: List[Any]      ,      a							: Any	)							->       Optional[Any]:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE   :      Optional[int]				     =       dqa_pipeline(a      ,      top_k=2	)
				self.assertEqual(
				    a      ,      [
				        [
				            {"score": ANY(a	), "answer": ANY(a	), "start": ANY(a	), "end": ANY(a	)},
				            {"score": ANY(a	), "answer": ANY(a	), "start": ANY(a	), "end": ANY(a	)},
				        ]
				    ]
				    * 3      ,      )
			@require_torch
			@require_detectrona
			@require_pytesseract
			def 							__UpperCamelCase (			self							: Optional[int]	)							->       Optional[int]:

				"""simple docstring"""

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

				SCREAMING_SNAKE_CASE   :      Optional[int]				     =       [
				    {"score": 0.0001, "answer": "oy 2312/2019", "start": 38, "end": 39},
				    {"score": 0.0001, "answer": "oy 2312/2019 DUE", "start": 38, "end": 40},
				]
				SCREAMING_SNAKE_CASE   :      Union[str, Any]				     =       dqa_pipeline(image=a      ,      question=a      ,      top_k=2	)
				self.assertEqual(nested_simplify(a      ,      decimals=4	)      ,      a	)

				SCREAMING_SNAKE_CASE   :      Any				     =       dqa_pipeline({"image": image, "question": question}      ,      top_k=2	)
				self.assertEqual(nested_simplify(a      ,      decimals=4	)      ,      a	)

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

				# We can optionnally pass directly the words and bounding boxes
				SCREAMING_SNAKE_CASE   :      Optional[int]				     =       "./tests/fixtures/tests_samples/COCO/000000039769.png"
				SCREAMING_SNAKE_CASE   :      Union[str, Any]				     =       []
				SCREAMING_SNAKE_CASE   :      int				     =       []
				SCREAMING_SNAKE_CASE   :      str				     =       dqa_pipeline(image=a      ,      question=a      ,      words=a      ,      boxes=a      ,      top_k=2	)
				self.assertEqual(a      ,      []	)
			@slow
			@require_torch
			@require_detectrona
			@require_pytesseract
			def 							__UpperCamelCase (			self							: Optional[int]	)							->       Union[str, Any]:

				"""simple docstring"""

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

				SCREAMING_SNAKE_CASE   :      Dict				     =       dqa_pipeline(image=a      ,      question=a      ,      top_k=2	)
				self.assertEqual(
				    nested_simplify(a      ,      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[Any]				     =       dqa_pipeline({"image": image, "question": question}      ,      top_k=2	)
				self.assertEqual(
				    nested_simplify(a      ,      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   :      Any				     =       dqa_pipeline(
				    [{"image": image, "question": question}, {"image": image, "question": question}]      ,      top_k=2	)
				self.assertEqual(
				    nested_simplify(a      ,      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 							__UpperCamelCase (			self							: Tuple	)							->       Union[str, Any]:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE   :      Optional[Any]				     =       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   :      int				     =       "What is the invoice number?"

				SCREAMING_SNAKE_CASE   :      Any				     =       dqa_pipeline(image=a      ,      question=a      ,      top_k=2	)
				self.assertEqual(
				    nested_simplify(a      ,      decimals=4	)      ,      [
				        {"score": 0.9974, "answer": "1110212019", "start": 23, "end": 23},
				        {"score": 0.9948, "answer": "us-001", "start": 16, "end": 16},
				    ]      ,      )

				SCREAMING_SNAKE_CASE   :      Tuple				     =       dqa_pipeline({"image": image, "question": question}      ,      top_k=2	)
				self.assertEqual(
				    nested_simplify(a      ,      decimals=4	)      ,      [
				        {"score": 0.9974, "answer": "1110212019", "start": 23, "end": 23},
				        {"score": 0.9948, "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(a      ,      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 							__UpperCamelCase (			self							: Union[str, Any]	)							->       Optional[Any]:

				"""simple docstring"""

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

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

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

				# 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(a      ,      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 							__UpperCamelCase (			self							: Tuple	)							->       List[Any]:

				"""simple docstring"""

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

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

				# This model should also work if `image` is set to None
				SCREAMING_SNAKE_CASE   :      Any				     =       dqa_pipeline({"image": None, "word_boxes": word_boxes, "question": question}      ,      top_k=2	)
				self.assertEqual(
				    nested_simplify(a      ,      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 							__UpperCamelCase (			self							: str	)							->       int:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE   :      List[str]				     =       pipeline(
				    "document-question-answering"      ,      model="naver-clova-ix/donut-base-finetuned-docvqa"      ,      tokenizer=AutoTokenizer.from_pretrained("naver-clova-ix/donut-base-finetuned-docvqa"	)      ,      feature_extractor="naver-clova-ix/donut-base-finetuned-docvqa"      ,      )

				SCREAMING_SNAKE_CASE   :      int				     =       INVOICE_URL
				SCREAMING_SNAKE_CASE   :      Union[str, Any]				     =       "What is the invoice number?"
				SCREAMING_SNAKE_CASE   :      Union[str, Any]				     =       dqa_pipeline(image=a      ,      question=a      ,      top_k=2	)
				self.assertEqual(nested_simplify(a      ,      decimals=4	)      ,      [{"answer": "us-001"}]	)






			@require_tf
			@unittest.skip("Document question answering not implemented in TF"	)
			def 							__UpperCamelCase (			self							: List[str]	)							->       int:

				"""simple docstring"""

				pass