




import datasets

from .evaluate import evaluate


snake_case__			:    List[Any]			     =      '''\\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'''

snake_case__			:    str			     =      '''\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'''

snake_case__			:    Dict			     =      '''\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      snake_case	(						datasets.Metric				):


   '''simple docstring'''







   def 						UpperCAmelCase							(       self  :						Optional[int]      )       ->Union[str, 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 						UpperCAmelCase							(       self  :						List[Any]    ,     lowerCamelCase_  :						Tuple    ,     lowerCamelCase_  :						List[str]      )       ->Tuple:
     '''simple docstring'''







     UpperCAmelCase__         = {prediction['id']: prediction['prediction_text'] for prediction in predictions}
     UpperCAmelCase__         = [
         {
             'paragraphs': [
                 {
                     'qas': [
                         {
                             'answers': [{'text': answer_text} for answer_text in ref['answers']['text']],
                             'id': ref['id'],
                         }
                         for ref in references
                     ]
                 }
             ]
         }
     ]
     UpperCAmelCase__         = evaluate(dataset=lowerCamelCase_    ,     predictions=lowerCamelCase_      )
     return score










'''simple docstring'''



import inspect
import warnings
from typing import Any, Dict, Optional, Union

from packaging import version




def   lowercase__(			*__UpperCamelCase:					Union[str, Any]      ,__UpperCamelCase:					Optional[Union[Dict, Any]] = None      ,__UpperCamelCase:					Dict=True      ,__UpperCamelCase:					List[Any]=2    ):

      """simple docstring"""






      from .. import __version__

      SCREAMING_SNAKE_CASE   :      int    					=						take_from
      SCREAMING_SNAKE_CASE   :      Optional[int]    					=						()
      if not isinstance(args[0]      ,__UpperCamelCase    ):
            SCREAMING_SNAKE_CASE   :      List[str]    					=						(args,)

      for attribute, version_name, message in args:
            if version.parse(version.parse(__UpperCamelCase    ).base_version    ) >= version.parse(__UpperCamelCase    ):
                  raise ValueError(
                      f"The deprecation tuple {(attribute, version_name, message)} should be removed since diffusers'"
                      f" version {__version__} is >= {version_name}"    )

            SCREAMING_SNAKE_CASE   :      Tuple    					=						None
            if isinstance(__UpperCamelCase      ,__UpperCamelCase    ) and attribute in deprecated_kwargs:
                  values += (deprecated_kwargs.pop(__UpperCamelCase    ),)
                  SCREAMING_SNAKE_CASE   :      Dict    					=						f"The `{attribute}` argument is deprecated and will be removed in version {version_name}."
            elif hasattr(__UpperCamelCase      ,__UpperCamelCase    ):
                  values += (getattr(__UpperCamelCase      ,__UpperCamelCase    ),)
                  SCREAMING_SNAKE_CASE   :      Optional[int]    					=						f"The `{attribute}` attribute is deprecated and will be removed in version {version_name}."
            elif deprecated_kwargs is None:
                  SCREAMING_SNAKE_CASE   :      Dict    					=						f"`{attribute}` is deprecated and will be removed in version {version_name}."

            if warning is not None:
                  SCREAMING_SNAKE_CASE   :      Dict    					=						warning + ' ' if standard_warn else ''
                  warnings.warn(warning + message      ,__UpperCamelCase      ,stacklevel=__UpperCamelCase    )

      if isinstance(__UpperCamelCase      ,__UpperCamelCase    ) and len(__UpperCamelCase    ) > 0:
            SCREAMING_SNAKE_CASE   :      Union[str, Any]    					=						inspect.getouterframes(inspect.currentframe()    )[1]
            SCREAMING_SNAKE_CASE   :      Any    					=						call_frame.filename
            SCREAMING_SNAKE_CASE   :      Tuple    					=						call_frame.lineno
            SCREAMING_SNAKE_CASE   :      Union[str, Any]    					=						call_frame.function
            SCREAMING_SNAKE_CASE					,    SCREAMING_SNAKE_CASE   :      Tuple    					=						next(iter(deprecated_kwargs.items()    )    )
            raise TypeError(f"{function} in {filename} line {line_number-1} got an unexpected keyword argument `{key}`"    )

      if len(__UpperCamelCase    ) == 0:
            return
      elif len(__UpperCamelCase    ) == 1:
            return values[0]
      return values


