
'''simple docstring'''


from typing import List

import jiwer
import jiwer.transforms as tr
from packaging import version

import datasets
from datasets.config import PY_VERSION


if PY_VERSION < version.parse('3.8'):
   import importlib_metadata
else:
   import importlib.metadata as importlib_metadata


snake_case_ :  List[str]     =					''


if version.parse(importlib_metadata.version('jiwer')) < version.parse('2.3.0'):


   class 						lowercase__	(  tr.AbstractTransform   ):






      '''simple docstring'''







      def __init__(			self ,   lowerCamelCase__ = " "   ):

         '''simple docstring'''







         UpperCamelCase       =  sentence_delimiter







      def       UpperCAmelCase				(			self ,   lowerCamelCase__   ):

         '''simple docstring'''







         return list(lowerCamelCase__   )







      def       UpperCAmelCase				(			self ,   lowerCamelCase__   ):

         '''simple docstring'''







         UpperCamelCase       =  []
         for sent_idx, sentence in enumerate(lowerCamelCase__   ):
            chars.extend(self.process_string(lowerCamelCase__   )   )
            if self.sentence_delimiter is not None and self.sentence_delimiter != "" and sent_idx < len(lowerCamelCase__   ) - 1:
               chars.append(self.sentence_delimiter   )
         return chars




   snake_case_ :  Optional[Any]     =					tr.Compose(
       [tr.RemoveMultipleSpaces(), tr.Strip(), SentencesToListOfCharacters(SENTENCE_DELIMITER)]
   )
else:
   snake_case_ :  Union[str, Any]     =					tr.Compose(
       [
           tr.RemoveMultipleSpaces(),
           tr.Strip(),
           tr.ReduceToSingleSentence(SENTENCE_DELIMITER),
           tr.ReduceToListOfListOfChars(),
       ]
   )


snake_case_ :  List[str]     =					'\\n@inproceedings{inproceedings,\n    author = {Morris, Andrew and Maier, Viktoria and Green, Phil},\n    year = {2004},\n    month = {01},\n    pages = {},\n    title = {From WER and RIL to MER and WIL: improved evaluation measures for connected speech recognition.}\n}\n'

snake_case_ :  Tuple     =					'\\nCharacter error rate (CER) is a common metric of the performance of an automatic speech recognition system.\n\nCER is similar to Word Error Rate (WER), but operates on character instead of word. Please refer to docs of WER for further information.\n\nCharacter error rate can be computed as:\n\nCER = (S + D + I) / N = (S + D + I) / (S + D + C)\n\nwhere\n\nS is the number of substitutions,\nD is the number of deletions,\nI is the number of insertions,\nC is the number of correct characters,\nN is the number of characters in the reference (N=S+D+C).\n\nCER\'s output is not always a number between 0 and 1, in particular when there is a high number of insertions. This value is often associated to the percentage of characters that were incorrectly predicted. The lower the value, the better the\nperformance of the ASR system with a CER of 0 being a perfect score.\n'

