


import datasets

from .evaluate import evaluate


__lowerCAmelCase		       =							'''\
@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}
}
'''

__lowerCAmelCase		       =							'''
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.
'''

__lowerCAmelCase		       =							'''
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   __a			(    datasets.Metric      ):
 def 		SCREAMING_SNAKE_CASE__   (   self )					->				Optional[Any]:




        '''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 		SCREAMING_SNAKE_CASE__   (   self				, lowerCAmelCase__				, lowerCAmelCase__ )					->				Optional[Any]:




        '''simple docstring'''
        lowercase__:   List[str]  			=   {prediction['id']: prediction['prediction_text'] for prediction in predictions}
        lowercase__:   List[str]  			=   [
            {
                'paragraphs': [
                    {
                        'qas': [
                            {
                                'answers': [{'text': answer_text} for answer_text in ref['answers']['text']],
                                'id': ref['id'],
                            }
                            for ref in references
                        ]
                    }
                ]
            }
        ]
        lowercase__:   List[str]  			=   evaluate(dataset=lowerCAmelCase__				, predictions=lowerCAmelCase__ )
        return score




_lowerCamelCase       :				int       =			[4, 1, 7, 4, 2, 6, 4, 1, 5, 3, 7, 5]
_lowerCamelCase       :				str       =			[3, 7, 7, 4, 2, 6, 4, 1, 5, 3, 7, 5]
_lowerCamelCase       :				List[str]       =			{
    0: '''Sunday''',
    1: '''Monday''',
    2: '''Tuesday''',
    3: '''Wednesday''',
    4: '''Thursday''',
    5: '''Friday''',
    6: '''Saturday''',
}






def        a_		(       __lowercase   :	int       ,					__lowercase   :	int       ,					__lowercase   :	int ) ->  str:
			assert len(str(__lowercase ) ) > 2, "year should be in YYYY format"
			assert 1 <= month <= 12, "month should be between 1 to 12"
			assert 1 <= day <= 31, "day should be between 1 to 31"

			# Doomsday algorithm:
			_snake_case		=			year // 100
			_snake_case		=			(5 * (century % 4) + 2) % 7
			_snake_case		=			year % 100
			_snake_case		=			centurian % 12
			_snake_case		=			(
			    (centurian // 12) + centurian_m + (centurian_m // 4) + century_anchor
			) % 7
			_snake_case		=			(
			    DOOMSDAY_NOT_LEAP[month - 1]
			    if (year % 4 != 0) or (centurian == 0 and (year % 400) == 0)
			    else DOOMSDAY_LEAP[month - 1]
			)
			_snake_case		=			(dooms_day + day - day_anchor) % 7
			return WEEK_DAY_NAMES[week_day]


if __name__ == "__main__":
			import doctest

			doctest.testmod()