






'''simple docstring'''







import datasets

from .evaluate import evaluate


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

_A	:			int         ='''
This metric wrap the official scoring script for version 1 of the Stanford Question Answering Dataset (SQuAD).

Stanford Question Answering Dataset (SQuAD) is a reading comprehension dataset, consisting of questions posed by
crowdworkers on a set of Wikipedia articles, where the answer to every question is a segment of text, or span,
from the corresponding reading passage, or the question might be unanswerable.
'''

_A	:			Dict         ='''
Computes SQuAD scores (F1 and EM).
Args:
    predictions: List of question-answers dictionaries with the following key-values:
        - \'id\': id of the question-answer pair as given in the references (see below)
        - \'prediction_text\': the text of the answer
    references: List of question-answers dictionaries with the following key-values:
        - \'id\': id of the question-answer pair (see above),
        - \'answers\': a Dict in the SQuAD dataset format
            {
                \'text\': list of possible texts for the answer, as a list of strings
                \'answer_start\': list of start positions for the answer, as a list of ints
            }
            Note that answer_start values are not taken into account to compute the metric.
Returns:
    \'exact_match\': Exact match (the normalized answer exactly match the gold answer)
    \'f1\': The F-score of predicted tokens versus the gold answer
Examples:

    >>> predictions = [{\'prediction_text\': \'1976\', \'id\': \'56e10a3be3433e1400422b22\'}]
    >>> references = [{\'answers\': {\'answer_start\': [97], \'text\': [\'1976\']}, \'id\': \'56e10a3be3433e1400422b22\'}]
    >>> squad_metric = datasets.load_metric("squad")
    >>> results = squad_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {\'exact_match\': 100.0, \'f1\': 100.0}
'''

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




							def 		lowerCamelCase_				(							self:				List[str]     ):
														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 		lowerCamelCase_				(							self:				Union[str, Any]			,							UpperCamelCase__:				List[Any]			,							UpperCamelCase__:				Tuple     ):
														lowerCamelCase__					:	List[str]         =       {prediction["""id"""]: prediction["""prediction_text"""] for prediction in predictions}
														lowerCamelCase__					:	Tuple         =       [
														    {
														        """paragraphs""": [
														            {
														                """qas""": [
														                    {
														                        """answers""": [{"""text""": answer_text} for answer_text in ref["""answers"""]["""text"""]],
														                        """id""": ref["""id"""],
														                    }
														                    for ref in references
														                ]
														            }
														        ]
														    }
														]
														lowerCamelCase__					:	Any         =       evaluate(dataset=UpperCamelCase__			,							predictions=UpperCamelCase__     )
														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 _lowercase	(				unittest.TestCase		):




							def __init__(							self:				str			,							UpperCamelCase__:				Optional[Any]			,							UpperCamelCase__:				Any=7			,							UpperCamelCase__:				Optional[int]=3			,							UpperCamelCase__:				List[str]=18			,							UpperCamelCase__:				Union[str, Any]=30			,							UpperCamelCase__:				List[str]=400			,							UpperCamelCase__:				Any=True			,							UpperCamelCase__:				Union[str, Any]=None			,							UpperCamelCase__:				List[Any]=True			,							UpperCamelCase__:				List[Any]=False			,							UpperCamelCase__:				Tuple=True			,							UpperCamelCase__:				Tuple=True			,							UpperCamelCase__:				Any=[0.5, 0.5, 0.5]			,							UpperCamelCase__:				Optional[Any]=[0.5, 0.5, 0.5]			,							):
														lowerCamelCase__					:	int         =       parent
														lowerCamelCase__					:	Any         =       batch_size
														lowerCamelCase__					:	Optional[int]         =       num_channels
														lowerCamelCase__					:	Union[str, Any]         =       image_size
														lowerCamelCase__					:	Optional[int]         =       min_resolution
														lowerCamelCase__					:	Optional[Any]         =       max_resolution
														lowerCamelCase__					:	Union[str, Any]         =       do_resize
														lowerCamelCase__					:	Optional[Any]         =       size if size is not None else {"""height""": 18, """width""": 20}
														lowerCamelCase__					:	Dict         =       do_thumbnail
														lowerCamelCase__					:	Optional[int]         =       do_align_axis
														lowerCamelCase__					:	Any         =       do_pad
														lowerCamelCase__					:	Optional[Any]         =       do_normalize
														lowerCamelCase__					:	Union[str, Any]         =       image_mean
														lowerCamelCase__					:	Union[str, Any]         =       image_std




							def 		lowerCamelCase_				(							self:				str     ):
														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 _lowercase	(				_lowercase				,      unittest.TestCase		):
							a				      =       DonutImageProcessor if is_vision_available() else None




							def 		lowerCamelCase_				(							self:				Optional[int]     ):
														lowerCamelCase__					:	Any         =       DonutImageProcessingTester(self     )




							@property
							def 		lowerCamelCase_				(							self:				Optional[int]     ):
														return self.image_processor_tester.prepare_image_processor_dict()




							def 		lowerCamelCase_				(							self:				Tuple     ):
														lowerCamelCase__					:	Dict         =       self.image_processing_class(**self.image_processor_dict     )
														self.assertTrue(hasattr(UpperCamelCase__			,							"""do_resize"""     )     )
														self.assertTrue(hasattr(UpperCamelCase__			,							"""size"""     )     )
														self.assertTrue(hasattr(UpperCamelCase__			,							"""do_thumbnail"""     )     )
														self.assertTrue(hasattr(UpperCamelCase__			,							"""do_align_long_axis"""     )     )
														self.assertTrue(hasattr(UpperCamelCase__			,							"""do_pad"""     )     )
														self.assertTrue(hasattr(UpperCamelCase__			,							"""do_normalize"""     )     )
														self.assertTrue(hasattr(UpperCamelCase__			,							"""image_mean"""     )     )
														self.assertTrue(hasattr(UpperCamelCase__			,							"""image_std"""     )     )




							def 		lowerCamelCase_				(							self:				Optional[Any]     ):
														lowerCamelCase__					:	Optional[int]         =       self.image_processing_class.from_dict(self.image_processor_dict     )
														self.assertEqual(image_processor.size			,							{"""height""": 18, """width""": 20}     )

														lowerCamelCase__					:	Optional[int]         =       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
														lowerCamelCase__					:	List[str]         =       self.image_processing_class.from_dict(self.image_processor_dict			,							size=(42, 84)     )
														self.assertEqual(image_processor.size			,							{"""height""": 84, """width""": 42}     )




							def 		lowerCamelCase_				(							self:				List[str]     ):
														pass




							@is_flaky()
							def 		lowerCamelCase_				(							self:				Union[str, Any]     ):
														# Initialize image_processing
														lowerCamelCase__					:	str         =       self.image_processing_class(**self.image_processor_dict     )
														# create random PIL images
														lowerCamelCase__					:	Dict         =       prepare_image_inputs(self.image_processor_tester			,							equal_resolution=UpperCamelCase__     )
														for image in image_inputs:
																					self.assertIsInstance(UpperCamelCase__			,							Image.Image     )

														# Test not batched input
														lowerCamelCase__					:	Union[str, 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
														lowerCamelCase__					:	List[str]         =       image_processing(UpperCamelCase__			,							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 		lowerCamelCase_				(							self:				Optional[int]     ):
														# Initialize image_processing
														lowerCamelCase__					:	Dict         =       self.image_processing_class(**self.image_processor_dict     )
														# create random numpy tensors
														lowerCamelCase__					:	Dict         =       prepare_image_inputs(self.image_processor_tester			,							equal_resolution=UpperCamelCase__			,							numpify=UpperCamelCase__     )
														for image in image_inputs:
																					self.assertIsInstance(UpperCamelCase__			,							np.ndarray     )

														# Test not batched input
														lowerCamelCase__					:	List[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
														lowerCamelCase__					:	Optional[Any]         =       image_processing(UpperCamelCase__			,							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 		lowerCamelCase_				(							self:				Dict     ):
														# Initialize image_processing
														lowerCamelCase__					:	int         =       self.image_processing_class(**self.image_processor_dict     )
														# create random PyTorch tensors
														lowerCamelCase__					:	Optional[int]         =       prepare_image_inputs(self.image_processor_tester			,							equal_resolution=UpperCamelCase__			,							torchify=UpperCamelCase__     )
														for image in image_inputs:
																					self.assertIsInstance(UpperCamelCase__			,							torch.Tensor     )

														# Test not batched input
														lowerCamelCase__					:	Union[str, 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
														lowerCamelCase__					:	Tuple         =       image_processing(UpperCamelCase__			,							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"""],
														    )			,							)

