


'''simple docstring'''







import re
import string
from collections import Counter

import sacrebleu
import sacremoses
from packaging import version

import datasets


a__  :					Optional[Any]        =       '\n@inproceedings{xu-etal-2016-optimizing,\n    title = {Optimizing Statistical Machine Translation for Text Simplification},\n    authors={Xu, Wei and Napoles, Courtney and Pavlick, Ellie and Chen, Quanze and Callison-Burch, Chris},\n    journal = {Transactions of the Association for Computational Linguistics},\n    volume = {4},\n    year={2016},\n    url = {https://www.aclweb.org/anthology/Q16-1029},\n    pages = {401--415\n},\n@inproceedings{post-2018-call,\n    title = "A Call for Clarity in Reporting {BLEU} Scores",\n    author = "Post, Matt",\n    booktitle = "Proceedings of the Third Conference on Machine Translation: Research Papers",\n    month = oct,\n    year = "2018",\n    address = "Belgium, Brussels",\n    publisher = "Association for Computational Linguistics",\n    url = "https://www.aclweb.org/anthology/W18-6319",\n    pages = "186--191",\n}\n'

a__  :					List[Any]        =       '\\nWIKI_SPLIT is the combination of three metrics SARI, EXACT and SACREBLEU\nIt can be used to evaluate the quality of machine-generated texts.\n'


a__  :					int        =       '\nCalculates sari score (between 0 and 100) given a list of source and predicted\nsentences, and a list of lists of reference sentences. It also computes the BLEU score as well as the exact match score.\nArgs:\n    sources: list of source sentences where each sentence should be a string.\n    predictions: list of predicted sentences where each sentence should be a string.\n    references: list of lists of reference sentences where each sentence should be a string.\nReturns:\n    sari: sari score\n    sacrebleu: sacrebleu score\n    exact: exact score\n\nExamples:\n    >>> sources=["About 95 species are currently accepted ."]\n    >>> predictions=["About 95 you now get in ."]\n    >>> references=[["About 95 species are currently known ."]]\n    >>> wiki_split = datasets.load_metric("wiki_split")\n    >>> results = wiki_split.compute(sources=sources, predictions=predictions, references=references)\n    >>> print(results)\n    {\'sari\': 21.805555555555557, \'sacrebleu\': 14.535768424205482, \'exact\': 0.0}\n'







def _UpperCamelCase       (     __A    )							->		List[Any]:


      '''simple docstring'''



      def remove_articles(__A    ):
            UpperCamelCase__										=				re.compile(R"\b(a|an|the)\b"      ,			re.UNICODE    )
            return re.sub(__SCREAMING_SNAKE_CASE      ,			" "      ,			__SCREAMING_SNAKE_CASE    )

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

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

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

      return white_space_fix(remove_articles(remove_punc(lower(__SCREAMING_SNAKE_CASE    )    )    )    )







def _UpperCamelCase       (     __A      ,			__A    )							->		List[str]:


      '''simple docstring'''



      return int(normalize_answer(__SCREAMING_SNAKE_CASE    ) == normalize_answer(__SCREAMING_SNAKE_CASE    )    )







def _UpperCamelCase       (     __A      ,			__A    )							->		Any:


      '''simple docstring'''



      UpperCamelCase__										=				[any(compute_exact(__SCREAMING_SNAKE_CASE      ,			__SCREAMING_SNAKE_CASE    ) for ref in refs    ) for pred, refs in zip(__SCREAMING_SNAKE_CASE      ,			__SCREAMING_SNAKE_CASE    )]
      return (sum(__SCREAMING_SNAKE_CASE    ) / len(__SCREAMING_SNAKE_CASE    )) * 100







