




'''simple docstring'''



import datasets

from .evaluate import evaluate


UpperCamelCase_    	=				"\\n@inproceedings{Rajpurkar2016SQuAD10,\n  title={SQuAD: 100, 000+ Questions for Machine Comprehension of Text},\n  author={Pranav Rajpurkar and Jian Zhang and Konstantin Lopyrev and Percy Liang},\n  booktitle={EMNLP},\n  year={2016}\n}\n"

UpperCamelCase_    	=				"\nThis metric wrap the official scoring script for version 1 of the Stanford Question Answering Dataset (SQuAD).\n\nStanford Question Answering Dataset (SQuAD) is a reading comprehension dataset, consisting of questions posed by\ncrowdworkers on a set of Wikipedia articles, where the answer to every question is a segment of text, or span,\nfrom the corresponding reading passage, or the question might be unanswerable.\n"

UpperCamelCase_    	=				"\nComputes SQuAD scores (F1 and EM).\nArgs:\n    predictions: List of question-answers dictionaries with the following key-values:\n        - 'id': id of the question-answer pair as given in the references (see below)\n        - 'prediction_text': the text of the answer\n    references: List of question-answers dictionaries with the following key-values:\n        - 'id': id of the question-answer pair (see above),\n        - 'answers': a Dict in the SQuAD dataset format\n            {\n                'text': list of possible texts for the answer, as a list of strings\n                'answer_start': list of start positions for the answer, as a list of ints\n            }\n            Note that answer_start values are not taken into account to compute the metric.\nReturns:\n    'exact_match': Exact match (the normalized answer exactly match the gold answer)\n    'f1': The F-score of predicted tokens versus the gold answer\nExamples:\n\n    >>> predictions = [{'prediction_text': '1976', 'id': '56e10a3be3433e1400422b22'}]\n    >>> references = [{'answers': {'answer_start': [97], 'text': ['1976']}, 'id': '56e10a3be3433e1400422b22'}]\n    >>> squad_metric = datasets.load_metric(\"squad\")\n    >>> results = squad_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {'exact_match': 100.0, 'f1': 100.0}\n"






