

"""simple docstring"""




import datasets

from .evaluate import evaluate


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

__UpperCAmelCase =				"""
This metric wrap the official scoring script for version 1 of the Contract
Understanding Atticus Dataset (CUAD).
Contract Understanding Atticus Dataset (CUAD) v1 is a corpus of more than 13,000 labels in 510
commercial legal contracts that have been manually labeled to identify 41 categories of important
clauses that lawyers look for when reviewing contracts in connection with corporate transactions.
"""

__UpperCAmelCase =				"""
Computes CUAD scores (EM, F1, AUPR, Precision@80%Recall, and Precision@90%Recall).
Args:
    predictions: List of question-answers dictionaries with the following key-values:
        - 'id': id of the question-answer pair as given in the references (see below)
        - 'prediction_text': list of possible texts for the answer, as a list of strings
        depending on a threshold on the confidence probability of each prediction.
    references: List of question-answers dictionaries with the following key-values:
        - 'id': id of the question-answer pair (see above),
        - 'answers': a Dict in the CUAD dataset format
            {
                'text': list of possible texts for the answer, as a list of strings
                'answer_start': list of start positions for the answer, as a list of ints
            }
            Note that answer_start values are not taken into account to compute the metric.
Returns:
    'exact_match': Exact match (the normalized answer exactly match the gold answer)
    'f1': The F-score of predicted tokens versus the gold answer
    'aupr': Area Under the Precision-Recall curve
    'prec_at_80_recall': Precision at 80% recall
    'prec_at_90_recall': Precision at 90% recall
Examples:
    >>> 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'}]
    >>> 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'}]
    >>> cuad_metric = datasets.load_metric(\"cuad\")
    >>> results = cuad_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {'exact_match': 100.0, 'f1': 100.0, 'aupr': 0.0, 'prec_at_80_recall': 1.0, 'prec_at_90_recall': 1.0}
"""







