


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  _a							:




			@staticmethod
			def 							UpperCAmelCase__( *_SCREAMING_SNAKE_CASE						:		Any		, **_SCREAMING_SNAKE_CASE						:		List[str]		)->	Union[str, Any]:
					pass






		def 					lowerCamelCase_   (	_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.
lowerCamelCase :    Union[str, Any]						=		(
    """https://huggingface.co/spaces/impira/docquery/resolve/2f6c96314dc84dfda62d40de9da55f2f5165d403/invoice.png"""
)





@is_pipeline_test
@require_torch
@require_vision
class  _a							(    unittest.TestCase):
	_a  :  int				   =							MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING




	@require_pytesseract
	@require_vision
	def 							UpperCAmelCase__( self						:		Dict		, _SCREAMING_SNAKE_CASE						:		Optional[int]		, _SCREAMING_SNAKE_CASE						:		List[str]		, _SCREAMING_SNAKE_CASE						:		Tuple		)->	int:
			lowerCAmelCase__       :      Union[str, Any]   					= pipeline(
			    '''document-question-answering'''		, model=a_		, tokenizer=a_		, image_processor=a_		)

			lowerCAmelCase__       :      Any   					= INVOICE_URL
			lowerCAmelCase__       :      List[str]   					= list(zip(*apply_tesseract(load_image(a_		)		, a_		, ''''''		)		)		)
			lowerCAmelCase__       :      Any   					= '''What is the placebo?'''
			lowerCAmelCase__       :      Any   					= [
			    {
			        '''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						:		int		, _SCREAMING_SNAKE_CASE						:		Dict		, _SCREAMING_SNAKE_CASE						:		int		)->	int:
			lowerCAmelCase__       :      Optional[Any]   					= 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						:		Dict		)->	int:
			lowerCAmelCase__       :      str   					= pipeline('''document-question-answering'''		, model='''hf-internal-testing/tiny-random-layoutlmv2'''		)
			lowerCAmelCase__       :      Union[str, Any]   					= INVOICE_URL
			lowerCAmelCase__       :      Tuple   					= '''How many cats are there?'''

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

			lowerCAmelCase__       :      int   					= 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
			lowerCAmelCase__       :      List[Any]   					= '''./tests/fixtures/tests_samples/COCO/000000039769.png'''
			lowerCAmelCase__       :      List[Any]   					= dqa_pipeline(image=a_		, question=a_		, top_k=2		)
			self.assertEqual(a_		, []		)

			# We can optionnally pass directly the words and bounding boxes
			lowerCAmelCase__       :      Dict   					= '''./tests/fixtures/tests_samples/COCO/000000039769.png'''
			lowerCAmelCase__       :      Union[str, Any]   					= []
			lowerCAmelCase__       :      int   					= []
			lowerCAmelCase__       :      List[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						:		Union[str, Any]		)->	Any:
			lowerCAmelCase__       :      List[Any]   					= pipeline(
			    '''document-question-answering'''		, model='''tiennvcs/layoutlmv2-base-uncased-finetuned-docvqa'''		, revision='''9977165'''		, )
			lowerCAmelCase__       :      str   					= INVOICE_URL
			lowerCAmelCase__       :      Any   					= '''What is the invoice number?'''

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

			lowerCAmelCase__       :      Union[str, 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},
			    ]		, )

			lowerCAmelCase__       :      Dict   					= 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						:		List[Any]		)->	Optional[int]:
			lowerCAmelCase__       :      Optional[int]   					= pipeline(
			    '''document-question-answering'''		, model='''tiennvcs/layoutlmv2-base-uncased-finetuned-docvqa'''		, revision='''9977165'''		, max_seq_len=50		, )
			lowerCAmelCase__       :      str   					= INVOICE_URL
			lowerCAmelCase__       :      List[str]   					= '''What is the invoice number?'''

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

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

			lowerCAmelCase__       :      Optional[int]   					= 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						:		Any		)->	Optional[int]:
			lowerCAmelCase__       :      Tuple   					= AutoTokenizer.from_pretrained(
			    '''impira/layoutlm-document-qa'''		, revision='''3dc6de3'''		, add_prefix_space=a_		)
			lowerCAmelCase__       :      int   					= pipeline(
			    '''document-question-answering'''		, model='''impira/layoutlm-document-qa'''		, tokenizer=a_		, revision='''3dc6de3'''		, )
			lowerCAmelCase__       :      int   					= INVOICE_URL
			lowerCAmelCase__       :      List[str]   					= '''What is the invoice number?'''

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

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

			lowerCAmelCase__       :      Tuple   					= 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		, )

			lowerCAmelCase__       :      Union[str, Any]   					= list(zip(*apply_tesseract(load_image(a_		)		, a_		, ''''''		)		)		)

			# This model should also work if `image` is set to None
			lowerCAmelCase__       :      Dict   					= 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						:		Any		)->	Optional[Any]:
			lowerCAmelCase__       :      int   					= AutoTokenizer.from_pretrained(
			    '''impira/layoutlm-document-qa'''		, revision='''3dc6de3'''		, add_prefix_space=a_		)
			lowerCAmelCase__       :      int   					= pipeline(
			    '''document-question-answering'''		, model='''impira/layoutlm-document-qa'''		, tokenizer=a_		, revision='''3dc6de3'''		, max_seq_len=50		, )
			lowerCAmelCase__       :      int   					= INVOICE_URL
			lowerCAmelCase__       :      Optional[int]   					= '''What is the invoice number?'''

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

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

			lowerCAmelCase__       :      Union[str, Any]   					= list(zip(*apply_tesseract(load_image(a_		)		, a_		, ''''''		)		)		)

			# This model should also work if `image` is set to None
			lowerCAmelCase__       :      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						:		Any		)->	Union[str, Any]:
			lowerCAmelCase__       :      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'''		, )

			lowerCAmelCase__       :      int   					= INVOICE_URL
			lowerCAmelCase__       :      Optional[Any]   					= '''What is the invoice number?'''
			lowerCAmelCase__       :      Optional[int]   					= 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[Any]		)->	Dict:
			pass








import math





class  _a							:




	def __init__( self						:		List[Any]		, _SCREAMING_SNAKE_CASE						:		Any=0		)->	Optional[Any]:  # a graph with Node 0,1,...,N-1
			lowerCAmelCase__       :      Optional[int]   					= n
			lowerCAmelCase__       :      List[Any]   					= [
			    [math.inf for j in range(0		, _SCREAMING_SNAKE_CASE		)] for i in range(0		, _SCREAMING_SNAKE_CASE		)
			]  # adjacency matrix for weight
			lowerCAmelCase__       :      str   					= [
			    [math.inf for j in range(0		, _SCREAMING_SNAKE_CASE		)] for i in range(0		, _SCREAMING_SNAKE_CASE		)
			]  # dp[i][j] stores minimum distance from i to j




	def 							UpperCAmelCase__( self						:		Optional[Any]		, _SCREAMING_SNAKE_CASE						:		Optional[int]		, _SCREAMING_SNAKE_CASE						:		List[str]		, _SCREAMING_SNAKE_CASE						:		str		)->	List[str]:
			lowerCAmelCase__       :      Optional[int]   					= w




	def 							UpperCAmelCase__( self						:		List[Any]		)->	Optional[int]:
			for k in range(0		, self.n		):
					for i in range(0		, self.n		):
							for j in range(0		, self.n		):
									lowerCAmelCase__       :      Dict   					= min(self.dp[i][j]		, self.dp[i][k] + self.dp[k][j]		)




	def 							UpperCAmelCase__( self						:		str		, _SCREAMING_SNAKE_CASE						:		Any		, _SCREAMING_SNAKE_CASE						:		str		)->	str:
			return self.dp[u][v]


if __name__ == "__main__":
		lowerCamelCase						=		Graph(5)
		graph.add_edge(0, 2, 9)
		graph.add_edge(0, 4, 10)
		graph.add_edge(1, 3, 5)
		graph.add_edge(2, 3, 7)
		graph.add_edge(3, 0, 10)
		graph.add_edge(3, 1, 2)
		graph.add_edge(3, 2, 1)
		graph.add_edge(3, 4, 6)
		graph.add_edge(4, 1, 3)
		graph.add_edge(4, 2, 4)
		graph.add_edge(4, 3, 9)
		graph.floyd_warshall()
		graph.show_min(1, 4)
		graph.show_min(0, 3)




