


import os
from datetime import datetime as dt

from github import Github


__lowerCAmelCase	: List[str]  				=[
    'good first issue',
    'feature request',
    'wip',
]


def        _UpperCamelCase							(      ):
						__SCREAMING_SNAKE_CASE						:     Any					=		Github(os.environ['''GITHUB_TOKEN''']      )
						__SCREAMING_SNAKE_CASE						:     Any					=		g.get_repo('''huggingface/accelerate'''      )
						__SCREAMING_SNAKE_CASE						:     int					=		repo.get_issues(state='''open'''      )

						for issue in open_issues:
												__SCREAMING_SNAKE_CASE						:     Optional[Any]					=		sorted([comment for comment in issue.get_comments()]    ,       key=lambda lowercase__      : i.created_at    ,       reverse=lowercase__      )
												__SCREAMING_SNAKE_CASE						:     Dict					=		comments[0] if len(lowercase__      ) > 0 else None
												__SCREAMING_SNAKE_CASE						:     Tuple					=		dt.utcnow()
												__SCREAMING_SNAKE_CASE						:     Tuple					=		(current_time - issue.updated_at).days
												__SCREAMING_SNAKE_CASE						:     str					=		(current_time - issue.created_at).days
												if (
												    last_comment is not None
												    and last_comment.user.login == "github-actions[bot]"
												    and days_since_updated > 7
												    and days_since_creation >= 30
												    and not any(label.name.lower() in LABELS_TO_EXEMPT for label in issue.get_labels()      )
												):
																		# Close issue since it has been 7 days of inactivity since bot mention.
																		issue.edit(state='''closed'''      )
												elif (
												    days_since_updated > 23
												    and days_since_creation >= 30
												    and not any(label.name.lower() in LABELS_TO_EXEMPT for label in issue.get_labels()      )
												):
																		# Add stale comment
																		issue.create_comment(
																		    '''This issue has been automatically marked as stale because it has not had '''
																		    '''recent activity. If you think this still needs to be addressed '''
																		    '''please comment on this thread.\n\nPlease note that issues that do not follow the '''
																		    '''[contributing guidelines](https://github.com/huggingface/accelerate/blob/main/CONTRIBUTING.md) '''
																		    '''are likely to be ignored.'''      )


