





import argparse
import json
import re
import string
import sys
from collections import Counter



def _a							(      lowerCamelCase:  Union[str, Any]					)      ->		Tuple:







      '''simple docstring'''






      def remove_articles(lowerCamelCase:  Dict					):
            return re.sub(r'''\b(a|an|the)\b'''   ,							''' '''   ,							a__					)

      def white_space_fix(lowerCamelCase:  Any					):
            return " ".join(text.split()					)

      def remove_punc(lowerCamelCase:  int					):
            __A			  =							set(string.punctuation					)
            return "".join(ch for ch in text if ch not in exclude					)

      def lower(lowerCamelCase:  List[Any]					):
            return text.lower()

      return white_space_fix(remove_articles(remove_punc(lower(a__					)					)					)					)



def _a							(      lowerCamelCase:  Optional[Any]   ,							lowerCamelCase:  Dict					)      ->		Union[str, Any]:







      '''simple docstring'''






      __A			  =							normalize_answer(a__					).split()
      __A			  =							normalize_answer(a__					).split()
      __A			  =							Counter(a__					) & Counter(a__					)
      __A			  =							sum(common.values()					)
      if num_same == 0:
            return 0
      __A			  =							1.0 * num_same / len(a__					)
      __A			  =							1.0 * num_same / len(a__					)
      __A			  =							(2 * precision * recall) / (precision + recall)
      return fa



def _a							(      lowerCamelCase:  Optional[Any]   ,							lowerCamelCase:  int					)      ->		Any:







      '''simple docstring'''






      return normalize_answer(a__					) == normalize_answer(a__					)



def _a							(      lowerCamelCase:  Tuple   ,							lowerCamelCase:  List[str]   ,							lowerCamelCase:  List[Any]					)      ->		Optional[Any]:







      '''simple docstring'''






      __A			  =							[]
      for ground_truth in ground_truths:
            __A			  =							metric_fn(a__   ,							a__					)
            scores_for_ground_truths.append(a__					)
      return max(a__					)



def _a							(      lowerCamelCase:  int   ,							lowerCamelCase:  Union[str, Any]					)      ->		Union[str, Any]:







      '''simple docstring'''






      __A			  =							0
      __A			  =							[]
      for passage in dataset:
            for qa in passage["qas"]:
                  total += 1
                  if qa["id"] not in predictions:
                        __A			  =							F"""Unanswered question {qa['id']} will receive score 0."""
                        print(a__   ,							file=sys.stderr					)
                        continue

                  __A			  =							[x['''text'''] for x in qa['''answers''']]
                  __A			  =							predictions[qa['''id''']]

                  __A			  =							metric_max_over_ground_truths(a__   ,							a__   ,							a__					)
                  if int(_exact_match					) == 1:
                        correct_ids.append(qa['''id''']					)
                  exact_match += _exact_match

                  fa += metric_max_over_ground_truths(a__   ,							a__   ,							a__					)

      __A			  =							exact_match / total
      __A			  =							fa / total

      return {"exact_match": exact_match, "f1": fa}, correct_ids


if __name__ == "__main__":
       snake_case__   :				int						=	'''1.0'''
       snake_case__   :				int						=	argparse.ArgumentParser('Official evaluation script for ReCoRD v1.0.')
       parser.add_argument('data_file', help='The dataset file in JSON format.')
       parser.add_argument('pred_file', help='The model prediction file in JSON format.')
       parser.add_argument('--output_correct_ids', action='store_true', help='Output the correctly answered query IDs.')
       snake_case__   :				int						=	parser.parse_args()

       with open(args.data_file) as data_file:
              snake_case__   :				List[Any]						=	json.load(data_file)
              if dataset_json["version"] != expected_version:
                     print(
                         f'Evaluation expects v-{expected_version}, but got dataset with v-{dataset_json["version"]}',
                         file=sys.stderr,
                     )
              snake_case__   :				Union[str, Any]						=	dataset_json['''data''']

       with open(args.pred_file) as pred_file:
              snake_case__   :				str						=	json.load(pred_file)

       snake_case__   :				str						=	evaluate(dataset, predictions)

       if args.output_correct_ids:
              print(f'Output {len(correct_ids)} correctly answered question IDs.')
              with open('correct_ids.json', 'w') as f:
                     json.dump(correct_ids, f)







# Lint as: python3
import sys
from collections.abc import Mapping
from typing import TYPE_CHECKING

import numpy as np
import pyarrow as pa

from .. import config
from ..utils.py_utils import map_nested
from .formatting import TensorFormatter


if TYPE_CHECKING:
      import tensorflow as tf






