






import os
import re
import warnings
from shutil import copyfile
from typing import List, Optional, Tuple

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import is_sentencepiece_available, logging


if is_sentencepiece_available():
 from .tokenization_ta import TaTokenizer
else:
 snake_case__   :						str													=   None


snake_case__   :						Optional[int]													=   logging.get_logger(__name__)

snake_case__   :						Dict													=   {"""vocab_file""": """spiece.model""", """tokenizer_file""": """tokenizer.json"""}

snake_case__   :						Any													=   {
    """vocab_file""": {
        """t5-small""": """https://huggingface.co/t5-small/resolve/main/spiece.model""",
        """t5-base""": """https://huggingface.co/t5-base/resolve/main/spiece.model""",
        """t5-large""": """https://huggingface.co/t5-large/resolve/main/spiece.model""",
        """t5-3b""": """https://huggingface.co/t5-3b/resolve/main/spiece.model""",
        """t5-11b""": """https://huggingface.co/t5-11b/resolve/main/spiece.model""",
    },
    """tokenizer_file""": {
        """t5-small""": """https://huggingface.co/t5-small/resolve/main/tokenizer.json""",
        """t5-base""": """https://huggingface.co/t5-base/resolve/main/tokenizer.json""",
        """t5-large""": """https://huggingface.co/t5-large/resolve/main/tokenizer.json""",
        """t5-3b""": """https://huggingface.co/t5-3b/resolve/main/tokenizer.json""",
        """t5-11b""": """https://huggingface.co/t5-11b/resolve/main/tokenizer.json""",
    },
}


# TODO(PVP) - this should be removed in Transformers v5
snake_case__   :						List[Any]													=   {
    """t5-small""": 5_1_2,
    """t5-base""": 5_1_2,
    """t5-large""": 5_1_2,
    """t5-3b""": 5_1_2,
    """t5-11b""": 5_1_2,
}


