




import argparse
import json
import re
import string
import sys
from collections import Counter
def 		a_       (   __lowerCAmelCase							):

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

  def white_space_fix(__lowerCAmelCase							):
    return " ".join(text.split()							)

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

  def lower(__lowerCAmelCase							):
    return text.lower()

  return white_space_fix(remove_articles(remove_punc(lower(__lowerCAmelCase							)							)							)							)
def 		a_       (   __lowerCAmelCase      ,   __lowerCAmelCase							):
  lowerCAmelCase__								=			normalize_answer(__lowerCAmelCase							).split()
  lowerCAmelCase__								=			normalize_answer(__lowerCAmelCase							).split()
  lowerCAmelCase__								=			Counter(__lowerCAmelCase							) & Counter(__lowerCAmelCase							)
  lowerCAmelCase__								=			sum(common.values()							)
  if num_same == 0:
    return 0
  lowerCAmelCase__								=			1.0 * num_same / len(__lowerCAmelCase							)
  lowerCAmelCase__								=			1.0 * num_same / len(__lowerCAmelCase							)
  lowerCAmelCase__								=			(2 * precision * recall) / (precision + recall)
  return fa
def 		a_       (   __lowerCAmelCase      ,   __lowerCAmelCase							):
  return normalize_answer(__lowerCAmelCase							) == normalize_answer(__lowerCAmelCase							)
def 		a_       (   __lowerCAmelCase      ,   __lowerCAmelCase      ,   __lowerCAmelCase							):
  lowerCAmelCase__								=			[]
  for ground_truth in ground_truths:
    lowerCAmelCase__								=			metric_fn(__lowerCAmelCase      ,   __lowerCAmelCase							)
    scores_for_ground_truths.append(__lowerCAmelCase							)
  return max(__lowerCAmelCase							)
def 		a_       (   __lowerCAmelCase      ,   __lowerCAmelCase							):
  lowerCAmelCase__								=			lowerCAmelCase__								=			lowerCAmelCase__								=			0
  lowerCAmelCase__								=			[]
  for passage in dataset:
    for qa in passage["qas"]:
      total += 1
      if qa["id"] not in predictions:
        lowerCAmelCase__								=			F"""Unanswered question {qa['id']} will receive score 0."""
        print(__lowerCAmelCase      ,   file=sys.stderr							)
        continue

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

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

      fa += metric_max_over_ground_truths(__lowerCAmelCase      ,   __lowerCAmelCase      ,   __lowerCAmelCase							)

  lowerCAmelCase__								=			exact_match / total
  lowerCAmelCase__								=			fa / total

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


