
import datasets

from .evaluate import evaluate


lowercase  : Any						   =							"\\n@article{hendrycks2021cuad,\n      title={CUAD: An Expert-Annotated NLP Dataset for Legal Contract Review},\n      author={Dan Hendrycks and Collin Burns and Anya Chen and Spencer Ball},\n      journal={arXiv preprint arXiv:2103.06268},\n      year={2021}\n}\n"

lowercase  : List[Any]						   =							"\nThis metric wrap the official scoring script for version 1 of the Contract\nUnderstanding Atticus Dataset (CUAD).\nContract Understanding Atticus Dataset (CUAD) v1 is a corpus of more than 13,000 labels in 510\ncommercial legal contracts that have been manually labeled to identify 41 categories of important\nclauses that lawyers look for when reviewing contracts in connection with corporate transactions.\n"

lowercase  : Optional[Any]						   =							"\nComputes CUAD scores (EM, F1, AUPR, Precision@80%Recall, and Precision@90%Recall).\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': list of possible texts for the answer, as a list of strings\n        depending on a threshold on the confidence probability of each prediction.\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 CUAD 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\n    'aupr': Area Under the Precision-Recall curve\n    'prec_at_80_recall': Precision at 80% recall\n    'prec_at_90_recall': Precision at 90% recall\nExamples:\n    >>> predictions = [{'prediction_text': ['The seller:', 'The buyer/End-User: Shenzhen LOHAS Supply Chain Management Co., Ltd.'], 'id': 'LohaCompanyltd_20191209_F-1_EX-10.16_11917878_EX-10.16_Supply Agreement__Parties'}]\n    >>> references = [{'answers': {'answer_start': [143, 49], 'text': ['The seller:', 'The buyer/End-User: Shenzhen LOHAS Supply Chain Management Co., Ltd.']}, 'id': 'LohaCompanyltd_20191209_F-1_EX-10.16_11917878_EX-10.16_Supply Agreement__Parties'}]\n    >>> cuad_metric = datasets.load_metric(\"cuad\")\n    >>> results = cuad_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {'exact_match': 100.0, 'f1': 100.0, 'aupr': 0.0, 'prec_at_80_recall': 1.0, 'prec_at_90_recall': 1.0}\n"

@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION ,     _KWARGS_DESCRIPTION					)
class __snake_case		(				datasets.Metric					):
    def     _SCREAMING_SNAKE_CASE	(  self				):



           '''simple docstring'''







           return datasets.MetricInfo(
               description=_DESCRIPTION		,citation=_CITATION		,inputs_description=_KWARGS_DESCRIPTION		,features=datasets.Features(
                   {
                       """predictions""": {
                           """id""": datasets.Value("""string"""				),
                           """prediction_text""": datasets.features.Sequence(datasets.Value("""string"""				)				),
                       },
                       """references""": {
                           """id""": datasets.Value("""string"""				),
                           """answers""": datasets.features.Sequence(
                               {
                                   """text""": datasets.Value("""string"""				),
                                   """answer_start""": datasets.Value("""int32"""				),
                               }				),
                       },
                   }				)		,codebase_urls=["""https://www.atticusprojectai.org/cuad"""]		,reference_urls=["""https://www.atticusprojectai.org/cuad"""]		,)
    def     _SCREAMING_SNAKE_CASE	(  self		,snake_case		,snake_case				):



           '''simple docstring'''







           lowercase							:					int	     =				{prediction["""id"""]: prediction["""prediction_text"""] for prediction in predictions}
           lowercase							:					Optional[int]	     =				[
               {
                   """paragraphs""": [
                       {
                           """qas""": [
                               {
                                   """answers""": [{"""text""": answer_text} for answer_text in ref["""answers"""]["""text"""]],
                                   """id""": ref["""id"""],
                               }
                               for ref in references
                           ]
                       }
                   ]
               }
           ]
           lowercase							:					List[Any]	     =				evaluate(dataset=a_		,predictions=a_				)
           return score


import os
import re
import shutil
from argparse import ArgumentParser, Namespace

from datasets.commands import BaseDatasetsCLICommand
from datasets.utils.logging import get_logger


lowercase  : Tuple						   =							"""<<<<<<< This should probably be modified because it mentions: """

