






"""simple docstring"""







import datasets

from .evaluate import evaluate


_UpperCamelCase					      =  '\\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'

_UpperCamelCase					      =  '\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'

_UpperCamelCase					      =  '\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  lowerCamelCase__ (	datasets.Metric			):






				def     _UpperCamelCase							(			self ):
										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     ,A     ,A ):
										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=_UpperCamelCase     ,predictions=_UpperCamelCase )
										return score











"""simple docstring"""







from pathlib import Path
from typing import List

from transformers import is_torch_available, is_vision_available
from transformers.testing_utils import get_tests_dir, is_tool_test
from transformers.tools.agent_types import AGENT_TYPE_MAPPING, AgentAudio, AgentImage, AgentText


if is_torch_available():
  import torch

if is_vision_available():
  from PIL import Image


_UpperCamelCase					      =  ["""text""", """image""", """audio"""]

def _a			(		_snake_case							):







      """simple docstring"""






      UpperCAmelCase          =	[]

      for input_type in input_types:
            if input_type == "text":
                  inputs.append("""Text input"""							)
            elif input_type == "image":
                  inputs.append(
                      Image.open(Path(get_tests_dir("""fixtures/tests_samples/COCO"""							)							) / """000000039769.png"""							).resize((512, 512)							)							)
            elif input_type == "audio":
                  inputs.append(torch.ones(3000							)							)
            elif isinstance(_snake_case				,	_snake_case							):
                  inputs.append(create_inputs(_snake_case							)							)
            else:
                  raise ValueError(F'''Invalid type requested: {input_type}'''							)

      return inputs

def _a			(		_snake_case							):







      """simple docstring"""






      UpperCAmelCase          =	[]

      for output in outputs:
            if isinstance(_snake_case				,	(str, AgentText)							):
                  output_types.append("""text"""							)
            elif isinstance(_snake_case				,	(Image.Image, AgentImage)							):
                  output_types.append("""image"""							)
            elif isinstance(_snake_case				,	(torch.Tensor, AgentAudio)							):
                  output_types.append("""audio"""							)
            else:
                  raise ValueError(F'''Invalid output: {output}'''							)

      return output_types







@is_tool_test
class  lowerCamelCase__ :






    def     _UpperCamelCase							(			self ):
          self.assertTrue(hasattr(self.tool     ,"""inputs""" ) )
          self.assertTrue(hasattr(self.tool     ,"""outputs""" ) )

          UpperCAmelCase          =	self.tool.inputs
          for _input in inputs:
                if isinstance(_input     ,A ):
                      for __input in _input:
                            self.assertTrue(__input in authorized_types )
                else:
                      self.assertTrue(_input in authorized_types )

          UpperCAmelCase          =	self.tool.outputs
          for _output in outputs:
                self.assertTrue(_output in authorized_types )






    def     _UpperCamelCase							(			self ):
          UpperCAmelCase          =	create_inputs(self.tool.inputs )
          UpperCAmelCase          =	self.tool(*A )

          # There is a single output
          if len(self.tool.outputs ) == 1:
                UpperCAmelCase          =	[outputs]

          self.assertListEqual(output_types(A )     ,self.tool.outputs )






    def     _UpperCamelCase							(			self ):
          self.assertTrue(hasattr(self.tool     ,"""description""" ) )
          self.assertTrue(hasattr(self.tool     ,"""default_checkpoint""" ) )
          self.assertTrue(self.tool.description.startswith("""This is a tool that""" ) )






    def     _UpperCamelCase							(			self ):
          UpperCAmelCase          =	create_inputs(self.tool.inputs )
          UpperCAmelCase          =	self.tool(*A )

          if not isinstance(A     ,A ):
                UpperCAmelCase          =	[outputs]

          self.assertEqual(len(A )     ,len(self.tool.outputs ) )

          for output, output_type in zip(A     ,self.tool.outputs ):
                UpperCAmelCase          =	AGENT_TYPE_MAPPING[output_type]
                self.assertTrue(isinstance(A     ,A ) )






    def     _UpperCamelCase							(			self ):
          UpperCAmelCase          =	create_inputs(self.tool.inputs )

          UpperCAmelCase          =	[]

          for _input, input_type in zip(A     ,self.tool.inputs ):
                if isinstance(A     ,A ):
                      _inputs.append([AGENT_TYPE_MAPPING[_input_type](_input ) for _input_type in input_type] )
                else:
                      _inputs.append(AGENT_TYPE_MAPPING[input_type](_input ) )

        # Should not raise an error
          UpperCAmelCase          =	self.tool(*A )

          if not isinstance(A     ,A ):
                UpperCAmelCase          =	[outputs]

          self.assertEqual(len(A )     ,len(self.tool.outputs ) )



