

import datasets

from .evaluate import evaluate


UpperCAmelCase_							:					str		 =   '''\
@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_							:					List[Any]		 =   '''
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_							:					Tuple		 =   '''
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        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						:     Optional[Any]					,      __A						:     List[str]					,      __A						:     List[str]							):
		__A :			Any		    =			{prediction["""id"""]: prediction["""prediction_text"""] for prediction in predictions}
		__A :			Tuple		    =			[
		    {
		        """paragraphs""": [
		            {
		                """qas""": [
		                    {
		                        """answers""": [{"""text""": answer_text} for answer_text in ref["""answers"""]["""text"""]],
		                        """id""": ref["""id"""],
		                    }
		                    for ref in references
		                ]
		            }
		        ]
		    }
		]
		__A :			Optional[Any]		    =			evaluate(dataset=__A					,      predictions=__A							)
		return score








UpperCAmelCase_							:					dict[str, float]		 =   {
    "joule": 1.0,
    "kilojoule": 1_000,
    "megajoule": 1_000_000,
    "gigajoule": 1_000_000_000,
    "wattsecond": 1.0,
    "watthour": 3_600,
    "kilowatthour": 3_600_000,
    "newtonmeter": 1.0,
    "calorie_nutr": 4_186.8,
    "kilocalorie_nutr": 4_186_800.00,
    "electronvolt": 1.6_0217_6634e-19,
    "britishthermalunit_it": 1_055.05_585,
    "footpound": 1.35_5818,
}
def 							__SCREAMING_SNAKE_CASE     (   a__    :   str			,a__    :   str			,a__    :   float       )					->				float:
	if to_type not in ENERGY_CONVERSION or from_type not in ENERGY_CONVERSION:
		__A :			Optional[int]		    =			(
		    f"""Incorrect 'from_type' or 'to_type' value: {from_type!r}, {to_type!r}\n"""
		    f"""Valid values are: {", ".join(a__       )}"""
		)
		raise ValueError(a__       )
	return value * ENERGY_CONVERSION[from_type] / ENERGY_CONVERSION[to_type]


if __name__ == "__main__":
			import doctest

			doctest.testmod()