snake_case_ :  Optional[int]     =					'\nComputes CER score of transcribed segments against references.\nArgs:\n    references: list of references for each speech input.\n    predictions: list of transcribtions to score.\n    concatenate_texts: Whether or not to concatenate sentences before evaluation, set to True for more accurate result.\nReturns:\n    (float): the character error rate\n\nExamples:\n\n    >>> predictions = ["this is the prediction", "there is an other sample"]\n    >>> references = ["this is the reference", "there is another one"]\n    >>> cer = datasets.load_metric("cer")\n    >>> cer_score = cer.compute(predictions=predictions, references=references)\n    >>> print(cer_score)\n    0.34146341463414637\n'


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






   '''simple docstring'''







   def       UpperCAmelCase				(			self   ):

      '''simple docstring'''







      return datasets.MetricInfo(
          description=_DESCRIPTION ,   citation=_CITATION ,   inputs_description=_KWARGS_DESCRIPTION ,   features=datasets.Features(
              {
                  '''predictions''': datasets.Value('''string''' ,   id='''sequence'''   ),
                  '''references''': datasets.Value('''string''' ,   id='''sequence'''   ),
              }   ) ,   codebase_urls=['''https://github.com/jitsi/jiwer/'''] ,   reference_urls=[
              '''https://en.wikipedia.org/wiki/Word_error_rate''',
              '''https://sites.google.com/site/textdigitisation/qualitymeasures/computingerrorrates''',
          ] ,   )







   def       UpperCAmelCase				(			self ,   lowerCamelCase__ ,   lowerCamelCase__ ,   lowerCamelCase__=False   ):

      '''simple docstring'''







      if concatenate_texts:
         return jiwer.compute_measures(
             lowerCamelCase__ ,   lowerCamelCase__ ,   truth_transform=lowerCamelCase__ ,   hypothesis_transform=lowerCamelCase__ ,   )["wer"]

      UpperCamelCase       =  0
      UpperCamelCase       =  0
      for prediction, reference in zip(lowerCamelCase__ ,   lowerCamelCase__   ):
         UpperCamelCase       =  jiwer.compute_measures(
             lowerCamelCase__ ,   lowerCamelCase__ ,   truth_transform=lowerCamelCase__ ,   hypothesis_transform=lowerCamelCase__ ,   )
         incorrect += measures["substitutions"] + measures["deletions"] + measures["insertions"]
         total += measures["substitutions"] + measures["deletions"] + measures["hits"]

      return incorrect / total







'''simple docstring'''


import re
import string
from collections import Counter

import sacrebleu
import sacremoses
from packaging import version

import datasets


snake_case_ :  int     =					'\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'

snake_case_ :  Optional[int]     =					'\\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'


snake_case_ :  Optional[Any]     =					'\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  __snake_case     (    _UpperCAmelCase					:       Optional[Any]):

   def remove_articles(_UpperCAmelCase					:       str):
      UpperCamelCase       =  re.compile(R'''\b(a|an|the)\b''',      re.UNICODE)
      return re.sub(_UpperCAmelCase,      ''' ''',      _UpperCAmelCase)

   def white_space_fix(_UpperCAmelCase					:       Union[str, Any]):
      return " ".join(text.split())

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

   def lower(_UpperCAmelCase					:       List[str]):
      return text.lower()

   return white_space_fix(remove_articles(remove_punc(lower(_UpperCAmelCase))))



def  __snake_case     (    _UpperCAmelCase					:       Union[str, Any],      _UpperCAmelCase					:       List[str]):
   return int(normalize_answer(_UpperCAmelCase) == normalize_answer(_UpperCAmelCase))



def  __snake_case     (    _UpperCAmelCase					:       int,      _UpperCAmelCase					:       Optional[int]):
   UpperCamelCase       =  [any(compute_exact(_UpperCAmelCase,      _UpperCAmelCase) for ref in refs) for pred, refs in zip(_UpperCAmelCase,      _UpperCAmelCase)]
   return (sum(_UpperCAmelCase) / len(_UpperCAmelCase)) * 100