lowercase  : Any						   =							"""=======
>>>>>>>
"""

lowercase  : List[str]						   =							[
    """TextEncoderConfig""",
    """ByteTextEncoder""",
    """SubwordTextEncoder""",
    """encoder_config""",
    """maybe_build_from_corpus""",
    """manual_dir""",
]

lowercase  : Any						   =							[
    # (pattern, replacement)
    # Order is important here for some replacements
    (R"""tfds\.core""", R"""datasets"""),
    (R"""tf\.io\.gfile\.GFile""", R"""open"""),
    (R"""tf\.([\w\d]+)""", R"""datasets.Value('\1')"""),
    (R"""tfds\.features\.Text\(\)""", R"""datasets.Value('string')"""),
    (R"""tfds\.features\.Text\(""", R"""datasets.Value('string'),"""),
    (R"""features\s*=\s*tfds.features.FeaturesDict\(""", R"""features=datasets.Features("""),
    (R"""tfds\.features\.FeaturesDict\(""", R"""dict("""),
    (R"""The TensorFlow Datasets Authors""", R"""The TensorFlow Datasets Authors and the HuggingFace Datasets Authors"""),
    (R"""tfds\.""", R"""datasets."""),
    (R"""dl_manager\.manual_dir""", R"""self.config.data_dir"""),
    (R"""self\.builder_config""", R"""self.config"""),
]







def 						_snake_case(  SCREAMING_SNAKE_CASE__    )			->   List[Any]:
       return ConvertCommand(args.tfds_path ,     args.datasets_directory    )