if __name__ == "__main__":
						main()




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






										'''simple docstring'''



										@staticmethod
										def 		__magic_name__(       *lowerCAmelCase__			:Union[str, Any]			,			**lowerCAmelCase__			:str	)		->			Union[str, Any]:
																pass




						def        _UpperCamelCase							(      lowercase__      ):
												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	: str  				=(
    'https://huggingface.co/spaces/impira/docquery/resolve/2f6c96314dc84dfda62d40de9da55f2f5165d403/invoice.png'
)
@is_pipeline_test
@require_torch
@require_vision
class        _lowercase      (			unittest.TestCase       ):






				'''simple docstring'''



				SCREAMING_SNAKE_CASE__				:			Tuple						=		MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING


				@require_pytesseract
				@require_vision
				def 		__magic_name__(       self			:Any			,			lowerCAmelCase__			:List[str]			,			lowerCAmelCase__			:Optional[Any]			,			lowerCAmelCase__			:Any	)		->			Any:
										__SCREAMING_SNAKE_CASE						:     Optional[int]					=		pipeline(
										    '''document-question-answering'''			,			model=lowerCAmelCase__			,			tokenizer=lowerCAmelCase__			,			image_processor=lowerCAmelCase__	)

										__SCREAMING_SNAKE_CASE						:     Dict					=		INVOICE_URL
										__SCREAMING_SNAKE_CASE						:     Optional[Any]					=		list(zip(*apply_tesseract(load_image(lowerCAmelCase__	)			,			lowerCAmelCase__			,			''''''	)	)	)
										__SCREAMING_SNAKE_CASE						:     str					=		'''What is the placebo?'''
										__SCREAMING_SNAKE_CASE						:     str					=		[
										    {
										        '''image''': load_image(lowerCAmelCase__	),
										        '''question''': question,
										    },
										    {
										        '''image''': image,
										        '''question''': question,
										    },
										    {
										        '''image''': image,
										        '''question''': question,
										        '''word_boxes''': word_boxes,
										    },
										]
										return dqa_pipeline, examples


				def 		__magic_name__(       self			:Optional[Any]			,			lowerCAmelCase__			:Tuple			,			lowerCAmelCase__			:Tuple	)		->			str:
										__SCREAMING_SNAKE_CASE						:     Any					=		dqa_pipeline(lowerCAmelCase__			,			top_k=2	)
										self.assertEqual(
										    lowerCAmelCase__			,			[
										        [
										            {'''score''': ANY(lowerCAmelCase__	), '''answer''': ANY(lowerCAmelCase__	), '''start''': ANY(lowerCAmelCase__	), '''end''': ANY(lowerCAmelCase__	)},
										            {'''score''': ANY(lowerCAmelCase__	), '''answer''': ANY(lowerCAmelCase__	), '''start''': ANY(lowerCAmelCase__	), '''end''': ANY(lowerCAmelCase__	)},
										        ]
										    ]
										    * 3			,			)


				@require_torch
				@require_detectrona
				@require_pytesseract
				def 		__magic_name__(       self			:Dict	)		->			List[str]:
										__SCREAMING_SNAKE_CASE						:     Tuple					=		pipeline('''document-question-answering'''			,			model='''hf-internal-testing/tiny-random-layoutlmv2'''	)
										__SCREAMING_SNAKE_CASE						:     Dict					=		INVOICE_URL
										__SCREAMING_SNAKE_CASE						:     int					=		'''How many cats are there?'''

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

										__SCREAMING_SNAKE_CASE						:     Dict					=		dqa_pipeline({'''image''': image, '''question''': question}			,			top_k=2	)
										self.assertEqual(nested_simplify(lowerCAmelCase__			,			decimals=4	)			,			lowerCAmelCase__	)

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

										# We can optionnally pass directly the words and bounding boxes
										__SCREAMING_SNAKE_CASE						:     Union[str, Any]					=		'''./tests/fixtures/tests_samples/COCO/000000039769.png'''
										__SCREAMING_SNAKE_CASE						:     Union[str, Any]					=		[]
										__SCREAMING_SNAKE_CASE						:     Union[str, Any]					=		[]
										__SCREAMING_SNAKE_CASE						:     Union[str, Any]					=		dqa_pipeline(image=lowerCAmelCase__			,			question=lowerCAmelCase__			,			words=lowerCAmelCase__			,			boxes=lowerCAmelCase__			,			top_k=2	)
										self.assertEqual(lowerCAmelCase__			,			[]	)


				@slow
				@require_torch
				@require_detectrona
				@require_pytesseract
				def 		__magic_name__(       self			:int	)		->			Optional[Any]:
										__SCREAMING_SNAKE_CASE						:     List[Any]					=		pipeline(
										    '''document-question-answering'''			,			model='''tiennvcs/layoutlmv2-base-uncased-finetuned-docvqa'''			,			revision='''9977165'''			,			)
										__SCREAMING_SNAKE_CASE						:     Dict					=		INVOICE_URL
										__SCREAMING_SNAKE_CASE						:     Any					=		'''What is the invoice number?'''

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

										__SCREAMING_SNAKE_CASE						:     Tuple					=		dqa_pipeline({'''image''': image, '''question''': question}			,			top_k=2	)
										self.assertEqual(
										    nested_simplify(lowerCAmelCase__			,			decimals=4	)			,			[
										        {'''score''': 0.9944, '''answer''': '''us-001''', '''start''': 16, '''end''': 16},
										        {'''score''': 0.0009, '''answer''': '''us-001''', '''start''': 16, '''end''': 16},
										    ]			,			)

										__SCREAMING_SNAKE_CASE						:     List[Any]					=		dqa_pipeline(
										    [{'''image''': image, '''question''': question}, {'''image''': image, '''question''': question}]			,			top_k=2	)
										self.assertEqual(
										    nested_simplify(lowerCAmelCase__			,			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 		__magic_name__(       self			:Optional[Any]	)		->			Any:
										__SCREAMING_SNAKE_CASE						:     int					=		pipeline(
										    '''document-question-answering'''			,			model='''tiennvcs/layoutlmv2-base-uncased-finetuned-docvqa'''			,			revision='''9977165'''			,			max_seq_len=50			,			)
										__SCREAMING_SNAKE_CASE						:     Union[str, Any]					=		INVOICE_URL
										__SCREAMING_SNAKE_CASE						:     Tuple					=		'''What is the invoice number?'''

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

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

										__SCREAMING_SNAKE_CASE						:     str					=		dqa_pipeline(
										    [{'''image''': image, '''question''': question}, {'''image''': image, '''question''': question}]			,			top_k=2	)
										self.assertEqual(
										    nested_simplify(lowerCAmelCase__			,			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 		__magic_name__(       self			:int	)		->			List[Any]:
										__SCREAMING_SNAKE_CASE						:     List[Any]					=		AutoTokenizer.from_pretrained(
										    '''impira/layoutlm-document-qa'''			,			revision='''3dc6de3'''			,			add_prefix_space=lowerCAmelCase__	)
										__SCREAMING_SNAKE_CASE						:     Dict					=		pipeline(
										    '''document-question-answering'''			,			model='''impira/layoutlm-document-qa'''			,			tokenizer=lowerCAmelCase__			,			revision='''3dc6de3'''			,			)
										__SCREAMING_SNAKE_CASE						:     Union[str, Any]					=		INVOICE_URL
										__SCREAMING_SNAKE_CASE						:     str					=		'''What is the invoice number?'''

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

										__SCREAMING_SNAKE_CASE						:     Union[str, Any]					=		dqa_pipeline({'''image''': image, '''question''': question}			,			top_k=2	)
										self.assertEqual(
										    nested_simplify(lowerCAmelCase__			,			decimals=4	)			,			[
										        {'''score''': 0.4251, '''answer''': '''us-001''', '''start''': 16, '''end''': 16},
										        {'''score''': 0.0819, '''answer''': '''1110212019''', '''start''': 23, '''end''': 23},
										    ]			,			)

										__SCREAMING_SNAKE_CASE						:     Union[str, Any]					=		dqa_pipeline(
										    [{'''image''': image, '''question''': question}, {'''image''': image, '''question''': question}]			,			top_k=2	)
										self.assertEqual(
										    nested_simplify(lowerCAmelCase__			,			decimals=4	)			,			[
										        [
										            {'''score''': 0.4251, '''answer''': '''us-001''', '''start''': 16, '''end''': 16},
										            {'''score''': 0.0819, '''answer''': '''1110212019''', '''start''': 23, '''end''': 23},
										        ]
										    ]
										    * 2			,			)

										__SCREAMING_SNAKE_CASE						:     Optional[int]					=		list(zip(*apply_tesseract(load_image(lowerCAmelCase__	)			,			lowerCAmelCase__			,			''''''	)	)	)

										# This model should also work if `image` is set to None
										__SCREAMING_SNAKE_CASE						:     str					=		dqa_pipeline({'''image''': None, '''word_boxes''': word_boxes, '''question''': question}			,			top_k=2	)
										self.assertEqual(
										    nested_simplify(lowerCAmelCase__			,			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 		__magic_name__(       self			:str	)		->			Dict:
										__SCREAMING_SNAKE_CASE						:     Optional[int]					=		AutoTokenizer.from_pretrained(
										    '''impira/layoutlm-document-qa'''			,			revision='''3dc6de3'''			,			add_prefix_space=lowerCAmelCase__	)
										__SCREAMING_SNAKE_CASE						:     Tuple					=		pipeline(
										    '''document-question-answering'''			,			model='''impira/layoutlm-document-qa'''			,			tokenizer=lowerCAmelCase__			,			revision='''3dc6de3'''			,			max_seq_len=50			,			)
										__SCREAMING_SNAKE_CASE						:     List[str]					=		INVOICE_URL
										__SCREAMING_SNAKE_CASE						:     Dict					=		'''What is the invoice number?'''

										__SCREAMING_SNAKE_CASE						:     List[Any]					=		dqa_pipeline(image=lowerCAmelCase__			,			question=lowerCAmelCase__			,			top_k=2	)
										self.assertEqual(
										    nested_simplify(lowerCAmelCase__			,			decimals=4	)			,			[
										        {'''score''': 0.9999, '''answer''': '''us-001''', '''start''': 16, '''end''': 16},
										        {'''score''': 0.9998, '''answer''': '''us-001''', '''start''': 16, '''end''': 16},
										    ]			,			)

										__SCREAMING_SNAKE_CASE						:     Optional[int]					=		dqa_pipeline(
										    [{'''image''': image, '''question''': question}, {'''image''': image, '''question''': question}]			,			top_k=2	)
										self.assertEqual(
										    nested_simplify(lowerCAmelCase__			,			decimals=4	)			,			[
										        [
										            {'''score''': 0.9999, '''answer''': '''us-001''', '''start''': 16, '''end''': 16},
										            {'''score''': 0.9998, '''answer''': '''us-001''', '''start''': 16, '''end''': 16},
										        ]
										    ]
										    * 2			,			)

										__SCREAMING_SNAKE_CASE						:     List[str]					=		list(zip(*apply_tesseract(load_image(lowerCAmelCase__	)			,			lowerCAmelCase__			,			''''''	)	)	)

										# This model should also work if `image` is set to None
										__SCREAMING_SNAKE_CASE						:     List[Any]					=		dqa_pipeline({'''image''': None, '''word_boxes''': word_boxes, '''question''': question}			,			top_k=2	)
										self.assertEqual(
										    nested_simplify(lowerCAmelCase__			,			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 		__magic_name__(       self			:Union[str, Any]	)		->			Tuple:
										__SCREAMING_SNAKE_CASE						:     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'''			,			)

										__SCREAMING_SNAKE_CASE						:     Union[str, Any]					=		INVOICE_URL
										__SCREAMING_SNAKE_CASE						:     Optional[int]					=		'''What is the invoice number?'''
										__SCREAMING_SNAKE_CASE						:     Tuple					=		dqa_pipeline(image=lowerCAmelCase__			,			question=lowerCAmelCase__			,			top_k=2	)
										self.assertEqual(nested_simplify(lowerCAmelCase__			,			decimals=4	)			,			[{'''answer''': '''us-001'''}]	)



				@require_tf
				@unittest.skip('''Document question answering not implemented in TF'''	)
				def 		__magic_name__(       self			:Union[str, Any]	)		->			Tuple:
										pass
