import gc
import random
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import AutoencoderKL, CycleDiffusionPipeline, DDIMScheduler, UNetaDConditionModel
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, skip_mps

from ..pipeline_params import (
    IMAGE_TO_IMAGE_IMAGE_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_PARAMS,
)
from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()


class 	lowerCamelCase_     (   UpperCAmelCase_						,	UpperCAmelCase_						,	unittest.TestCase ):






    '''simple docstring'''






    a__	:						str						=      CycleDiffusionPipeline
    a__	:						List[str]						=      TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {
        """negative_prompt""",
        """height""",
        """width""",
        """negative_prompt_embeds""",
    }
    a__	:						Union[str, Any]						=      PipelineTesterMixin.required_optional_params - {"""latents"""}
    a__	:						List[Any]						=      TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({"""source_prompt"""} )
    a__	:						List[str]						=      IMAGE_TO_IMAGE_IMAGE_PARAMS
    a__	:						str						=      IMAGE_TO_IMAGE_IMAGE_PARAMS







    def 			UpperCamelCase__   (	self)       ->	Any:
        torch.manual_seed(0)
        __UpperCamelCase     :Union[str, Any]			  =		UNetaDConditionModel(
            block_out_channels=(32, 64) , layers_per_block=2 , sample_size=32 , in_channels=4 , out_channels=4 , down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''') , up_block_types=('''CrossAttnUpBlock2D''', '''UpBlock2D''') , cross_attention_dim=32 , )
        __UpperCamelCase     :Any			  =		DDIMScheduler(
            beta_start=0.0_00_85 , beta_end=0.0_12 , beta_schedule='''scaled_linear''' , num_train_timesteps=1_000 , clip_sample=__lowercase , set_alpha_to_one=__lowercase , )
        torch.manual_seed(0)
        __UpperCamelCase     :Any			  =		AutoencoderKL(
            block_out_channels=[32, 64] , in_channels=3 , out_channels=3 , down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D'''] , up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D'''] , latent_channels=4 , )
        torch.manual_seed(0)
        __UpperCamelCase     :Tuple			  =		CLIPTextConfig(
            bos_token_id=0 , eos_token_id=2 , hidden_size=32 , intermediate_size=37 , layer_norm_eps=1E-0_5 , num_attention_heads=4 , num_hidden_layers=5 , pad_token_id=1 , vocab_size=1_000 , )
        __UpperCamelCase     :List[str]			  =		CLIPTextModel(__lowercase)
        __UpperCamelCase     :Tuple			  =		CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip''')

        __UpperCamelCase     :str			  =		{
            '''unet''': unet,
            '''scheduler''': scheduler,
            '''vae''': vae,
            '''text_encoder''': text_encoder,
            '''tokenizer''': tokenizer,
            '''safety_checker''': None,
            '''feature_extractor''': None,
        }
        return components







    def 			UpperCamelCase__   (	self , __lowercase , __lowercase=0)       ->	str:
        __UpperCamelCase     :List[str]			  =		floats_tensor((1, 3, 32, 32) , rng=random.Random(__lowercase)).to(__lowercase)
        __UpperCamelCase     :List[Any]			  =		image / 2 + 0.5
        if str(__lowercase).startswith('''mps'''):
            __UpperCamelCase     :Optional[int]			  =		torch.manual_seed(__lowercase)
        else:
            __UpperCamelCase     :Optional[int]			  =		torch.Generator(device=__lowercase).manual_seed(__lowercase)
        __UpperCamelCase     :Any			  =		{
            '''prompt''': '''An astronaut riding an elephant''',
            '''source_prompt''': '''An astronaut riding a horse''',
            '''image''': image,
            '''generator''': generator,
            '''num_inference_steps''': 2,
            '''eta''': 0.1,
            '''strength''': 0.8,
            '''guidance_scale''': 3,
            '''source_guidance_scale''': 1,
            '''output_type''': '''numpy''',
        }
        return inputs







    def 			UpperCamelCase__   (	self)       ->	List[Any]:
        __UpperCamelCase     :Optional[Any]			  =		'''cpu'''  # ensure determinism for the device-dependent torch.Generator

        __UpperCamelCase     :Optional[Any]			  =		self.get_dummy_components()
        __UpperCamelCase     :List[str]			  =		CycleDiffusionPipeline(**__lowercase)
        __UpperCamelCase     :Tuple			  =		pipe.to(__lowercase)
        pipe.set_progress_bar_config(disable=__lowercase)

        __UpperCamelCase     :List[Any]			  =		self.get_dummy_inputs(__lowercase)
        __UpperCamelCase     :Tuple			  =		pipe(**__lowercase)
        __UpperCamelCase     :Tuple			  =		output.images

        __UpperCamelCase     :Union[str, Any]			  =		images[0, -3:, -3:, -1]

        assert images.shape == (1, 32, 32, 3)
        __UpperCamelCase     :int			  =		np.array([0.44_59, 0.49_43, 0.45_44, 0.66_43, 0.54_74, 0.43_27, 0.57_01, 0.59_59, 0.51_79])

        assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-2







    @unittest.skipIf(torch_device != '''cuda''' , '''This test requires a GPU''')
    def 			UpperCamelCase__   (	self)       ->	Optional[int]:
        __UpperCamelCase     :Any			  =		self.get_dummy_components()
        for name, module in components.items():
            if hasattr(__lowercase , '''half'''):
                __UpperCamelCase     :Any			  =		module.half()
        __UpperCamelCase     :int			  =		CycleDiffusionPipeline(**__lowercase)
        __UpperCamelCase     :Optional[int]			  =		pipe.to(__lowercase)
        pipe.set_progress_bar_config(disable=__lowercase)

        __UpperCamelCase     :Optional[Any]			  =		self.get_dummy_inputs(__lowercase)
        __UpperCamelCase     :str			  =		pipe(**__lowercase)
        __UpperCamelCase     :Any			  =		output.images

        __UpperCamelCase     :str			  =		images[0, -3:, -3:, -1]

        assert images.shape == (1, 32, 32, 3)
        __UpperCamelCase     :Optional[Any]			  =		np.array([0.35_06, 0.45_43, 0.4_46, 0.45_75, 0.51_95, 0.41_55, 0.52_73, 0.5_18, 0.41_16])

        assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-2







    @skip_mps
    def 			UpperCamelCase__   (	self)       ->	List[Any]:
        return super().test_save_load_local()







    @unittest.skip('''non-deterministic pipeline''')
    def 			UpperCamelCase__   (	self)       ->	Optional[int]:
        return super().test_inference_batch_single_identical()







    @skip_mps
    def 			UpperCamelCase__   (	self)       ->	Tuple:
        return super().test_dict_tuple_outputs_equivalent()







    @skip_mps
    def 			UpperCamelCase__   (	self)       ->	Any:
        return super().test_save_load_optional_components()







    @skip_mps
    def 			UpperCamelCase__   (	self)       ->	Tuple:
        return super().test_attention_slicing_forward_pass()