def _UpperCamelCase       (     __A      ,			__A      ,			__A      ,			__A    )							->		Dict:


      '''simple docstring'''



      UpperCamelCase__										=				[rgram for rgrams in rgramslist for rgram in rgrams]
      UpperCamelCase__										=				Counter(__SCREAMING_SNAKE_CASE    )

      UpperCamelCase__										=				Counter(__SCREAMING_SNAKE_CASE    )
      UpperCamelCase__										=				Counter()
      for sgram, scount in sgramcounter.items():
            UpperCamelCase__										=				scount * numref

      UpperCamelCase__										=				Counter(__SCREAMING_SNAKE_CASE    )
      UpperCamelCase__										=				Counter()
      for cgram, ccount in cgramcounter.items():
            UpperCamelCase__										=				ccount * numref

      # KEEP
      UpperCamelCase__										=				sgramcounter_rep & cgramcounter_rep
      UpperCamelCase__										=				keepgramcounter_rep & rgramcounter
      UpperCamelCase__										=				sgramcounter_rep & rgramcounter

      UpperCamelCase__										=				0
      UpperCamelCase__										=				0
      for keepgram in keepgramcountergood_rep:
            keeptmpscorea += keepgramcountergood_rep[keepgram] / keepgramcounter_rep[keepgram]
            # Fix an alleged bug [2] in the keep score computation.
            # keeptmpscore2 += keepgramcountergood_rep[keepgram] / keepgramcounterall_rep[keepgram]
            keeptmpscorea += keepgramcountergood_rep[keepgram]
      # Define 0/0=1 instead of 0 to give higher scores for predictions that match
      #      a target exactly.
      UpperCamelCase__										=				1
      UpperCamelCase__										=				1
      if len(__SCREAMING_SNAKE_CASE    ) > 0:
            UpperCamelCase__										=				keeptmpscorea / len(__SCREAMING_SNAKE_CASE    )
      if len(__SCREAMING_SNAKE_CASE    ) > 0:
            # Fix an alleged bug [2] in the keep score computation.
            # keepscore_recall = keeptmpscore2 / len(keepgramcounterall_rep)
            UpperCamelCase__										=				keeptmpscorea / sum(keepgramcounterall_rep.values()    )
      UpperCamelCase__										=				0
      if keepscore_precision > 0 or keepscore_recall > 0:
            UpperCamelCase__										=				2 * keepscore_precision * keepscore_recall / (keepscore_precision + keepscore_recall)

      # DELETION
      UpperCamelCase__										=				sgramcounter_rep - cgramcounter_rep
      UpperCamelCase__										=				delgramcounter_rep - rgramcounter
      UpperCamelCase__										=				sgramcounter_rep - rgramcounter
      UpperCamelCase__										=				0
      UpperCamelCase__										=				0
      for delgram in delgramcountergood_rep:
            deltmpscorea += delgramcountergood_rep[delgram] / delgramcounter_rep[delgram]
            deltmpscorea += delgramcountergood_rep[delgram] / delgramcounterall_rep[delgram]
      # Define 0/0=1 instead of 0 to give higher scores for predictions that match
      # a target exactly.
      UpperCamelCase__										=				1
      if len(__SCREAMING_SNAKE_CASE    ) > 0:
            UpperCamelCase__										=				deltmpscorea / len(__SCREAMING_SNAKE_CASE    )

      # ADDITION
      UpperCamelCase__										=				set(__SCREAMING_SNAKE_CASE    ) - set(__SCREAMING_SNAKE_CASE    )
      UpperCamelCase__										=				set(__SCREAMING_SNAKE_CASE    ) & set(__SCREAMING_SNAKE_CASE    )
      UpperCamelCase__										=				set(__SCREAMING_SNAKE_CASE    ) - set(__SCREAMING_SNAKE_CASE    )

      UpperCamelCase__										=				0
      for addgram in addgramcountergood:
            addtmpscore += 1

      # Define 0/0=1 instead of 0 to give higher scores for predictions that match
      # a target exactly.
      UpperCamelCase__										=				1
      UpperCamelCase__										=				1
      if len(__SCREAMING_SNAKE_CASE    ) > 0:
            UpperCamelCase__										=				addtmpscore / len(__SCREAMING_SNAKE_CASE    )
      if len(__SCREAMING_SNAKE_CASE    ) > 0:
            UpperCamelCase__										=				addtmpscore / len(__SCREAMING_SNAKE_CASE    )
      UpperCamelCase__										=				0
      if addscore_precision > 0 or addscore_recall > 0:
            UpperCamelCase__										=				2 * addscore_precision * addscore_recall / (addscore_precision + addscore_recall)

      return (keepscore, delscore_precision, addscore)