if __name__ == "__main__":
      __magic_name__     :     Tuple  							=					"""1.0"""
      __magic_name__     :     List[Any]  							=					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.""")
      __magic_name__     :     Dict  							=					parser.parse_args()

      with open(args.data_file) as data_file:
            __magic_name__     :     Tuple  							=					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,
                  )
            __magic_name__     :     Dict  							=					dataset_json["""data"""]

      with open(args.pred_file) as pred_file:
            __magic_name__     :     Optional[Any]  							=					json.load(pred_file)

      __magic_name__							,   __magic_name__     :     Any  							=					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)







import importlib
import inspect
from functools import wraps
from typing import TYPE_CHECKING, Optional, Union

from .download.streaming_download_manager import (
    xbasename,
    xdirname,
    xet_parse,
    xexists,
    xgetsize,
    xglob,
    xgzip_open,
    xisdir,
    xisfile,
    xjoin,
    xlistdir,
    xnumpy_load,
    xopen,
    xpandas_read_csv,
    xpandas_read_excel,
    xPath,
    xrelpath,
    xsio_loadmat,
    xsplit,
    xsplitext,
    xwalk,
    xxml_dom_minidom_parse,
)
from .utils.logging import get_logger
from .utils.patching import patch_submodule
from .utils.py_utils import get_imports


__magic_name__     :     List[Any]  							=					get_logger(__name__)


if TYPE_CHECKING:
      from .builder import DatasetBuilder
def 		a_       (   __lowerCAmelCase      ,   __lowerCAmelCase = None							):
  lowerCAmelCase__								=			importlib.import_module(__lowerCAmelCase							)

  # TODO(QL): always update the module to add subsequent new authentication
  if hasattr(__lowerCAmelCase      ,   '''_patched_for_streaming'''							) and module._patched_for_streaming:
    return

  def wrap_auth(__lowerCAmelCase							):
    @wraps(__lowerCAmelCase							)
    def wrapper(*__lowerCAmelCase      ,   **__lowerCAmelCase							):
      return function(*__lowerCAmelCase      ,   use_auth_token=__lowerCAmelCase      ,   **__lowerCAmelCase							)

    lowerCAmelCase__								=			'''wrap_auth'''
    return wrapper

  # open files in a streaming fashion
  patch_submodule(__lowerCAmelCase      ,   '''open'''      ,   wrap_auth(__lowerCAmelCase							)							).start()
  patch_submodule(__lowerCAmelCase      ,   '''os.listdir'''      ,   wrap_auth(__lowerCAmelCase							)							).start()
  patch_submodule(__lowerCAmelCase      ,   '''os.walk'''      ,   wrap_auth(__lowerCAmelCase							)							).start()
  patch_submodule(__lowerCAmelCase      ,   '''glob.glob'''      ,   wrap_auth(__lowerCAmelCase							)							).start()
  # allow to navigate in remote zip files
  patch_submodule(__lowerCAmelCase      ,   '''os.path.join'''      ,   __lowerCAmelCase							).start()
  patch_submodule(__lowerCAmelCase      ,   '''os.path.dirname'''      ,   __lowerCAmelCase							).start()
  patch_submodule(__lowerCAmelCase      ,   '''os.path.basename'''      ,   __lowerCAmelCase							).start()
  patch_submodule(__lowerCAmelCase      ,   '''os.path.relpath'''      ,   __lowerCAmelCase							).start()
  patch_submodule(__lowerCAmelCase      ,   '''os.path.split'''      ,   __lowerCAmelCase							).start()
  patch_submodule(__lowerCAmelCase      ,   '''os.path.splitext'''      ,   __lowerCAmelCase							).start()
  # allow checks on paths
  patch_submodule(__lowerCAmelCase      ,   '''os.path.exists'''      ,   wrap_auth(__lowerCAmelCase							)							).start()
  patch_submodule(__lowerCAmelCase      ,   '''os.path.isdir'''      ,   wrap_auth(__lowerCAmelCase							)							).start()
  patch_submodule(__lowerCAmelCase      ,   '''os.path.isfile'''      ,   wrap_auth(__lowerCAmelCase							)							).start()
  patch_submodule(__lowerCAmelCase      ,   '''os.path.getsize'''      ,   wrap_auth(__lowerCAmelCase							)							).start()
  patch_submodule(__lowerCAmelCase      ,   '''pathlib.Path'''      ,   __lowerCAmelCase							).start()
  # file readers
  patch_submodule(__lowerCAmelCase      ,   '''gzip.open'''      ,   wrap_auth(__lowerCAmelCase							)							).start()
  patch_submodule(__lowerCAmelCase      ,   '''numpy.load'''      ,   wrap_auth(__lowerCAmelCase							)							).start()
  patch_submodule(__lowerCAmelCase      ,   '''pandas.read_csv'''      ,   wrap_auth(__lowerCAmelCase							)      ,   attrs=['''__version__''']							).start()
  patch_submodule(__lowerCAmelCase      ,   '''pandas.read_excel'''      ,   wrap_auth(__lowerCAmelCase							)      ,   attrs=['''__version__''']							).start()
  patch_submodule(__lowerCAmelCase      ,   '''scipy.io.loadmat'''      ,   wrap_auth(__lowerCAmelCase							)      ,   attrs=['''__version__''']							).start()
  patch_submodule(__lowerCAmelCase      ,   '''xml.etree.ElementTree.parse'''      ,   wrap_auth(__lowerCAmelCase							)							).start()
  patch_submodule(__lowerCAmelCase      ,   '''xml.dom.minidom.parse'''      ,   wrap_auth(__lowerCAmelCase							)							).start()
  lowerCAmelCase__								=			True




def 		a_       (   __lowerCAmelCase							):
  extend_module_for_streaming(builder.__module__      ,   use_auth_token=builder.use_auth_token							)
  # if needed, we also have to extend additional internal imports (like wmt14 -> wmt_utils)
  if not builder.__module__.startswith('''datasets.'''							):  # check that it's not a packaged builder like csv
    for imports in get_imports(inspect.getfile(builder.__class__							)							):
      if imports[0] == "internal":
        lowerCAmelCase__								=			imports[1]
        lowerCAmelCase__								=			'''.'''.join(builder.__module__.split('''.'''							)[:-1] + [internal_import_name]							)
        extend_module_for_streaming(__lowerCAmelCase      ,   use_auth_token=builder.use_auth_token							)

    # builders can inherit from other builders that might use streaming functionality
    # (for example, ImageFolder and AudioFolder inherit from FolderBuilder which implements examples generation)
    # but these parents builders are not patched automatically as they are not instantiated, so we patch them here
  from .builder import DatasetBuilder

  lowerCAmelCase__								=			[
      cls.__module__
      for cls in type(__lowerCAmelCase							).__mro__[1:]  # make sure it's not the same module we've already patched
      if issubclass(cls      ,   __lowerCAmelCase							) and cls.__module__ != DatasetBuilder.__module__
  ]  # check it's not a standard builder from datasets.builder
  for module in parent_builder_modules:
    extend_module_for_streaming(__lowerCAmelCase      ,   use_auth_token=builder.use_auth_token							)