@slow
@require_torch_gpu
class 	lowerCamelCase_     (   unittest.TestCase ):






    '''simple docstring'''






    def 			UpperCamelCase__   (	self)       ->	Dict:
        # clean up the VRAM after each test
        super().tearDown()
        gc.collect()
        torch.cuda.empty_cache()







    def 			UpperCamelCase__   (	self)       ->	Dict:
        __UpperCamelCase     :int			  =		load_image(
            '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
            '''/cycle-diffusion/black_colored_car.png''')
        __UpperCamelCase     :str			  =		load_numpy(
            '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/cycle-diffusion/blue_colored_car_fp16.npy''')
        __UpperCamelCase     :int			  =		init_image.resize((512, 512))

        __UpperCamelCase     :List[Any]			  =		'''CompVis/stable-diffusion-v1-4'''
        __UpperCamelCase     :Optional[Any]			  =		DDIMScheduler.from_pretrained(__lowercase , subfolder='''scheduler''')
        __UpperCamelCase     :Optional[Any]			  =		CycleDiffusionPipeline.from_pretrained(
            __lowercase , scheduler=__lowercase , safety_checker=__lowercase , torch_dtype=torch.floataa , revision='''fp16''')

        pipe.to(__lowercase)
        pipe.set_progress_bar_config(disable=__lowercase)
        pipe.enable_attention_slicing()

        __UpperCamelCase     :Dict			  =		'''A black colored car'''
        __UpperCamelCase     :List[str]			  =		'''A blue colored car'''

        __UpperCamelCase     :Optional[int]			  =		torch.manual_seed(0)
        __UpperCamelCase     :Optional[int]			  =		pipe(
            prompt=__lowercase , source_prompt=__lowercase , image=__lowercase , num_inference_steps=100 , eta=0.1 , strength=0.85 , guidance_scale=3 , source_guidance_scale=1 , generator=__lowercase , output_type='''np''' , )
        __UpperCamelCase     :List[Any]			  =		output.images

        # the values aren't exactly equal, but the images look the same visually
        assert np.abs(image - expected_image).max() < 5E-1







    def 			UpperCamelCase__   (	self)       ->	int:
        __UpperCamelCase     :str			  =		load_image(
            '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
            '''/cycle-diffusion/black_colored_car.png''')
        __UpperCamelCase     :str			  =		load_numpy(
            '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/cycle-diffusion/blue_colored_car.npy''')
        __UpperCamelCase     :List[Any]			  =		init_image.resize((512, 512))

        __UpperCamelCase     :Optional[int]			  =		'''CompVis/stable-diffusion-v1-4'''
        __UpperCamelCase     :str			  =		DDIMScheduler.from_pretrained(__lowercase , subfolder='''scheduler''')
        __UpperCamelCase     :List[str]			  =		CycleDiffusionPipeline.from_pretrained(__lowercase , scheduler=__lowercase , safety_checker=__lowercase)

        pipe.to(__lowercase)
        pipe.set_progress_bar_config(disable=__lowercase)
        pipe.enable_attention_slicing()

        __UpperCamelCase     :Tuple			  =		'''A black colored car'''
        __UpperCamelCase     :str			  =		'''A blue colored car'''

        __UpperCamelCase     :Tuple			  =		torch.manual_seed(0)
        __UpperCamelCase     :int			  =		pipe(
            prompt=__lowercase , source_prompt=__lowercase , image=__lowercase , num_inference_steps=100 , eta=0.1 , strength=0.85 , guidance_scale=3 , source_guidance_scale=1 , generator=__lowercase , output_type='''np''' , )
        __UpperCamelCase     :Optional[Any]			  =		output.images

        assert np.abs(image - expected_image).max() < 2E-2