def _UpperCamelCase       (     __A      ,			__A      ,			__A    )							->		Union[str, Any]:


      '''simple docstring'''



      UpperCamelCase__										=				len(__SCREAMING_SNAKE_CASE    )

      UpperCamelCase__										=				ssent.split(" "    )
      UpperCamelCase__										=				csent.split(" "    )
      UpperCamelCase__										=				[]
      UpperCamelCase__										=				[]
      UpperCamelCase__										=				[]
      UpperCamelCase__										=				[]
      UpperCamelCase__										=				[]
      UpperCamelCase__										=				[]

      UpperCamelCase__										=				[]
      UpperCamelCase__										=				[]
      UpperCamelCase__										=				[]
      UpperCamelCase__										=				[]
      for rsent in rsents:
            UpperCamelCase__										=				rsent.split(" "    )
            UpperCamelCase__										=				[]
            UpperCamelCase__										=				[]
            UpperCamelCase__										=				[]
            ragramslist.append(__SCREAMING_SNAKE_CASE    )
            for i in range(0      ,			len(__SCREAMING_SNAKE_CASE    ) - 1    ):
                  if i < len(__SCREAMING_SNAKE_CASE    ) - 1:
                        UpperCamelCase__										=				ragrams[i] + " " + ragrams[i + 1]
                        ragrams.append(__SCREAMING_SNAKE_CASE    )
                  if i < len(__SCREAMING_SNAKE_CASE    ) - 2:
                        UpperCamelCase__										=				ragrams[i] + " " + ragrams[i + 1] + " " + ragrams[i + 2]
                        ragrams.append(__SCREAMING_SNAKE_CASE    )
                  if i < len(__SCREAMING_SNAKE_CASE    ) - 3:
                        UpperCamelCase__										=				ragrams[i] + " " + ragrams[i + 1] + " " + ragrams[i + 2] + " " + ragrams[i + 3]
                        ragrams.append(__SCREAMING_SNAKE_CASE    )
            ragramslist.append(__SCREAMING_SNAKE_CASE    )
            ragramslist.append(__SCREAMING_SNAKE_CASE    )
            ragramslist.append(__SCREAMING_SNAKE_CASE    )

      for i in range(0      ,			len(__SCREAMING_SNAKE_CASE    ) - 1    ):
            if i < len(__SCREAMING_SNAKE_CASE    ) - 1:
                  UpperCamelCase__										=				sagrams[i] + " " + sagrams[i + 1]
                  sagrams.append(__SCREAMING_SNAKE_CASE    )
            if i < len(__SCREAMING_SNAKE_CASE    ) - 2:
                  UpperCamelCase__										=				sagrams[i] + " " + sagrams[i + 1] + " " + sagrams[i + 2]
                  sagrams.append(__SCREAMING_SNAKE_CASE    )
            if i < len(__SCREAMING_SNAKE_CASE    ) - 3:
                  UpperCamelCase__										=				sagrams[i] + " " + sagrams[i + 1] + " " + sagrams[i + 2] + " " + sagrams[i + 3]
                  sagrams.append(__SCREAMING_SNAKE_CASE    )

      for i in range(0      ,			len(__SCREAMING_SNAKE_CASE    ) - 1    ):
            if i < len(__SCREAMING_SNAKE_CASE    ) - 1:
                  UpperCamelCase__										=				cagrams[i] + " " + cagrams[i + 1]
                  cagrams.append(__SCREAMING_SNAKE_CASE    )
            if i < len(__SCREAMING_SNAKE_CASE    ) - 2:
                  UpperCamelCase__										=				cagrams[i] + " " + cagrams[i + 1] + " " + cagrams[i + 2]
                  cagrams.append(__SCREAMING_SNAKE_CASE    )
            if i < len(__SCREAMING_SNAKE_CASE    ) - 3:
                  UpperCamelCase__										=				cagrams[i] + " " + cagrams[i + 1] + " " + cagrams[i + 2] + " " + cagrams[i + 3]
                  cagrams.append(__SCREAMING_SNAKE_CASE    )

      ((UpperCamelCase__)					,	(UpperCamelCase__)					,	(UpperCamelCase__))										=				SARIngram(__SCREAMING_SNAKE_CASE      ,			__SCREAMING_SNAKE_CASE      ,			__SCREAMING_SNAKE_CASE      ,			__SCREAMING_SNAKE_CASE    )
      ((UpperCamelCase__)					,	(UpperCamelCase__)					,	(UpperCamelCase__))										=				SARIngram(__SCREAMING_SNAKE_CASE      ,			__SCREAMING_SNAKE_CASE      ,			__SCREAMING_SNAKE_CASE      ,			__SCREAMING_SNAKE_CASE    )
      ((UpperCamelCase__)					,	(UpperCamelCase__)					,	(UpperCamelCase__))										=				SARIngram(__SCREAMING_SNAKE_CASE      ,			__SCREAMING_SNAKE_CASE      ,			__SCREAMING_SNAKE_CASE      ,			__SCREAMING_SNAKE_CASE    )
      ((UpperCamelCase__)					,	(UpperCamelCase__)					,	(UpperCamelCase__))										=				SARIngram(__SCREAMING_SNAKE_CASE      ,			__SCREAMING_SNAKE_CASE      ,			__SCREAMING_SNAKE_CASE      ,			__SCREAMING_SNAKE_CASE    )
      UpperCamelCase__										=				sum([keepascore, keepascore, keepascore, keepascore]    ) / 4
      UpperCamelCase__										=				sum([delascore, delascore, delascore, delascore]    ) / 4
      UpperCamelCase__										=				sum([addascore, addascore, addascore, addascore]    ) / 4
      UpperCamelCase__										=				(avgkeepscore + avgdelscore + avgaddscore) / 3
      return finalscore