def  __snake_case     (    _UpperCAmelCase					:       Any,      _UpperCAmelCase					:       Optional[int],      _UpperCAmelCase					:       int,      _UpperCAmelCase					:       List[str]):
   UpperCamelCase       =  [rgram for rgrams in rgramslist for rgram in rgrams]
   UpperCamelCase       =  Counter(_UpperCAmelCase)

   UpperCamelCase       =  Counter(_UpperCAmelCase)
   UpperCamelCase       =  Counter()
   for sgram, scount in sgramcounter.items():
      UpperCamelCase       =  scount * numref

   UpperCamelCase       =  Counter(_UpperCAmelCase)
   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(_UpperCAmelCase) > 0:
      UpperCamelCase       =  keeptmpscorea / len(_UpperCAmelCase)
   if len(_UpperCAmelCase) > 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(_UpperCAmelCase) > 0:
      UpperCamelCase       =  deltmpscorea / len(_UpperCAmelCase)

   # ADDITION
   UpperCamelCase       =  set(_UpperCAmelCase) - set(_UpperCAmelCase)
   UpperCamelCase       =  set(_UpperCAmelCase) & set(_UpperCAmelCase)
   UpperCamelCase       =  set(_UpperCAmelCase) - set(_UpperCAmelCase)

   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(_UpperCAmelCase) > 0:
      UpperCamelCase       =  addtmpscore / len(_UpperCAmelCase)
   if len(_UpperCAmelCase) > 0:
      UpperCamelCase       =  addtmpscore / len(_UpperCAmelCase)
   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  __snake_case     (    _UpperCAmelCase					:       str,      _UpperCAmelCase					:       Tuple,      _UpperCAmelCase					:       str):
   UpperCamelCase       =  len(_UpperCAmelCase)

   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(_UpperCAmelCase)
      for i in range(0,      len(_UpperCAmelCase) - 1):
         if i < len(_UpperCAmelCase) - 1:
            UpperCamelCase       =  ragrams[i] + ''' ''' + ragrams[i + 1]
            ragrams.append(_UpperCAmelCase)
         if i < len(_UpperCAmelCase) - 2:
            UpperCamelCase       =  ragrams[i] + ''' ''' + ragrams[i + 1] + ''' ''' + ragrams[i + 2]
            ragrams.append(_UpperCAmelCase)
         if i < len(_UpperCAmelCase) - 3:
            UpperCamelCase       =  ragrams[i] + ''' ''' + ragrams[i + 1] + ''' ''' + ragrams[i + 2] + ''' ''' + ragrams[i + 3]
            ragrams.append(_UpperCAmelCase)
      ragramslist.append(_UpperCAmelCase)
      ragramslist.append(_UpperCAmelCase)
      ragramslist.append(_UpperCAmelCase)

   for i in range(0,      len(_UpperCAmelCase) - 1):
      if i < len(_UpperCAmelCase) - 1:
         UpperCamelCase       =  sagrams[i] + ''' ''' + sagrams[i + 1]
         sagrams.append(_UpperCAmelCase)
      if i < len(_UpperCAmelCase) - 2:
         UpperCamelCase       =  sagrams[i] + ''' ''' + sagrams[i + 1] + ''' ''' + sagrams[i + 2]
         sagrams.append(_UpperCAmelCase)
      if i < len(_UpperCAmelCase) - 3:
         UpperCamelCase       =  sagrams[i] + ''' ''' + sagrams[i + 1] + ''' ''' + sagrams[i + 2] + ''' ''' + sagrams[i + 3]
         sagrams.append(_UpperCAmelCase)

   for i in range(0,      len(_UpperCAmelCase) - 1):
      if i < len(_UpperCAmelCase) - 1:
         UpperCamelCase       =  cagrams[i] + ''' ''' + cagrams[i + 1]
         cagrams.append(_UpperCAmelCase)
      if i < len(_UpperCAmelCase) - 2:
         UpperCamelCase       =  cagrams[i] + ''' ''' + cagrams[i + 1] + ''' ''' + cagrams[i + 2]
         cagrams.append(_UpperCAmelCase)
      if i < len(_UpperCAmelCase) - 3:
         UpperCamelCase       =  cagrams[i] + ''' ''' + cagrams[i + 1] + ''' ''' + cagrams[i + 2] + ''' ''' + cagrams[i + 3]
         cagrams.append(_UpperCAmelCase)

   ((UpperCamelCase)     , (UpperCamelCase)     , (UpperCamelCase))       =  SARIngram(_UpperCAmelCase,      _UpperCAmelCase,      _UpperCAmelCase,      _UpperCAmelCase)
   ((UpperCamelCase)     , (UpperCamelCase)     , (UpperCamelCase))       =  SARIngram(_UpperCAmelCase,      _UpperCAmelCase,      _UpperCAmelCase,      _UpperCAmelCase)
   ((UpperCamelCase)     , (UpperCamelCase)     , (UpperCamelCase))       =  SARIngram(_UpperCAmelCase,      _UpperCAmelCase,      _UpperCAmelCase,      _UpperCAmelCase)
   ((UpperCamelCase)     , (UpperCamelCase)     , (UpperCamelCase))       =  SARIngram(_UpperCAmelCase,      _UpperCAmelCase,      _UpperCAmelCase,      _UpperCAmelCase)
   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  __snake_case     (    _UpperCAmelCase					:       List[str],      _UpperCAmelCase					:       bool = True,      _UpperCAmelCase					:       str = "13a",      _UpperCAmelCase					:       bool = True):
   # Normalization is requried for the ASSET dataset (one of the primary
   # datasets in sentence simplification) to allow using space
   # to split the sentence. Even though Wiki-Auto and TURK datasets,
   # do not require normalization, we do it for consistency.
   # Code adapted from the EASSE library [1] written by the authors of the ASSET dataset.
   # [1] https://github.com/feralvam/easse/blob/580bba7e1378fc8289c663f864e0487188fe8067/easse/utils/preprocessing.py#L7

   if lowercase:
      UpperCamelCase       =  sentence.lower()

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

   if not return_str:
      UpperCamelCase       =  normalized_sent.split()

   return normalized_sent



