
"""simple docstring"""



import datasets

from .evaluate import evaluate


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

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

UpperCAmelCase__          = '''
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       lowerCAmelCase__				(						datasets.Metric	):







     def      lowercase	(							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      lowercase	(							self			:			List[Any]    ,      _lowerCamelCase			:			Any    ,      _lowerCamelCase			:			str			):
       _snake_case					     =       {prediction["""id"""]: prediction["""prediction_text"""] for prediction in predictions}
       _snake_case					     =       [
           {
               """paragraphs""": [
                   {
                       """qas""": [
                           {
                               """answers""": [{"""text""": answer_text} for answer_text in ref["""answers"""]["""text"""]],
                               """id""": ref["""id"""],
                           }
                           for ref in references
                       ]
                   }
               ]
           }
       ]
       _snake_case					     =       evaluate(dataset=lowerCAmelCase__    ,      predictions=lowerCAmelCase__			)
       return score








'''simple docstring'''




UpperCamelCase__       :	Optional[Any]    = [
    (10_00, '''M'''),
    (9_00, '''CM'''),
    (5_00, '''D'''),
    (4_00, '''CD'''),
    (1_00, '''C'''),
    (90, '''XC'''),
    (50, '''L'''),
    (40, '''XL'''),
    (10, '''X'''),
    (9, '''IX'''),
    (5, '''V'''),
    (4, '''IV'''),
    (1, '''I'''),
]


def 				lowerCAmelCase_   (	_lowerCamelCase:   str					):
		__SCREAMING_SNAKE_CASE       :		List[Any]           =		{"""I""": 1, """V""": 5, """X""": 10, """L""": 50, """C""": 1_00, """D""": 5_00, """M""": 10_00}
		__SCREAMING_SNAKE_CASE       :		Tuple           =		0
		__SCREAMING_SNAKE_CASE       :		str           =		0
		while place < len(_lowerCamelCase					):
				if (place + 1 < len(_lowerCamelCase					)) and (vals[roman[place]] < vals[roman[place + 1]]):
						total += vals[roman[place + 1]] - vals[roman[place]]
						place += 2
				else:
						total += vals[roman[place]]
						place += 1
		return total


def 				lowerCAmelCase_   (	_lowerCamelCase:   int					):
		__SCREAMING_SNAKE_CASE       :		Any           =		[]
		for arabic, roman in ROMAN:
				((__SCREAMING_SNAKE_CASE)       ,						(__SCREAMING_SNAKE_CASE))       :		str           =		divmod(_lowerCamelCase       ,      _lowerCamelCase					)
				result.append(roman * factor					)
				if number == 0:
						break
		return "".join(_lowerCamelCase					)


if __name__ == "__main__":
						import doctest

						doctest.testmod()