def _UpperCamelCase       (     __A      ,			__A = True      ,			__A = "13a"      ,			__A = True    )							->		List[Any]:


      '''simple docstring'''



      if lowercase:
            UpperCamelCase__										=				sentence.lower()

      if tokenizer in ["13a", "intl"]:
            if version.parse(sacrebleu.__version__    ).major >= 2:
                  UpperCamelCase__										=				sacrebleu.metrics.bleu._get_tokenizer(__SCREAMING_SNAKE_CASE    )()(__SCREAMING_SNAKE_CASE    )
            else:
                  UpperCamelCase__										=				sacrebleu.TOKENIZERS[tokenizer]()(__SCREAMING_SNAKE_CASE    )
      elif tokenizer == "moses":
            UpperCamelCase__										=				sacremoses.MosesTokenizer().tokenize(__SCREAMING_SNAKE_CASE      ,			return_str=__SCREAMING_SNAKE_CASE      ,			escape=__SCREAMING_SNAKE_CASE    )
      elif tokenizer == "penn":
            UpperCamelCase__										=				sacremoses.MosesTokenizer().penn_tokenize(__SCREAMING_SNAKE_CASE      ,			return_str=__SCREAMING_SNAKE_CASE    )
      else:
            UpperCamelCase__										=				sentence

      if not return_str:
            UpperCamelCase__										=				normalized_sent.split()

      return normalized_sent







