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






												@staticmethod
												def      _snake_case   (       *__SCREAMING_SNAKE_CASE    ,							**__SCREAMING_SNAKE_CASE		):


																		"""simple docstring"""





																		pass







							def  snake_case_		(    __SCREAMING_SNAKE_CASE :			Union[str, 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.
_lowercase			:  Optional[int]   							=	(
    "https://huggingface.co/spaces/impira/docquery/resolve/2f6c96314dc84dfda62d40de9da55f2f5165d403/invoice.png"
)






@is_pipeline_test
@require_torch
@require_vision
class 			lowerCAmelCase__       (  unittest.TestCase					):
					lowerCAmelCase_					       =					MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING






					@require_pytesseract
					@require_vision
					def      _snake_case   (       self    ,							__SCREAMING_SNAKE_CASE    ,							__SCREAMING_SNAKE_CASE    ,							__SCREAMING_SNAKE_CASE		):


											"""simple docstring"""





											lowercase_     :					List[str]													=	pipeline(
											    '''document-question-answering'''    ,							model=__SCREAMING_SNAKE_CASE    ,							tokenizer=__SCREAMING_SNAKE_CASE    ,							image_processor=__SCREAMING_SNAKE_CASE		)

											lowercase_     :					Optional[int]													=	INVOICE_URL
											lowercase_     :					Optional[int]													=	list(zip(*apply_tesseract(load_image(__SCREAMING_SNAKE_CASE		)    ,							__SCREAMING_SNAKE_CASE    ,							''''''		)		)		)
											lowercase_     :					Tuple													=	'''What is the placebo?'''
											lowercase_     :					Dict													=	[
											    {
											        '''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      _snake_case   (       self    ,							__SCREAMING_SNAKE_CASE    ,							__SCREAMING_SNAKE_CASE		):


											"""simple docstring"""





											lowercase_     :					Any													=	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      _snake_case   (       self		):


											"""simple docstring"""





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

											lowercase_     :					Dict													=	[
											    {'''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},
											]
											lowercase_     :					Dict													=	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		)

											lowercase_     :					Union[str, Any]													=	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
											lowercase_     :					List[str]													=	'''./tests/fixtures/tests_samples/COCO/000000039769.png'''
											lowercase_     :					Dict													=	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
											lowercase_     :					Optional[int]													=	'''./tests/fixtures/tests_samples/COCO/000000039769.png'''
											lowercase_     :					Union[str, Any]													=	[]
											lowercase_     :					List[Any]													=	[]
											lowercase_     :					Optional[int]													=	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      _snake_case   (       self		):


											"""simple docstring"""





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

											lowercase_     :					Optional[Any]													=	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},
											    ]    ,							)

											lowercase_     :					str													=	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},
											    ]    ,							)

											lowercase_     :					Union[str, Any]													=	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      _snake_case   (       self		):


											"""simple docstring"""





											lowercase_     :					Dict													=	pipeline(
											    '''document-question-answering'''    ,							model='''tiennvcs/layoutlmv2-base-uncased-finetuned-docvqa'''    ,							revision='''9977165'''    ,							max_seq_len=50    ,							)
											lowercase_     :					Tuple													=	INVOICE_URL
											lowercase_     :					str													=	'''What is the invoice number?'''

											lowercase_     :					int													=	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},
											    ]    ,							)

											lowercase_     :					List[Any]													=	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},
											    ]    ,							)

											lowercase_     :					Union[str, Any]													=	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      _snake_case   (       self		):


											"""simple docstring"""





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

											lowercase_     :					int													=	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},
											    ]    ,							)

											lowercase_     :					str													=	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},
											    ]    ,							)

											lowercase_     :					str													=	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    ,							)

											lowercase_     :					Optional[Any]													=	list(zip(*apply_tesseract(load_image(__SCREAMING_SNAKE_CASE		)    ,							__SCREAMING_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(__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      _snake_case   (       self		):


											"""simple docstring"""





											lowercase_     :					List[str]													=	AutoTokenizer.from_pretrained(
											    '''impira/layoutlm-document-qa'''    ,							revision='''3dc6de3'''    ,							add_prefix_space=__SCREAMING_SNAKE_CASE		)
											lowercase_     :					Any													=	pipeline(
											    '''document-question-answering'''    ,							model='''impira/layoutlm-document-qa'''    ,							tokenizer=__SCREAMING_SNAKE_CASE    ,							revision='''3dc6de3'''    ,							max_seq_len=50    ,							)
											lowercase_     :					Tuple													=	INVOICE_URL
											lowercase_     :					str													=	'''What is the invoice number?'''

											lowercase_     :					Tuple													=	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},
											    ]    ,							)

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

											lowercase_     :					Tuple													=	list(zip(*apply_tesseract(load_image(__SCREAMING_SNAKE_CASE		)    ,							__SCREAMING_SNAKE_CASE    ,							''''''		)		)		)

											# This model should also work if `image` is set to None
											lowercase_     :					List[str]													=	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      _snake_case   (       self		):


											"""simple docstring"""





											lowercase_     :					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'''    ,							)

											lowercase_     :					Tuple													=	INVOICE_URL
											lowercase_     :					Any													=	'''What is the invoice number?'''
											lowercase_     :					List[str]													=	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      _snake_case   (       self		):


											"""simple docstring"""





											pass





'''simple docstring'''







def  snake_case_		(    __SCREAMING_SNAKE_CASE :			int				,				__SCREAMING_SNAKE_CASE :			float				,				__SCREAMING_SNAKE_CASE :			float							):



						"""simple docstring"""





						return round(float(moles / volume							) * nfactor							)
def  snake_case_		(    __SCREAMING_SNAKE_CASE :			float				,				__SCREAMING_SNAKE_CASE :			float				,				__SCREAMING_SNAKE_CASE :			float							):



						"""simple docstring"""





						return round(float((moles * 0.0821 * temperature) / (volume)							)							)
def  snake_case_		(    __SCREAMING_SNAKE_CASE :			float				,				__SCREAMING_SNAKE_CASE :			float				,				__SCREAMING_SNAKE_CASE :			float							):



						"""simple docstring"""





						return round(float((moles * 0.0821 * temperature) / (pressure)							)							)
def  snake_case_		(    __SCREAMING_SNAKE_CASE :			float				,				__SCREAMING_SNAKE_CASE :			float				,				__SCREAMING_SNAKE_CASE :			float							):



						"""simple docstring"""





						return round(float((pressure * volume) / (0.0821 * moles)							)							)


if __name__ == "__main__":
							import doctest

							doctest.testmod()



