

'''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  UpperCAmelCase :

						'''simple docstring'''






						@staticmethod
						def 			UpperCamelCase(					*SCREAMING_SNAKE_CASE_   ,			**SCREAMING_SNAKE_CASE_		)  ->     List[Any]:






											'''simple docstring'''



											pass







				def   _UpperCamelCase	(		__UpperCamelCase	)       ->			List[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.
A_	= (
    "https://huggingface.co/spaces/impira/docquery/resolve/2f6c96314dc84dfda62d40de9da55f2f5165d403/invoice.png"
)


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

		'''simple docstring'''






		SCREAMING_SNAKE_CASE_           =					MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING
		@require_pytesseract
		@require_vision
		def 			UpperCamelCase(					self   ,			SCREAMING_SNAKE_CASE_   ,			SCREAMING_SNAKE_CASE_   ,			SCREAMING_SNAKE_CASE_		)  ->     Optional[Any]:






							'''simple docstring'''



							lowerCamelCase_  				=      pipeline(
							    'document-question-answering'   ,			model=SCREAMING_SNAKE_CASE_   ,			tokenizer=SCREAMING_SNAKE_CASE_   ,			image_processor=SCREAMING_SNAKE_CASE_		)

							lowerCamelCase_  				=      INVOICE_URL
							lowerCamelCase_  				=      list(zip(*apply_tesseract(load_image(SCREAMING_SNAKE_CASE_		)   ,			SCREAMING_SNAKE_CASE_   ,			''		)		)		)
							lowerCamelCase_  				=      'What is the placebo?'
							lowerCamelCase_  				=      [
							    {
							        'image': load_image(SCREAMING_SNAKE_CASE_		),
							        'question': question,
							    },
							    {
							        'image': image,
							        'question': question,
							    },
							    {
							        'image': image,
							        'question': question,
							        'word_boxes': word_boxes,
							    },
							]
							return dqa_pipeline, examples
		def 			UpperCamelCase(					self   ,			SCREAMING_SNAKE_CASE_   ,			SCREAMING_SNAKE_CASE_		)  ->     Dict:






							'''simple docstring'''



							lowerCamelCase_  				=      dqa_pipeline(SCREAMING_SNAKE_CASE_   ,			top_k=2		)
							self.assertEqual(
							    SCREAMING_SNAKE_CASE_   ,			[
							        [
							            {'score': ANY(SCREAMING_SNAKE_CASE_		), 'answer': ANY(SCREAMING_SNAKE_CASE_		), 'start': ANY(SCREAMING_SNAKE_CASE_		), 'end': ANY(SCREAMING_SNAKE_CASE_		)},
							            {'score': ANY(SCREAMING_SNAKE_CASE_		), 'answer': ANY(SCREAMING_SNAKE_CASE_		), 'start': ANY(SCREAMING_SNAKE_CASE_		), 'end': ANY(SCREAMING_SNAKE_CASE_		)},
							        ]
							    ]
							    * 3   ,			)
		@require_torch
		@require_detectrona
		@require_pytesseract
		def 			UpperCamelCase(					self		)  ->     Optional[Any]:






							'''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=SCREAMING_SNAKE_CASE_   ,			question=SCREAMING_SNAKE_CASE_   ,			top_k=2		)
							self.assertEqual(nested_simplify(SCREAMING_SNAKE_CASE_   ,			decimals=4		)   ,			SCREAMING_SNAKE_CASE_		)

							lowerCamelCase_  				=      dqa_pipeline({'image': image, 'question': question}   ,			top_k=2		)
							self.assertEqual(nested_simplify(SCREAMING_SNAKE_CASE_   ,			decimals=4		)   ,			SCREAMING_SNAKE_CASE_		)

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

							# We can optionnally pass directly the words and bounding boxes
							lowerCamelCase_  				=      './tests/fixtures/tests_samples/COCO/000000039769.png'
							lowerCamelCase_  				=      []
							lowerCamelCase_  				=      []
							lowerCamelCase_  				=      dqa_pipeline(image=SCREAMING_SNAKE_CASE_   ,			question=SCREAMING_SNAKE_CASE_   ,			words=SCREAMING_SNAKE_CASE_   ,			boxes=SCREAMING_SNAKE_CASE_   ,			top_k=2		)
							self.assertEqual(SCREAMING_SNAKE_CASE_   ,			[]		)
		@slow
		@require_torch
		@require_detectrona
		@require_pytesseract
		def 			UpperCamelCase(					self		)  ->     Any:






							'''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=SCREAMING_SNAKE_CASE_   ,			question=SCREAMING_SNAKE_CASE_   ,			top_k=2		)
							self.assertEqual(
							    nested_simplify(SCREAMING_SNAKE_CASE_   ,			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(SCREAMING_SNAKE_CASE_   ,			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(SCREAMING_SNAKE_CASE_   ,			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 			UpperCamelCase(					self		)  ->     Optional[int]:






							'''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=SCREAMING_SNAKE_CASE_   ,			question=SCREAMING_SNAKE_CASE_   ,			top_k=2		)
							self.assertEqual(
							    nested_simplify(SCREAMING_SNAKE_CASE_   ,			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(SCREAMING_SNAKE_CASE_   ,			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(SCREAMING_SNAKE_CASE_   ,			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 			UpperCamelCase(					self		)  ->     str:






							'''simple docstring'''



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

							lowerCamelCase_  				=      dqa_pipeline(image=SCREAMING_SNAKE_CASE_   ,			question=SCREAMING_SNAKE_CASE_   ,			top_k=2		)
							self.assertEqual(
							    nested_simplify(SCREAMING_SNAKE_CASE_   ,			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(SCREAMING_SNAKE_CASE_   ,			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(SCREAMING_SNAKE_CASE_   ,			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(SCREAMING_SNAKE_CASE_		)   ,			SCREAMING_SNAKE_CASE_   ,			''		)		)		)

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






							'''simple docstring'''



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

							lowerCamelCase_  				=      dqa_pipeline(image=SCREAMING_SNAKE_CASE_   ,			question=SCREAMING_SNAKE_CASE_   ,			top_k=2		)
							self.assertEqual(
							    nested_simplify(SCREAMING_SNAKE_CASE_   ,			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(SCREAMING_SNAKE_CASE_   ,			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(SCREAMING_SNAKE_CASE_		)   ,			SCREAMING_SNAKE_CASE_   ,			''		)		)		)

							# 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(SCREAMING_SNAKE_CASE_   ,			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 			UpperCamelCase(					self		)  ->     List[str]:






							'''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=SCREAMING_SNAKE_CASE_   ,			question=SCREAMING_SNAKE_CASE_   ,			top_k=2		)
							self.assertEqual(nested_simplify(SCREAMING_SNAKE_CASE_   ,			decimals=4		)   ,			[{'answer': 'us-001'}]		)






		@require_tf
		@unittest.skip('Document question answering not implemented in TF'		)
		def 			UpperCamelCase(					self		)  ->     List[Any]:






							'''simple docstring'''



							pass







"""simple docstring"""


import json
import os
import shutil
import tempfile
import unittest

import numpy as np
import pytest

from transformers import BertTokenizer, BertTokenizerFast
from transformers.models.bert.tokenization_bert import VOCAB_FILES_NAMES
from transformers.testing_utils import require_vision
from transformers.utils import IMAGE_PROCESSOR_NAME, is_vision_available


if is_vision_available():
   from PIL import Image

   from transformers import AlignProcessor, EfficientNetImageProcessor

@require_vision
class 				_SCREAMING_SNAKE_CASE				(							unittest.TestCase  ):
   """simple docstring"""



   def 					UpperCAmelCase__(						self						)      ->							Tuple:
    lowercase__       :       str				=						tempfile.mkdtemp()

    lowercase__       :       List[Any]				=						[
        """[UNK]""",
        """[CLS]""",
        """[SEP]""",
        """[PAD]""",
        """[MASK]""",
        """want""",
        """##want""",
        """##ed""",
        """wa""",
        """un""",
        """runn""",
        """##ing""",
        """,""",
        """low""",
        """lowest""",
    ]
    lowercase__       :       str				=						os.path.join(self.tmpdirname ,     VOCAB_FILES_NAMES["""vocab_file"""]						)
    with open(self.vocab_file ,     """w""" ,     encoding="""utf-8"""						) as vocab_writer:
     vocab_writer.write("""""".join([x + """\n""" for x in vocab_tokens]						)						)

    lowercase__       :       Optional[Any]				=						{
        """do_resize""": True,
        """size""": 20,
        """do_center_crop""": True,
        """crop_size""": 18,
        """do_normalize""": True,
        """image_mean""": [0.4814_5466, 0.457_8275, 0.4082_1073],
        """image_std""": [0.2686_2954, 0.2613_0258, 0.2757_7711],
    }
    lowercase__       :       Any				=						os.path.join(self.tmpdirname ,     lowerCamelCase__						)
    with open(self.image_processor_file ,     """w""" ,     encoding="""utf-8"""						) as fp:
     json.dump(lowerCamelCase__ ,     lowerCamelCase__						)


   def 					UpperCAmelCase__(						self ,     **lowerCamelCase__						)      ->							str:
    return BertTokenizer.from_pretrained(self.tmpdirname ,     **lowerCamelCase__						)


   def 					UpperCAmelCase__(						self ,     **lowerCamelCase__						)      ->							str:
    return BertTokenizerFast.from_pretrained(self.tmpdirname ,     **lowerCamelCase__						)


   def 					UpperCAmelCase__(						self ,     **lowerCamelCase__						)      ->							List[Any]:
    return EfficientNetImageProcessor.from_pretrained(self.tmpdirname ,     **lowerCamelCase__						)


   def 					UpperCAmelCase__(						self						)      ->							Any:
    shutil.rmtree(self.tmpdirname						)


   def 					UpperCAmelCase__(						self						)      ->							Optional[int]:
    lowercase__       :       Tuple				=						[np.random.randint(255 ,     size=(3, 30, 400) ,     dtype=np.uinta						)]
    lowercase__       :       Any				=						[Image.fromarray(np.moveaxis(lowerCamelCase__ ,     0 ,     -1						)						) for x in image_inputs]
    return image_inputs


   def 					UpperCAmelCase__(						self						)      ->							int:
    lowercase__       :       Union[str, Any]				=						self.get_tokenizer()
    lowercase__       :       Union[str, Any]				=						self.get_rust_tokenizer()
    lowercase__       :       Any				=						self.get_image_processor()

    lowercase__       :       Union[str, Any]				=						AlignProcessor(tokenizer=lowerCamelCase__ ,     image_processor=lowerCamelCase__						)
    processor_slow.save_pretrained(self.tmpdirname						)
    lowercase__       :       Tuple				=						AlignProcessor.from_pretrained(self.tmpdirname ,     use_fast=lowerCamelCase__						)

    lowercase__       :       List[Any]				=						AlignProcessor(tokenizer=lowerCamelCase__ ,     image_processor=lowerCamelCase__						)
    processor_fast.save_pretrained(self.tmpdirname						)
    lowercase__       :       str				=						AlignProcessor.from_pretrained(self.tmpdirname						)

    self.assertEqual(processor_slow.tokenizer.get_vocab() ,     tokenizer_slow.get_vocab()						)
    self.assertEqual(processor_fast.tokenizer.get_vocab() ,     tokenizer_fast.get_vocab()						)
    self.assertEqual(tokenizer_slow.get_vocab() ,     tokenizer_fast.get_vocab()						)
    self.assertIsInstance(processor_slow.tokenizer ,     lowerCamelCase__						)
    self.assertIsInstance(processor_fast.tokenizer ,     lowerCamelCase__						)

    self.assertEqual(processor_slow.image_processor.to_json_string() ,     image_processor.to_json_string()						)
    self.assertEqual(processor_fast.image_processor.to_json_string() ,     image_processor.to_json_string()						)
    self.assertIsInstance(processor_slow.image_processor ,     lowerCamelCase__						)
    self.assertIsInstance(processor_fast.image_processor ,     lowerCamelCase__						)


   def 					UpperCAmelCase__(						self						)      ->							int:
    lowercase__       :       Optional[int]				=						AlignProcessor(tokenizer=self.get_tokenizer() ,     image_processor=self.get_image_processor()						)
    processor.save_pretrained(self.tmpdirname						)

    lowercase__       :       Dict				=						self.get_tokenizer(bos_token="""(BOS)""" ,     eos_token="""(EOS)"""						)
    lowercase__       :       Any				=						self.get_image_processor(do_normalize=lowerCamelCase__ ,     padding_value=1.0						)

    lowercase__       :       Union[str, Any]				=						AlignProcessor.from_pretrained(
        self.tmpdirname ,     bos_token="""(BOS)""" ,     eos_token="""(EOS)""" ,     do_normalize=lowerCamelCase__ ,     padding_value=1.0						)

    self.assertEqual(processor.tokenizer.get_vocab() ,     tokenizer_add_kwargs.get_vocab()						)
    self.assertIsInstance(processor.tokenizer ,     lowerCamelCase__						)

    self.assertEqual(processor.image_processor.to_json_string() ,     image_processor_add_kwargs.to_json_string()						)
    self.assertIsInstance(processor.image_processor ,     lowerCamelCase__						)


   def 					UpperCAmelCase__(						self						)      ->							Tuple:
    lowercase__       :       Optional[int]				=						self.get_image_processor()
    lowercase__       :       Dict				=						self.get_tokenizer()

    lowercase__       :       Tuple				=						AlignProcessor(tokenizer=lowerCamelCase__ ,     image_processor=lowerCamelCase__						)

    lowercase__       :       Optional[int]				=						self.prepare_image_inputs()

    lowercase__       :       Tuple				=						image_processor(lowerCamelCase__ ,     return_tensors="""np"""						)
    lowercase__       :       str				=						processor(images=lowerCamelCase__ ,     return_tensors="""np"""						)

    for key in input_image_proc.keys():
     self.assertAlmostEqual(input_image_proc[key].sum() ,     input_processor[key].sum() ,     delta=1E-2						)


   def 					UpperCAmelCase__(						self						)      ->							List[str]:
    lowercase__       :       Union[str, Any]				=						self.get_image_processor()
    lowercase__       :       Tuple				=						self.get_tokenizer()

    lowercase__       :       List[str]				=						AlignProcessor(tokenizer=lowerCamelCase__ ,     image_processor=lowerCamelCase__						)

    lowercase__       :       Any				=						"""lower newer"""

    lowercase__       :       List[Any]				=						processor(text=lowerCamelCase__						)

    lowercase__       :       Tuple				=						tokenizer(lowerCamelCase__ ,     padding="""max_length""" ,     max_length=64						)

    for key in encoded_tok.keys():
     self.assertListEqual(encoded_tok[key] ,     encoded_processor[key]						)


   def 					UpperCAmelCase__(						self						)      ->							str:
    lowercase__       :       List[Any]				=						self.get_image_processor()
    lowercase__       :       Any				=						self.get_tokenizer()

    lowercase__       :       Union[str, Any]				=						AlignProcessor(tokenizer=lowerCamelCase__ ,     image_processor=lowerCamelCase__						)

    lowercase__       :       List[Any]				=						"""lower newer"""
    lowercase__       :       List[str]				=						self.prepare_image_inputs()

    lowercase__       :       List[Any]				=						processor(text=lowerCamelCase__ ,     images=lowerCamelCase__						)

    self.assertListEqual(list(inputs.keys()						) ,     ["""input_ids""", """token_type_ids""", """attention_mask""", """pixel_values"""]						)

    # test if it raises when no input is passed
    with pytest.raises(lowerCamelCase__						):
     processor()


   def 					UpperCAmelCase__(						self						)      ->							Union[str, Any]:
    lowercase__       :       int				=						self.get_image_processor()
    lowercase__       :       Union[str, Any]				=						self.get_tokenizer()

    lowercase__       :       Tuple				=						AlignProcessor(tokenizer=lowerCamelCase__ ,     image_processor=lowerCamelCase__						)

    lowercase__       :       Union[str, Any]				=						[[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

    lowercase__       :       Tuple				=						processor.batch_decode(lowerCamelCase__						)
    lowercase__       :       Optional[Any]				=						tokenizer.batch_decode(lowerCamelCase__						)

    self.assertListEqual(lowerCamelCase__ ,     lowerCamelCase__						)







   def 					UpperCAmelCase__(						self						)      ->							List[Any]:
    lowercase__       :       List[str]				=						self.get_image_processor()
    lowercase__       :       Optional[Any]				=						self.get_tokenizer()

    lowercase__       :       Optional[int]				=						AlignProcessor(tokenizer=lowerCamelCase__ ,     image_processor=lowerCamelCase__						)

    lowercase__       :       str				=						"""lower newer"""
    lowercase__       :       List[Any]				=						self.prepare_image_inputs()

    lowercase__       :       int				=						processor(text=lowerCamelCase__ ,     images=lowerCamelCase__						)

    self.assertListEqual(list(inputs.keys()						) ,     processor.model_input_names						)