



"""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 		_a			(   *a     ,							**a ):




														"""simple docstring"""





														pass



				def   A   (      _A				):




									"""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.
__UpperCAmelCase   :   int        =       (
    'https://huggingface.co/spaces/impira/docquery/resolve/2f6c96314dc84dfda62d40de9da55f2f5165d403/invoice.png'
)

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


					'''simple docstring'''


					a__          =  MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING







					@require_pytesseract
					@require_vision
					def 		_a			(   self     ,							a     ,							a     ,							a ):




										"""simple docstring"""





										snake_case_    :int										=    pipeline(
										    "document-question-answering"     ,							model=__lowercase     ,							tokenizer=__lowercase     ,							image_processor=__lowercase )

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







					def 		_a			(   self     ,							a     ,							a ):




										"""simple docstring"""





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







					@require_torch
					@require_detectrona
					@require_pytesseract
					def 		_a			(   self ):




										"""simple docstring"""





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

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

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

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

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







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




										"""simple docstring"""





										snake_case_    :Optional[int]										=    pipeline(
										    "document-question-answering"     ,							model="tiennvcs/layoutlmv2-base-uncased-finetuned-docvqa"     ,							revision="9977165"     ,							)
										snake_case_    :Union[str, Any]										=    INVOICE_URL
										snake_case_    :Union[str, Any]										=    '''What is the invoice number?'''

										snake_case_    :Optional[Any]										=    dqa_pipeline(image=__lowercase     ,							question=__lowercase     ,							top_k=2 )
										self.assertEqual(
										    nested_simplify(__lowercase     ,							decimals=4 )     ,							[
										        {"score": 0.9944, "answer": "us-001", "start": 16, "end": 16},
										        {"score": 0.0009, "answer": "us-001", "start": 16, "end": 16},
										    ]     ,							)

										snake_case_    :Union[str, Any]										=    dqa_pipeline({"image": image, "question": question}     ,							top_k=2 )
										self.assertEqual(
										    nested_simplify(__lowercase     ,							decimals=4 )     ,							[
										        {"score": 0.9944, "answer": "us-001", "start": 16, "end": 16},
										        {"score": 0.0009, "answer": "us-001", "start": 16, "end": 16},
										    ]     ,							)

										snake_case_    :int										=    dqa_pipeline(
										    [{"image": image, "question": question}, {"image": image, "question": question}]     ,							top_k=2 )
										self.assertEqual(
										    nested_simplify(__lowercase     ,							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 		_a			(   self ):




										"""simple docstring"""





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

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

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

										snake_case_    :List[str]										=    dqa_pipeline(
										    [{"image": image, "question": question}, {"image": image, "question": question}]     ,							top_k=2 )
										self.assertEqual(
										    nested_simplify(__lowercase     ,							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 		_a			(   self ):




										"""simple docstring"""





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

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

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

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

										snake_case_    :Any										=    list(zip(*apply_tesseract(load_image(__lowercase )     ,							__lowercase     ,							"" ) ) )

										# This model should also work if `image` is set to None
										snake_case_    :Optional[Any]										=    dqa_pipeline({"image": None, "word_boxes": word_boxes, "question": question}     ,							top_k=2 )
										self.assertEqual(
										    nested_simplify(__lowercase     ,							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 		_a			(   self ):




										"""simple docstring"""





										snake_case_    :Any										=    AutoTokenizer.from_pretrained(
										    "impira/layoutlm-document-qa"     ,							revision="3dc6de3"     ,							add_prefix_space=__lowercase )
										snake_case_    :Any										=    pipeline(
										    "document-question-answering"     ,							model="impira/layoutlm-document-qa"     ,							tokenizer=__lowercase     ,							revision="3dc6de3"     ,							max_seq_len=50     ,							)
										snake_case_    :Any										=    INVOICE_URL
										snake_case_    :Optional[int]										=    '''What is the invoice number?'''

										snake_case_    :Dict										=    dqa_pipeline(image=__lowercase     ,							question=__lowercase     ,							top_k=2 )
										self.assertEqual(
										    nested_simplify(__lowercase     ,							decimals=4 )     ,							[
										        {"score": 0.9999, "answer": "us-001", "start": 16, "end": 16},
										        {"score": 0.9998, "answer": "us-001", "start": 16, "end": 16},
										    ]     ,							)

										snake_case_    :Dict										=    dqa_pipeline(
										    [{"image": image, "question": question}, {"image": image, "question": question}]     ,							top_k=2 )
										self.assertEqual(
										    nested_simplify(__lowercase     ,							decimals=4 )     ,							[
										        [
										            {"score": 0.9999, "answer": "us-001", "start": 16, "end": 16},
										            {"score": 0.9998, "answer": "us-001", "start": 16, "end": 16},
										        ]
										    ]
										    * 2     ,							)

										snake_case_    :Dict										=    list(zip(*apply_tesseract(load_image(__lowercase )     ,							__lowercase     ,							"" ) ) )

										# This model should also work if `image` is set to None
										snake_case_    :List[Any]										=    dqa_pipeline({"image": None, "word_boxes": word_boxes, "question": question}     ,							top_k=2 )
										self.assertEqual(
										    nested_simplify(__lowercase     ,							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 		_a			(   self ):




										"""simple docstring"""





										snake_case_    :Union[str, Any]										=    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"     ,							)

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







					@require_tf
					@unittest.skip("Document question answering not implemented in TF" )
					def 		_a			(   self ):




										"""simple docstring"""





										pass








"""simple docstring"""





from __future__ import annotations



def 					lowerCAmelCase_      (   SCREAMING_SNAKE_CASE							:				list[int | str] ):


							'''simple docstring'''







							create_state_space_tree(SCREAMING_SNAKE_CASE     ,    []     ,    0     ,    [0 for i in range(len(SCREAMING_SNAKE_CASE ) )] )



def 					lowerCAmelCase_      (   SCREAMING_SNAKE_CASE							:				list[int | str]     ,    SCREAMING_SNAKE_CASE							:				list[int | str]     ,    SCREAMING_SNAKE_CASE							:				int     ,    SCREAMING_SNAKE_CASE							:				list[int]     ,    ):


							'''simple docstring'''







							if index == len(SCREAMING_SNAKE_CASE ):
														print(SCREAMING_SNAKE_CASE )
														return

							for i in range(len(SCREAMING_SNAKE_CASE ) ):
														if not index_used[i]:
																					current_sequence.append(sequence[i] )
																					__lowerCamelCase   :   List[Any]       =True
																					create_state_space_tree(SCREAMING_SNAKE_CASE     ,    SCREAMING_SNAKE_CASE     ,    index + 1     ,    SCREAMING_SNAKE_CASE )
																					current_sequence.pop()
																					__lowerCamelCase   :   List[Any]       =False
_UpperCamelCase					      =   [3, 1, 2, 4]
generate_all_permutations(sequence)

_UpperCamelCase					      =   ["A", "B", "C"]
generate_all_permutations(sequence_a)