class __snake_case		(				lowerCAmelCase					):
    @staticmethod
    def 				_SCREAMING_SNAKE_CASE	(  snake_case				):



           '''simple docstring'''







           lowercase							:					str	     =				parser.add_parser(
               """convert"""		,help="""Convert a TensorFlow Datasets dataset to a HuggingFace Datasets dataset."""		,)
           train_parser.add_argument(
               """--tfds_path"""		,type=snake_case		,required=snake_case		,help="""Path to a TensorFlow Datasets folder to convert or a single tfds file to convert."""		,)
           train_parser.add_argument(
               """--datasets_directory"""		,type=snake_case		,required=snake_case		,help="""Path to the HuggingFace Datasets folder."""				)
           train_parser.set_defaults(func=snake_case				)
    def __init__(  self		,snake_case		,snake_case		,*snake_case				):



           '''simple docstring'''







           lowercase							:					Optional[Any]	     =				get_logger("""datasets-cli/converting"""				)

           lowercase							:					Optional[int]	     =				tfds_path
           lowercase							:					Dict	     =				datasets_directory
    def 				_SCREAMING_SNAKE_CASE	(  self				):



           '''simple docstring'''







           if os.path.isdir(self._tfds_path				):
                  lowercase							:					List[str]	     =				os.path.abspath(self._tfds_path				)
           elif os.path.isfile(self._tfds_path				):
                  lowercase							:					Tuple	     =				os.path.dirname(self._tfds_path				)
           else:
                  raise ValueError("""--tfds_path is neither a directory nor a file. Please check path."""				)

           lowercase							:					Optional[int]	     =				os.path.abspath(self._datasets_directory				)

           self._logger.info(f"Converting datasets from {abs_tfds_path} to {abs_datasets_path}"				)

           lowercase							:					List[Any]	     =				[]
           lowercase							:					Optional[int]	     =				[]
           lowercase							:					Dict	     =				{}

           if os.path.isdir(self._tfds_path				):
                  lowercase							:					int	     =				os.listdir(snake_case				)
           else:
                  lowercase							:					List[Any]	     =				[os.path.basename(self._tfds_path				)]

           for f_name in file_names:
                  self._logger.info(f"Looking at file {f_name}"				)
                  lowercase							:					List[Any]	     =				os.path.join(snake_case		,snake_case				)
                  lowercase							:					List[str]	     =				os.path.join(snake_case		,snake_case				)

                  if not os.path.isfile(snake_case				) or "__init__" in f_name or "_test" in f_name or ".py" not in f_name:
                         self._logger.info("""Skipping file"""				)
                         continue

                  with open(snake_case		,encoding="""utf-8"""				) as f:
                         lowercase							:					str	     =				f.readlines()

                  lowercase							:					Union[str, Any]	     =				[]
                  lowercase							:					Optional[Any]	     =				False
                  lowercase							:					Optional[Any]	     =				False
                  lowercase							:					Optional[int]	     =				[]
                  for line in lines:
                         lowercase							:					int	     =				line

                         # Convert imports
                         if "import tensorflow.compat.v2 as tf" in out_line:
                                continue
                         elif "@tfds.core" in out_line:
                                continue
                         elif "builder=self" in out_line:
                                continue
                         elif "import tensorflow_datasets.public_api as tfds" in out_line:
                                lowercase							:					Union[str, Any]	     =				"""import datasets\n"""
                         elif "import tensorflow" in out_line:
                                # order is important here
                                lowercase							:					List[Any]	     =				""""""
                                continue
                         elif "from absl import logging" in out_line:
                                lowercase							:					Optional[int]	     =				"""from datasets import logging\n"""
                         elif "getLogger" in out_line:
                                lowercase							:					Any	     =				out_line.replace("""getLogger"""		,"""get_logger"""				)
                         elif any(expression in out_line for expression in TO_HIGHLIGHT				):
                                lowercase							:					Optional[Any]	     =				True
                                lowercase							:					Optional[Any]	     =				list(filter(lambda snake_case				: e in out_line		,snake_case				)				)
                                out_lines.append(HIGHLIGHT_MESSAGE_PRE + str(snake_case				) + """\n"""				)
                                out_lines.append(snake_case				)
                                out_lines.append(snake_case				)
                                continue
                         else:
                                for pattern, replacement in TO_CONVERT:
                                       lowercase							:					Union[str, Any]	     =				re.sub(snake_case		,snake_case		,snake_case				)

                # Take care of saving utilities (to later move them together with main script)
                         if "tensorflow_datasets" in out_line:
                                lowercase							:					Dict	     =				re.match(r"""from\stensorflow_datasets.*import\s([^\.\r\n]+)"""		,snake_case				)
                                tfds_imports.extend(imp.strip() for imp in match.group(1				).split(""","""				)				)
                                lowercase							:					Optional[int]	     =				"""from . import """ + match.group(1				)

                         # Check we have not forget anything
                         if "tf." in out_line or "tfds." in out_line or "tensorflow_datasets" in out_line:
                                raise ValueError(f"Error converting {out_line.strip()}"				)

                         if "GeneratorBasedBuilder" in out_line or "BeamBasedBuilder" in out_line:
                                lowercase							:					Any	     =				True
                         out_lines.append(snake_case				)

                  if is_builder or "wmt" in f_name:
                         # We create a new directory for each dataset
                         lowercase							:					Union[str, Any]	     =				f_name.replace(""".py"""		,""""""				)
                         lowercase							:					Optional[Any]	     =				os.path.join(snake_case		,snake_case				)
                         lowercase							:					List[str]	     =				os.path.join(snake_case		,snake_case				)
                         os.makedirs(snake_case		,exist_ok=snake_case				)
                         self._logger.info(f"Adding directory {output_dir}"				)
                         imports_to_builder_map.update({imp: output_dir for imp in tfds_imports}				)
                  else:
                         # Utilities will be moved at the end
                         utils_files.append(snake_case				)

                  if needs_manual_update:
                         with_manual_update.append(snake_case				)

                  with open(snake_case		,"""w"""		,encoding="""utf-8"""				) as f:
                         f.writelines(snake_case				)
                  self._logger.info(f"Converted in {output_file}"				)

           for utils_file in utils_files:
                  try:
                         lowercase							:					Optional[int]	     =				os.path.basename(snake_case				)
                         lowercase							:					int	     =				imports_to_builder_map[f_name.replace(""".py"""		,""""""				)]
                         self._logger.info(f"Moving {dest_folder} to {utils_file}"				)
                         shutil.copy(snake_case		,snake_case				)
                  except KeyError:
                         self._logger.error(f"Cannot find destination folder for {utils_file}. Please copy manually."				)

           if with_manual_update:
                  for file_path in with_manual_update:
                         self._logger.warning(
                             f"You need to manually update file {file_path} to remove configurations using 'TextEncoderConfig'."				)