class     a_       (			TensorFormatter[Mapping, 'tf.Tensor', Mapping]							):



       """simple docstring"""






       def __init__(		self				,       _lowerCamelCase=None				,       **_lowerCamelCase   )					->int:
           super().__init__(features=_lowerCamelCase   )
           SCREAMING_SNAKE_CASE				:				Any				      = tf_tensor_kwargs
           import tensorflow as tf  # noqa: import tf at initialization






       def 	__lowerCAmelCase     (		self				,       _lowerCamelCase   )					->Tuple:
           import tensorflow as tf

           if isinstance(_lowerCamelCase				,       _lowerCamelCase   ) and column:
               if all(
                   isinstance(_lowerCamelCase				,       tf.Tensor   ) and x.shape == column[0].shape and x.dtype == column[0].dtype for x in column   ):
                   return tf.stack(_lowerCamelCase   )
               elif all(
                   isinstance(_lowerCamelCase				,       (tf.Tensor, tf.RaggedTensor)   ) and x.ndim == 1 and x.dtype == column[0].dtype
                   for x in column   ):
                   # only rag 1-D tensors, otherwise some dimensions become ragged even though they were consolidated
                   return tf.ragged.stack(_lowerCamelCase   )

           return column






       def 	__lowerCAmelCase     (		self				,       _lowerCamelCase   )					->Union[str, Any]:
           import tensorflow as tf

           if value is None:
               return value

           SCREAMING_SNAKE_CASE				:				int				      = {}

           if isinstance(_lowerCamelCase				,       (np.number, np.ndarray)   ) and np.issubdtype(value.dtype				,       np.integer   ):
               SCREAMING_SNAKE_CASE				:				List[Any]				      = {'''dtype''': tf.intaa}
           elif isinstance(_lowerCamelCase				,       (np.number, np.ndarray)   ) and np.issubdtype(value.dtype				,       np.floating   ):
               SCREAMING_SNAKE_CASE				:				Optional[int]				      = {'''dtype''': tf.floataa}
           elif config.PIL_AVAILABLE and "PIL" in sys.modules:
               import PIL.Image

               if isinstance(_lowerCamelCase				,       PIL.Image.Image   ):
                   SCREAMING_SNAKE_CASE				:				Any				      = np.asarray(_lowerCamelCase   )

           return tf.convert_to_tensor(_lowerCamelCase				,       **{**default_dtype, **self.tf_tensor_kwargs}   )






       def 	__lowerCAmelCase     (		self				,       _lowerCamelCase   )					->Tuple:
           import tensorflow as tf

           # support for torch, tf, jax etc.
           if config.TORCH_AVAILABLE and "torch" in sys.modules:
               import torch

               if isinstance(_lowerCamelCase				,       torch.Tensor   ):
                   return self._tensorize(data_struct.detach().cpu().numpy()[()]   )
           if hasattr(_lowerCamelCase				,       '''__array__'''   ) and not isinstance(_lowerCamelCase				,       tf.Tensor   ):
               SCREAMING_SNAKE_CASE				:				int				      = data_struct.__array__()
           # support for nested types like struct of list of struct
           if isinstance(_lowerCamelCase				,       np.ndarray   ):
               if data_struct.dtype == object:  # tf tensors cannot be instantied from an array of objects
                   return self._consolidate([self.recursive_tensorize(_lowerCamelCase   ) for substruct in data_struct]   )
           elif isinstance(_lowerCamelCase				,       (list, tuple)   ):
               return self._consolidate([self.recursive_tensorize(_lowerCamelCase   ) for substruct in data_struct]   )
           return self._tensorize(_lowerCamelCase   )






       def 	__lowerCAmelCase     (		self				,       _lowerCamelCase   )					->Optional[int]:
           return map_nested(self._recursive_tensorize				,       _lowerCamelCase				,       map_list=_lowerCamelCase   )






       def 	__lowerCAmelCase     (		self				,       _lowerCamelCase   )					->Mapping:
           SCREAMING_SNAKE_CASE				:				str				      = self.numpy_arrow_extractor().extract_row(_lowerCamelCase   )
           SCREAMING_SNAKE_CASE				:				List[str]				      = self.python_features_decoder.decode_row(_lowerCamelCase   )
           return self.recursive_tensorize(_lowerCamelCase   )






       def 	__lowerCAmelCase     (		self				,       _lowerCamelCase   )					->"tf.Tensor":
           SCREAMING_SNAKE_CASE				:				Optional[int]				      = self.numpy_arrow_extractor().extract_column(_lowerCamelCase   )
           SCREAMING_SNAKE_CASE				:				str				      = self.python_features_decoder.decode_column(_lowerCamelCase				,       pa_table.column_names[0]   )
           SCREAMING_SNAKE_CASE				:				str				      = self.recursive_tensorize(_lowerCamelCase   )
           SCREAMING_SNAKE_CASE				:				int				      = self._consolidate(_lowerCamelCase   )
           return column






       def 	__lowerCAmelCase     (		self				,       _lowerCamelCase   )					->Mapping:
           SCREAMING_SNAKE_CASE				:				Tuple				      = self.numpy_arrow_extractor().extract_batch(_lowerCamelCase   )
           SCREAMING_SNAKE_CASE				:				Dict				      = self.python_features_decoder.decode_batch(_lowerCamelCase   )
           SCREAMING_SNAKE_CASE				:				int				      = self.recursive_tensorize(_lowerCamelCase   )
           for column_name in batch:
               SCREAMING_SNAKE_CASE				:				Optional[Any]				      = self._consolidate(batch[column_name]   )
           return batch