class     _a							(	UpperCAmelCase__     ):






  """simple docstring"""





  A_						       = VOCAB_FILES_NAMES
  A_						       = PRETRAINED_VOCAB_FILES_MAP
  A_						       = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
  A_						       = ["""input_ids""", """attention_mask"""]
  A_						       = TaTokenizer

  A_						       = []




  def __init__(  self		,		_UpperCAmelCase=None		,		_UpperCAmelCase=None		,		_UpperCAmelCase="</s>"		,		_UpperCAmelCase="<unk>"		,		_UpperCAmelCase="<pad>"		,		_UpperCAmelCase=100		,		_UpperCAmelCase=None		,		**_UpperCAmelCase		,		)      ->			Dict:
     # Add extra_ids to the special token list
     if extra_ids > 0 and additional_special_tokens is None:
        UpperCamelCase_						=  [f"""<extra_id_{i}>""" for i in range(_UpperCAmelCase			)]
     elif extra_ids > 0 and additional_special_tokens is not None:
        # Check that we have the right number of extra special tokens
        UpperCamelCase_						=  len(set(filter(lambda _UpperCAmelCase			: bool('extra_id_' in str(_UpperCAmelCase			)			)		,		_UpperCAmelCase			)			)			)
        if extra_tokens != extra_ids:
           raise ValueError(
               f"""Both extra_ids ({extra_ids}) and additional_special_tokens ({additional_special_tokens}) are"""
               ' provided to T5Tokenizer. In this case the additional_special_tokens must include the extra_ids'
               ' tokens'			)

     super().__init__(
         _UpperCAmelCase		,		tokenizer_file=_UpperCAmelCase		,		eos_token=_UpperCAmelCase		,		unk_token=_UpperCAmelCase		,		pad_token=_UpperCAmelCase		,		extra_ids=_UpperCAmelCase		,		additional_special_tokens=_UpperCAmelCase		,		**_UpperCAmelCase		,		)

     UpperCamelCase_						=  vocab_file
     UpperCamelCase_						=  False if not self.vocab_file else True
     UpperCamelCase_						=  extra_ids




  @staticmethod
  def  _UpperCAmelCase  (  _UpperCAmelCase		,		_UpperCAmelCase		,		_UpperCAmelCase			)      ->			List[str]:
     if pretrained_model_name_or_path in TaTokenizerFast.max_model_input_sizes:
        UpperCamelCase_						=  TaTokenizerFast.max_model_input_sizes[pretrained_model_name_or_path]
        if init_max_model_length is not None and init_max_model_length != max_model_length:
           return init_max_model_length
        elif init_max_model_length is None:
           warnings.warn(
               'This tokenizer was incorrectly instantiated with a model max length of'
               f""" {deprecated_max_model_length} which will be corrected in Transformers v5.\nFor now, this"""
               ' behavior is kept to avoid breaking backwards compatibility when padding/encoding with'
               ' `truncation is True`.\n- Be aware that you SHOULD NOT rely on'
               f""" {pretrained_model_name_or_path} automatically truncating your input to"""
               f""" {deprecated_max_model_length} when padding/encoding.\n- If you want to encode/pad to sequences"""
               f""" longer than {deprecated_max_model_length} you can either instantiate this tokenizer with"""
               ' `model_max_length` or pass `max_length` when encoding/padding.\n- To avoid this warning, please'
               ' instantiate this tokenizer with `model_max_length` set to your preferred value.'		,		_UpperCAmelCase		,		)

     return max_model_length




  def  _UpperCAmelCase  (  self		,		_UpperCAmelCase		,		_UpperCAmelCase = None			)      ->			Tuple[str]:
     if not self.can_save_slow_tokenizer:
        raise ValueError(
            'Your fast tokenizer does not have the necessary information to save the vocabulary for a slow '
            'tokenizer.'			)

     if not os.path.isdir(_UpperCAmelCase			):
        logger.error(f"""Vocabulary path ({save_directory}) should be a directory"""			)
        return
     UpperCamelCase_						=  os.path.join(
         _UpperCAmelCase		,		(filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['vocab_file']			)

     if os.path.abspath(self.vocab_file			) != os.path.abspath(_UpperCAmelCase			):
        copyfile(self.vocab_file		,		_UpperCAmelCase			)
        logger.info(f"""Copy vocab file to {out_vocab_file}"""			)

     return (out_vocab_file,)




  def  _UpperCAmelCase  (  self		,		_UpperCAmelCase		,		_UpperCAmelCase = None			)      ->			List[int]:
     UpperCamelCase_						=  token_ids_a + [self.eos_token_id]
     if token_ids_a is None:
        return self.prefix_tokens + token_ids_a
     else:
        UpperCamelCase_						=  token_ids_a + [self.eos_token_id]
        return self.prefix_tokens + token_ids_a + token_ids_a




  def  _UpperCAmelCase  (  self		,		_UpperCAmelCase		,		_UpperCAmelCase = None			)      ->			List[int]:
     UpperCamelCase_						=  [self.eos_token_id]

     if token_ids_a is None:
        return len(token_ids_a + eos			) * [0]
     return len(token_ids_a + eos + token_ids_a + eos			) * [0]




  def  _UpperCAmelCase  (  self			)      ->			List[str]:
     return list(
         set(filter(lambda _UpperCAmelCase			: bool(re.search(R'<extra_id_\d+>'		,		_UpperCAmelCase			)			) is not None		,		self.additional_special_tokens			)			)			)




  def  _UpperCAmelCase  (  self			)      ->			Optional[int]:
     return [self.convert_tokens_to_ids(_UpperCAmelCase			) for token in self.get_sentinel_tokens()]













import datasets

from .evaluate import evaluate


snake_case__   :						int													=   """\
@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}
}
"""

snake_case__   :						Union[str, Any]													=   """
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.
"""

snake_case__   :						Any													=   """
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     _a							(	datasets.Metric     ):






  """simple docstring"""





  def  _UpperCAmelCase  (  self			)      ->			Optional[int]:
     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  _UpperCAmelCase  (  self		,		_UpperCAmelCase		,		_UpperCAmelCase			)      ->			Dict:
     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