def _UpperCamelCase       (     __A      ,			__A      ,			__A    )							->		List[str]:


      '''simple docstring'''



      if not (len(__SCREAMING_SNAKE_CASE    ) == len(__SCREAMING_SNAKE_CASE    ) == len(__SCREAMING_SNAKE_CASE    )):
            raise ValueError("Sources length must match predictions and references lengths."    )
      UpperCamelCase__										=				0
      for src, pred, refs in zip(__SCREAMING_SNAKE_CASE      ,			__SCREAMING_SNAKE_CASE      ,			__SCREAMING_SNAKE_CASE    ):
            sari_score += SARIsent(normalize(__SCREAMING_SNAKE_CASE    )      ,			normalize(__SCREAMING_SNAKE_CASE    )      ,			[normalize(__SCREAMING_SNAKE_CASE    ) for sent in refs]    )
      UpperCamelCase__										=				sari_score / len(__SCREAMING_SNAKE_CASE    )
      return 100 * sari_score







def _UpperCamelCase       (     __A      ,			__A      ,			__A="exp"      ,			__A=None      ,			__A=False      ,			__A=False      ,			__A=False      ,			)							->		Optional[int]:


      '''simple docstring'''



      UpperCamelCase__										=				len(references[0]    )
      if any(len(__SCREAMING_SNAKE_CASE    ) != references_per_prediction for refs in references    ):
            raise ValueError("Sacrebleu requires the same number of references for each prediction"    )
      UpperCamelCase__										=				[[refs[i] for refs in references] for i in range(__SCREAMING_SNAKE_CASE    )]
      UpperCamelCase__										=				sacrebleu.corpus_bleu(
          __SCREAMING_SNAKE_CASE      ,			__SCREAMING_SNAKE_CASE      ,			smooth_method=__SCREAMING_SNAKE_CASE      ,			smooth_value=__SCREAMING_SNAKE_CASE      ,			force=__SCREAMING_SNAKE_CASE      ,			lowercase=__SCREAMING_SNAKE_CASE      ,			use_effective_order=__SCREAMING_SNAKE_CASE      ,			)
      return output.score



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


    def    __a							(     self    ):
          return datasets.MetricInfo(
              description=_DESCRIPTION  ,					citation=_CITATION  ,					inputs_description=_KWARGS_DESCRIPTION  ,					features=datasets.Features(
                  {
                      "predictions": datasets.Value("string"  ,					id="sequence"    ),
                      "references": datasets.Sequence(datasets.Value("string"  ,					id="sequence"    )  ,					id="references"    ),
                  }    )  ,					codebase_urls=[
                  "https://github.com/huggingface/transformers/blob/master/src/transformers/data/metrics/squad_metrics.py",
                  "https://github.com/cocoxu/simplification/blob/master/SARI.py",
                  "https://github.com/tensorflow/tensor2tensor/blob/master/tensor2tensor/utils/sari_hook.py",
                  "https://github.com/mjpost/sacreBLEU",
              ]  ,					reference_urls=[
                  "https://www.aclweb.org/anthology/Q16-1029.pdf",
                  "https://github.com/mjpost/sacreBLEU",
                  "https://en.wikipedia.org/wiki/BLEU",
                  "https://towardsdatascience.com/evaluating-text-output-in-nlp-bleu-at-your-own-risk-e8609665a213",
              ]  ,					)


    def    __a							(     self  ,					a  ,					a  ,					a    ):
          UpperCamelCase__										=				{}
          result.update({"sari": compute_sari(sources=a  ,					predictions=a  ,					references=a    )}    )
          result.update({"sacrebleu": compute_sacrebleu(predictions=a  ,					references=a    )}    )
          result.update({"exact": compute_em(predictions=a  ,					references=a    )}    )
          return result







def 							UpperCAmelCase_		(							__SCREAMING_SNAKE_CASE							):
	if not isinstance(__SCREAMING_SNAKE_CASE ,							__SCREAMING_SNAKE_CASE							):
		raise TypeError('Input value must be an \'int\' type'							)

	lowercase       =    0
	while number:
		position += 1
		number >>= 1

	return position


if __name__ == "__main__":
	import doctest

	doctest.testmod()