def  __snake_case     (    _UpperCAmelCase					:       Union[str, Any],      _UpperCAmelCase					:       List[Any],      _UpperCAmelCase					:       Optional[Any]):
   if not (len(_UpperCAmelCase) == len(_UpperCAmelCase) == len(_UpperCAmelCase)):
      raise ValueError('''Sources length must match predictions and references lengths.''')
   UpperCamelCase       =  0
   for src, pred, refs in zip(_UpperCAmelCase,      _UpperCAmelCase,      _UpperCAmelCase):
      sari_score += SARIsent(normalize(_UpperCAmelCase),      normalize(_UpperCAmelCase),      [normalize(_UpperCAmelCase) for sent in refs])
   UpperCamelCase       =  sari_score / len(_UpperCAmelCase)
   return 100 * sari_score



def  __snake_case     (    _UpperCAmelCase					:       str,      _UpperCAmelCase					:       Dict,      _UpperCAmelCase					:       Any="exp",      _UpperCAmelCase					:       str=None,      _UpperCAmelCase					:       Optional[Any]=False,      _UpperCAmelCase					:       Union[str, Any]=False,      _UpperCAmelCase					:       List[Any]=False,      ):
   UpperCamelCase       =  len(references[0])
   if any(len(_UpperCAmelCase) != 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(_UpperCAmelCase)]
   UpperCamelCase       =  sacrebleu.corpus_bleu(
       _UpperCAmelCase,      _UpperCAmelCase,      smooth_method=_UpperCAmelCase,      smooth_value=_UpperCAmelCase,      force=_UpperCAmelCase,      lowercase=_UpperCAmelCase,      use_effective_order=_UpperCAmelCase,      )
   return output.score


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






   '''simple docstring'''







   def       UpperCAmelCase				(			self   ):

      '''simple docstring'''







      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       UpperCAmelCase				(			self ,   lowerCamelCase__ ,   lowerCamelCase__ ,   lowerCamelCase__   ):

      '''simple docstring'''







      UpperCamelCase       =  {}
      result.update({'''sari''': compute_sari(sources=lowerCamelCase__ ,   predictions=lowerCamelCase__ ,   references=lowerCamelCase__   )}   )
      result.update({'''sacrebleu''': compute_sacrebleu(predictions=lowerCamelCase__ ,   references=lowerCamelCase__   )}   )
      result.update({'''exact''': compute_em(predictions=lowerCamelCase__ ,   references=lowerCamelCase__   )}   )
      return result