@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION ,      _KWARGS_DESCRIPTION )
class 							_a				(			datasets.Metric ):





       '''simple docstring'''






       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             return datasets.MetricInfo(
                 description=_DESCRIPTION,							citation=_CITATION,							inputs_description=_KWARGS_DESCRIPTION,							features=datasets.Features(
                     {
                         'predictions': {'id': datasets.Value('string'  ), 'prediction_text': datasets.Value('string'  )},
                         'references': {
                             'id': datasets.Value('string'  ),
                             'answers': datasets.features.Sequence(
                                 {
                                     'text': datasets.Value('string'  ),
                                     'answer_start': datasets.Value('int32'  ),
                                 }  ),
                         },
                     }  ),							codebase_urls=['https://rajpurkar.github.io/SQuAD-explorer/'],							reference_urls=['https://rajpurkar.github.io/SQuAD-explorer/'],							)







       def        UpperCamelCase_							(      self,							A,							A  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      int    					=						{prediction['id']: prediction['prediction_text'] for prediction in predictions}
             SCREAMING_SNAKE_CASE   :      Any    					=						[
                 {
                     'paragraphs': [
                         {
                             'qas': [
                                 {
                                     'answers': [{'text': answer_text} for answer_text in ref['answers']['text']],
                                     'id': ref['id'],
                                 }
                                 for ref in references
                             ]
                         }
                     ]
                 }
             ]
             SCREAMING_SNAKE_CASE   :      str    					=						evaluate(dataset=A,							predictions=A  )
             return score







'''simple docstring'''



import unittest

import numpy as np

from transformers.testing_utils import is_flaky, require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
							import torch

if is_vision_available():
							from PIL import Image

							from transformers import DonutImageProcessor
class 						lowerCamelCase_				(       unittest.TestCase      ):







						def __init__(	self :   Dict					,     lowerCAmelCase__ :   Union[str, Any]					,     lowerCAmelCase__ :   Dict=7					,     lowerCAmelCase__ :   List[str]=3					,     lowerCAmelCase__ :   Union[str, Any]=18					,     lowerCAmelCase__ :   Tuple=30					,     lowerCAmelCase__ :   Any=4_00					,     lowerCAmelCase__ :   Optional[int]=True					,     lowerCAmelCase__ :   List[Any]=None					,     lowerCAmelCase__ :   int=True					,     lowerCAmelCase__ :   Optional[Any]=False					,     lowerCAmelCase__ :   Any=True					,     lowerCAmelCase__ :   Optional[Any]=True					,     lowerCAmelCase__ :   Union[str, Any]=[0.5, 0.5, 0.5]					,     lowerCAmelCase__ :   List[str]=[0.5, 0.5, 0.5]					,     ):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE       :   Union[str, Any]         =      parent
													SCREAMING_SNAKE_CASE       :   int         =      batch_size
													SCREAMING_SNAKE_CASE       :   Union[str, Any]         =      num_channels
													SCREAMING_SNAKE_CASE       :   Union[str, Any]         =      image_size
													SCREAMING_SNAKE_CASE       :   Any         =      min_resolution
													SCREAMING_SNAKE_CASE       :   int         =      max_resolution
													SCREAMING_SNAKE_CASE       :   Tuple         =      do_resize
													SCREAMING_SNAKE_CASE       :   Optional[int]         =      size if size is not None else {'''height''': 18, '''width''': 20}
													SCREAMING_SNAKE_CASE       :   List[Any]         =      do_thumbnail
													SCREAMING_SNAKE_CASE       :   Union[str, Any]         =      do_align_axis
													SCREAMING_SNAKE_CASE       :   Tuple         =      do_pad
													SCREAMING_SNAKE_CASE       :   Union[str, Any]         =      do_normalize
													SCREAMING_SNAKE_CASE       :   Union[str, Any]         =      image_mean
													SCREAMING_SNAKE_CASE       :   Optional[int]         =      image_std







						def        __lowercase     (	self :   Union[str, Any]					):

													"""simple docstring"""
													return {
													    "do_resize": self.do_resize,
													    "size": self.size,
													    "do_thumbnail": self.do_thumbnail,
													    "do_align_long_axis": self.do_align_axis,
													    "do_pad": self.do_pad,
													    "do_normalize": self.do_normalize,
													    "image_mean": self.image_mean,
													    "image_std": self.image_std,
													}


@require_torch
@require_vision
class 						lowerCamelCase_				(       snake_case_     ,					unittest.TestCase      ):
						_lowerCAmelCase  : Any						  =					DonutImageProcessor if is_vision_available() else None







						def        __lowercase     (	self :   str					):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE       :   Tuple         =      DonutImageProcessingTester(self					)







						@property
						def        __lowercase     (	self :   int					):

													"""simple docstring"""
													return self.image_processor_tester.prepare_image_processor_dict()







						def        __lowercase     (	self :   Union[str, Any]					):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE       :   str         =      self.image_processing_class(**self.image_processor_dict					)
													self.assertTrue(hasattr(lowerCAmelCase__					,     '''do_resize'''					)					)
													self.assertTrue(hasattr(lowerCAmelCase__					,     '''size'''					)					)
													self.assertTrue(hasattr(lowerCAmelCase__					,     '''do_thumbnail'''					)					)
													self.assertTrue(hasattr(lowerCAmelCase__					,     '''do_align_long_axis'''					)					)
													self.assertTrue(hasattr(lowerCAmelCase__					,     '''do_pad'''					)					)
													self.assertTrue(hasattr(lowerCAmelCase__					,     '''do_normalize'''					)					)
													self.assertTrue(hasattr(lowerCAmelCase__					,     '''image_mean'''					)					)
													self.assertTrue(hasattr(lowerCAmelCase__					,     '''image_std'''					)					)







						def        __lowercase     (	self :   Any					):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE       :   Optional[int]         =      self.image_processing_class.from_dict(self.image_processor_dict					)
													self.assertEqual(image_processor.size					,     {'''height''': 18, '''width''': 20}					)

													SCREAMING_SNAKE_CASE       :   List[str]         =      self.image_processing_class.from_dict(self.image_processor_dict					,     size=42					)
													self.assertEqual(image_processor.size					,     {'''height''': 42, '''width''': 42}					)

													# Previous config had dimensions in (width, height) order
													SCREAMING_SNAKE_CASE       :   Dict         =      self.image_processing_class.from_dict(self.image_processor_dict					,     size=(42, 84)					)
													self.assertEqual(image_processor.size					,     {'''height''': 84, '''width''': 42}					)







						def        __lowercase     (	self :   int					):

													"""simple docstring"""
													pass







						@is_flaky()
						def        __lowercase     (	self :   int					):

													"""simple docstring"""
													# Initialize image_processing
													SCREAMING_SNAKE_CASE       :   Optional[int]         =      self.image_processing_class(**self.image_processor_dict					)
													# create random PIL images
													SCREAMING_SNAKE_CASE       :   List[str]         =      prepare_image_inputs(self.image_processor_tester					,     equal_resolution=lowerCAmelCase__					)
													for image in image_inputs:
																				self.assertIsInstance(lowerCAmelCase__					,     Image.Image					)

													# Test not batched input
													SCREAMING_SNAKE_CASE       :   Any         =      image_processing(image_inputs[0]					,     return_tensors='''pt'''					).pixel_values
													self.assertEqual(
													    encoded_images.shape					,     (
													        1,
													        self.image_processor_tester.num_channels,
													        self.image_processor_tester.size['''height'''],
													        self.image_processor_tester.size['''width'''],
													    )					,     )

													# Test batched
													SCREAMING_SNAKE_CASE       :   Optional[Any]         =      image_processing(lowerCAmelCase__					,     return_tensors='''pt'''					).pixel_values
													self.assertEqual(
													    encoded_images.shape					,     (
													        self.image_processor_tester.batch_size,
													        self.image_processor_tester.num_channels,
													        self.image_processor_tester.size['''height'''],
													        self.image_processor_tester.size['''width'''],
													    )					,     )







						@is_flaky()
						def        __lowercase     (	self :   Union[str, Any]					):

													"""simple docstring"""
													# Initialize image_processing
													SCREAMING_SNAKE_CASE       :   Optional[Any]         =      self.image_processing_class(**self.image_processor_dict					)
													# create random numpy tensors
													SCREAMING_SNAKE_CASE       :   Tuple         =      prepare_image_inputs(self.image_processor_tester					,     equal_resolution=lowerCAmelCase__					,     numpify=lowerCAmelCase__					)
													for image in image_inputs:
																				self.assertIsInstance(lowerCAmelCase__					,     np.ndarray					)

													# Test not batched input
													SCREAMING_SNAKE_CASE       :   int         =      image_processing(image_inputs[0]					,     return_tensors='''pt'''					).pixel_values
													self.assertEqual(
													    encoded_images.shape					,     (
													        1,
													        self.image_processor_tester.num_channels,
													        self.image_processor_tester.size['''height'''],
													        self.image_processor_tester.size['''width'''],
													    )					,     )

													# Test batched
													SCREAMING_SNAKE_CASE       :   int         =      image_processing(lowerCAmelCase__					,     return_tensors='''pt'''					).pixel_values
													self.assertEqual(
													    encoded_images.shape					,     (
													        self.image_processor_tester.batch_size,
													        self.image_processor_tester.num_channels,
													        self.image_processor_tester.size['''height'''],
													        self.image_processor_tester.size['''width'''],
													    )					,     )







						@is_flaky()
						def        __lowercase     (	self :   List[Any]					):

													"""simple docstring"""
													# Initialize image_processing
													SCREAMING_SNAKE_CASE       :   Optional[Any]         =      self.image_processing_class(**self.image_processor_dict					)
													# create random PyTorch tensors
													SCREAMING_SNAKE_CASE       :   Tuple         =      prepare_image_inputs(self.image_processor_tester					,     equal_resolution=lowerCAmelCase__					,     torchify=lowerCAmelCase__					)
													for image in image_inputs:
																				self.assertIsInstance(lowerCAmelCase__					,     torch.Tensor					)

													# Test not batched input
													SCREAMING_SNAKE_CASE       :   str         =      image_processing(image_inputs[0]					,     return_tensors='''pt'''					).pixel_values
													self.assertEqual(
													    encoded_images.shape					,     (
													        1,
													        self.image_processor_tester.num_channels,
													        self.image_processor_tester.size['''height'''],
													        self.image_processor_tester.size['''width'''],
													    )					,     )

													# Test batched
													SCREAMING_SNAKE_CASE       :   List[str]         =      image_processing(lowerCAmelCase__					,     return_tensors='''pt'''					).pixel_values
													self.assertEqual(
													    encoded_images.shape					,     (
													        self.image_processor_tester.batch_size,
													        self.image_processor_tester.num_channels,
													        self.image_processor_tester.size['''height'''],
													        self.image_processor_tester.size['''width'''],
													    )					,     )