@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION	,			_KWARGS_DESCRIPTION					)
class      __lowercase			(    datasets.Metric					):

  def    __lowercase       (  self		:			List[str]    ):






   '''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    __lowercase       (  self		:			Union[str, Any]					,A		:			Any					,A		:			List[Any]    ):






   '''simple docstring'''
   UpperCAmelCase__					:  int					   =					{prediction["id"]: prediction["prediction_text"] for prediction in predictions}
   UpperCAmelCase__					:  Union[str, Any]					   =					[
       {
           "paragraphs": [
               {
                   "qas": [
                       {
                           "answers": [{"text": answer_text} for answer_text in ref["answers"]["text"]],
                           "id": ref["id"],
                       }
                       for ref in references
                   ]
               }
           ]
       }
   ]
   UpperCAmelCase__					:  Optional[int]					   =					evaluate(dataset=__A					,predictions=__A    )
   return score








"""simple docstring"""




import argparse
import os
import re

import packaging.version


__UpperCAmelCase =				'examples/'
__UpperCAmelCase =				{
    'examples': (re.compile(r'^check_min_version\("[^"]+"\)\s*$', re.MULTILINE), 'check_min_version("VERSION")\n'),
    'init': (re.compile(r'^__version__\s+=\s+"([^"]+)"\s*$', re.MULTILINE), '__version__ = "VERSION"\n'),
    'setup': (re.compile(r'^(\s*)version\s*=\s*"[^"]+",', re.MULTILINE), r'\1version="VERSION",'),
    'doc': (re.compile(r'^(\s*)release\s*=\s*"[^"]+"$', re.MULTILINE), 'release = "VERSION"\n'),
}
__UpperCAmelCase =				{
    'init': 'src/transformers/__init__.py',
    'setup': 'setup.py',
}
__UpperCAmelCase =				'README.md'
def   lowerCAmelCase						(					__UpperCamelCase							,    __UpperCamelCase							,    __UpperCamelCase      ):
 '''simple docstring'''





 with open(__UpperCamelCase							,    """r"""							,    encoding="""utf-8"""							,    newline="""\n"""      ) as f:
  UpperCAmelCase__					:  Dict					   =					f.read()
 UpperCAmelCase__   ,      UpperCAmelCase__					:  Any					   =					REPLACE_PATTERNS[pattern]
 UpperCAmelCase__					:  List[str]					   =					replace.replace("""VERSION"""							,    __UpperCamelCase      )
 UpperCAmelCase__					:  Tuple					   =					re_pattern.sub(__UpperCamelCase							,    __UpperCamelCase      )
 with open(__UpperCamelCase							,    """w"""							,    encoding="""utf-8"""							,    newline="""\n"""      ) as f:
  f.write(__UpperCamelCase      )
def   lowerCAmelCase						(					__UpperCamelCase      ):
 '''simple docstring'''





 for folder, directories, fnames in os.walk(__UpperCamelCase      ):
  # Removing some of the folders with non-actively maintained examples from the walk
  if "research_projects" in directories:
   directories.remove("""research_projects"""      )
  if "legacy" in directories:
   directories.remove("""legacy"""      )
  for fname in fnames:
   if fname.endswith(""".py"""      ):
    update_version_in_file(os.path.join(__UpperCamelCase							,    __UpperCamelCase      )							,    __UpperCamelCase							,    pattern="""examples"""      )
def   lowerCAmelCase						(					__UpperCamelCase							,    __UpperCamelCase=False      ):
 '''simple docstring'''





 for pattern, fname in REPLACE_FILES.items():
  update_version_in_file(__UpperCamelCase							,    __UpperCamelCase							,    __UpperCamelCase      )
 if not patch:
  update_version_in_examples(__UpperCamelCase      )
def   lowerCAmelCase						(					):
 '''simple docstring'''





 UpperCAmelCase__					:  Dict					   =					"""🤗 Transformers currently provides the following architectures"""
 UpperCAmelCase__					:  Union[str, Any]					   =					"""1. Want to contribute a new model?"""
 with open(__UpperCamelCase							,    """r"""							,    encoding="""utf-8"""							,    newline="""\n"""      ) as f:
  UpperCAmelCase__					:  str					   =					f.readlines()

 # Find the start of the list.
 UpperCAmelCase__					:  List[Any]					   =					0
 while not lines[start_index].startswith(_start_prompt      ):
  start_index += 1
 start_index += 1

 UpperCAmelCase__					:  int					   =					start_index
 # Update the lines in the model list.
 while not lines[index].startswith(_end_prompt      ):
  if lines[index].startswith("""1."""      ):
   UpperCAmelCase__					:  List[Any]					   =					lines[index].replace(
       """https://huggingface.co/docs/transformers/main/model_doc"""							,    """https://huggingface.co/docs/transformers/model_doc"""							,    )
  index += 1

 with open(__UpperCamelCase							,    """w"""							,    encoding="""utf-8"""							,    newline="""\n"""      ) as f:
  f.writelines(__UpperCamelCase      )
def   lowerCAmelCase						(					):
 '''simple docstring'''





 with open(REPLACE_FILES["""init"""]							,    """r"""      ) as f:
  UpperCAmelCase__					:  Optional[Any]					   =					f.read()
 UpperCAmelCase__					:  int					   =					REPLACE_PATTERNS["""init"""][0].search(__UpperCamelCase      ).groups()[0]
 return packaging.version.parse(__UpperCamelCase      )
def   lowerCAmelCase						(					__UpperCamelCase=False      ):
 '''simple docstring'''





 UpperCAmelCase__					:  List[str]					   =					get_version()
 if patch and default_version.is_devrelease:
  raise ValueError("""Can't create a patch version from the dev branch, checkout a released version!"""      )
 if default_version.is_devrelease:
  UpperCAmelCase__					:  List[str]					   =					default_version.base_version
 elif patch:
  UpperCAmelCase__					:  Any					   =					F"{default_version.major}.{default_version.minor}.{default_version.micro + 1}"
 else:
  UpperCAmelCase__					:  Optional[Any]					   =					F"{default_version.major}.{default_version.minor + 1}.0"

 # Now let's ask nicely if that's the right one.
 UpperCAmelCase__					:  Optional[int]					   =					input(F"Which version are you releasing? [{default_version}]"      )
 if len(__UpperCamelCase      ) == 0:
  UpperCAmelCase__					:  Union[str, Any]					   =					default_version

 print(F"Updating version to {version}."      )
 global_version_update(__UpperCamelCase							,    patch=__UpperCamelCase      )
 if not patch:
  print("""Cleaning main README, don't forget to run `make fix-copies`."""      )
  clean_main_ref_in_model_list()
def   lowerCAmelCase						(					):
 '''simple docstring'''





 UpperCAmelCase__					:  Optional[Any]					   =					get_version()
 UpperCAmelCase__					:  Any					   =					F"{current_version.major}.{current_version.minor + 1}.0.dev0"
 UpperCAmelCase__					:  List[Any]					   =					current_version.base_version

 # Check with the user we got that right.
 UpperCAmelCase__					:  Dict					   =					input(F"Which version are we developing now? [{dev_version}]"      )
 if len(__UpperCamelCase      ) == 0:
  UpperCAmelCase__					:  List[Any]					   =					dev_version

 print(F"Updating version to {version}."      )
 global_version_update(__UpperCamelCase      )
 print("""Cleaning main README, don't forget to run `make fix-copies`."""      )
 clean_main_ref_in_model_list()


if __name__ == "__main__":
      __UpperCAmelCase =				argparse.ArgumentParser()
      parser.add_argument('--post_release', action='store_true', help='Whether this is pre or post release.')
      parser.add_argument('--patch', action='store_true', help='Whether or not this is a patch release.')
      __UpperCAmelCase =				parser.parse_args()
      if not args.post_release:
            pre_release_work(patch=args.patch)
      elif args.patch:
            print('Nothing to do after a patch :-)')
      else:
            post_release_work()