"""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 					_lowercase (			*UpperCAmelCase__							:			Tuple,					**UpperCAmelCase__							:			List[Any]	):
       pass







   def   _A  (  UpperCamelCase_     :       Union[str, Any])	->						Any:
      '''simple docstring'''


      return None


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




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







 """simple docstring"""







 __UpperCAmelCase	:					Tuple   		=	MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING


 @require_pytesseract
 @require_vision
 def 					_lowercase (			self							:			Optional[Any],					UpperCAmelCase__							:			Optional[Any],					UpperCAmelCase__							:			Dict,					UpperCAmelCase__							:			Optional[Any]	):
    __lowercase								=						pipeline(
        "document-question-answering",					model=UpperCAmelCase__,					tokenizer=UpperCAmelCase__,					image_processor=UpperCAmelCase__	)

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


 def 					_lowercase (			self							:			int,					UpperCAmelCase__							:			Tuple,					UpperCAmelCase__							:			Any	):
    __lowercase								=						dqa_pipeline(UpperCAmelCase__,					top_k=2	)
    self.assertEqual(
        UpperCAmelCase__,					[
            [
                {"score": ANY(UpperCAmelCase__	), "answer": ANY(UpperCAmelCase__	), "start": ANY(UpperCAmelCase__	), "end": ANY(UpperCAmelCase__	)},
                {"score": ANY(UpperCAmelCase__	), "answer": ANY(UpperCAmelCase__	), "start": ANY(UpperCAmelCase__	), "end": ANY(UpperCAmelCase__	)},
            ]
        ]
        * 3,					)


 @require_torch
 @require_detectrona
 @require_pytesseract
 def 					_lowercase (			self							:			Dict	):
    __lowercase								=						pipeline("document-question-answering",					model="hf-internal-testing/tiny-random-layoutlmv2"	)
    __lowercase								=						INVOICE_URL
    __lowercase								=						"How many cats are there?"

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

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

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


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

    __lowercase								=						dqa_pipeline(image=UpperCAmelCase__,					question=UpperCAmelCase__,					top_k=2	)
    self.assertEqual(
        nested_simplify(UpperCAmelCase__,					decimals=4	),					[
            {"score": 0.9_944, "answer": "us-001", "start": 1_6, "end": 1_6},
            {"score": 0.0_009, "answer": "us-001", "start": 1_6, "end": 1_6},
        ],					)

    __lowercase								=						dqa_pipeline({"image": image, "question": question},					top_k=2	)
    self.assertEqual(
        nested_simplify(UpperCAmelCase__,					decimals=4	),					[
            {"score": 0.9_944, "answer": "us-001", "start": 1_6, "end": 1_6},
            {"score": 0.0_009, "answer": "us-001", "start": 1_6, "end": 1_6},
        ],					)

    __lowercase								=						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": 1_6, "end": 1_6},
                {"score": 0.0_009, "answer": "us-001", "start": 1_6, "end": 1_6},
            ],
        ]
        * 2,					)


 @slow
 @require_torch
 @require_detectrona
 @require_pytesseract
 def 					_lowercase (			self							:			Dict	):
    __lowercase								=						pipeline(
        "document-question-answering",					model="tiennvcs/layoutlmv2-base-uncased-finetuned-docvqa",					revision="9977165",					max_seq_len=5_0,					)
    __lowercase								=						INVOICE_URL
    __lowercase								=						"What is the invoice number?"

    __lowercase								=						dqa_pipeline(image=UpperCAmelCase__,					question=UpperCAmelCase__,					top_k=2	)
    self.assertEqual(
        nested_simplify(UpperCAmelCase__,					decimals=4	),					[
            {"score": 0.9_974, "answer": "1110212019", "start": 2_3, "end": 2_3},
            {"score": 0.9_948, "answer": "us-001", "start": 1_6, "end": 1_6},
        ],					)

    __lowercase								=						dqa_pipeline({"image": image, "question": question},					top_k=2	)
    self.assertEqual(
        nested_simplify(UpperCAmelCase__,					decimals=4	),					[
            {"score": 0.9_974, "answer": "1110212019", "start": 2_3, "end": 2_3},
            {"score": 0.9_948, "answer": "us-001", "start": 1_6, "end": 1_6},
        ],					)

    __lowercase								=						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": 2_3, "end": 2_3},
                {"score": 0.9_948, "answer": "us-001", "start": 1_6, "end": 1_6},
            ]
        ]
        * 2,					)


 @slow
 @require_torch
 @require_pytesseract
 @require_vision
 def 					_lowercase (			self							:			Optional[Any]	):
    __lowercase								=						AutoTokenizer.from_pretrained(
        "impira/layoutlm-document-qa",					revision="3dc6de3",					add_prefix_space=UpperCAmelCase__	)
    __lowercase								=						pipeline(
        "document-question-answering",					model="impira/layoutlm-document-qa",					tokenizer=UpperCAmelCase__,					revision="3dc6de3",					)
    __lowercase								=						INVOICE_URL
    __lowercase								=						"What is the invoice number?"

    __lowercase								=						dqa_pipeline(image=UpperCAmelCase__,					question=UpperCAmelCase__,					top_k=2	)
    self.assertEqual(
        nested_simplify(UpperCAmelCase__,					decimals=4	),					[
            {"score": 0.4_251, "answer": "us-001", "start": 1_6, "end": 1_6},
            {"score": 0.0_819, "answer": "1110212019", "start": 2_3, "end": 2_3},
        ],					)

    __lowercase								=						dqa_pipeline({"image": image, "question": question},					top_k=2	)
    self.assertEqual(
        nested_simplify(UpperCAmelCase__,					decimals=4	),					[
            {"score": 0.4_251, "answer": "us-001", "start": 1_6, "end": 1_6},
            {"score": 0.0_819, "answer": "1110212019", "start": 2_3, "end": 2_3},
        ],					)

    __lowercase								=						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": 1_6, "end": 1_6},
                {"score": 0.0_819, "answer": "1110212019", "start": 2_3, "end": 2_3},
            ]
        ]
        * 2,					)

    __lowercase								=						list(zip(*apply_tesseract(load_image(UpperCAmelCase__	),					UpperCAmelCase__,					""	)	)	)

    # This model should also work if `image` is set to None
    __lowercase								=						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": 1_6, "end": 1_6},
            {"score": 0.0_819, "answer": "1110212019", "start": 2_3, "end": 2_3},
        ],					)


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

    __lowercase								=						dqa_pipeline(image=UpperCAmelCase__,					question=UpperCAmelCase__,					top_k=2	)
    self.assertEqual(
        nested_simplify(UpperCAmelCase__,					decimals=4	),					[
            {"score": 0.9_999, "answer": "us-001", "start": 1_6, "end": 1_6},
            {"score": 0.9_998, "answer": "us-001", "start": 1_6, "end": 1_6},
        ],					)

    __lowercase								=						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": 1_6, "end": 1_6},
                {"score": 0.9_998, "answer": "us-001", "start": 1_6, "end": 1_6},
            ]
        ]
        * 2,					)

    __lowercase								=						list(zip(*apply_tesseract(load_image(UpperCAmelCase__	),					UpperCAmelCase__,					""	)	)	)

    # This model should also work if `image` is set to None
    __lowercase								=						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": 1_6, "end": 1_6},
            {"score": 0.9_998, "answer": "us-001", "start": 1_6, "end": 1_6},
        ],					)


 @slow
 @require_torch
 def 					_lowercase (			self							:			Dict	):
    __lowercase								=						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								=						INVOICE_URL
    __lowercase								=						"What is the invoice number?"
    __lowercase								=						dqa_pipeline(image=UpperCAmelCase__,					question=UpperCAmelCase__,					top_k=2	)
    self.assertEqual(nested_simplify(UpperCAmelCase__,					decimals=4	),					[{"answer": "us-001"}]	)



 @require_tf
 @unittest.skip("Document question answering not implemented in TF"	)
 def 					_lowercase (			self							:			List[Any]	):
    pass




