





from typing import List

from packaging import version
from sklearn.metrics import fa_score

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


# TODO(Patrick/Anton)
__UpperCAmelCase						=      '\\n'

__UpperCAmelCase						=      '\\n    XTREME-S is a benchmark to evaluate universal cross-lingual speech representations in many languages.\n    XTREME-S covers four task families: speech recognition, classification, speech-to-text translation and retrieval.\n'

__UpperCAmelCase						=      '\nCompute XTREME-S evaluation metric associated to each XTREME-S dataset.\nArgs:\n    predictions: list of predictions to score.\n        Each translation should be tokenized into a list of tokens.\n    references: list of lists of references for each translation.\n        Each reference should be tokenized into a list of tokens.\n    bleu_kwargs: optional dict of keywords to be passed when computing \'bleu\'.\n        Keywords include Dict can be one of \'smooth_method\', \'smooth_value\', \'force\', \'lowercase\',\n        \'tokenize\', \'use_effective_order\'.\n    wer_kwargs: optional dict of keywords to be passed when computing \'wer\' and \'cer\'.\n        Keywords include \'concatenate_texts\'.\nReturns: depending on the XTREME-S task, one or several of:\n    \"accuracy\": Accuracy - for \'fleurs-lang_id\', \'minds14\'\n    \"f1\": F1 score - for \'minds14\'\n    \"wer\": Word error rate - for \'mls\', \'fleurs-asr\', \'voxpopuli\', \'babel\'\n    \"cer\": Character error rate - for \'mls\', \'fleurs-asr\', \'voxpopuli\', \'babel\'\n    \"bleu\": BLEU score according to the `sacrebleu` metric - for \'covost2\'\nExamples:\n\n    >>> xtreme_s_metric = datasets.load_metric(\'xtreme_s\', \'mls\')  # \'mls\', \'voxpopuli\', \'fleurs-asr\' or \'babel\'\n    >>> references = [\"it is sunny here\", \"paper and pen are essentials\"]\n    >>> predictions = [\"it\'s sunny\", \"paper pen are essential\"]\n    >>> results = xtreme_s_metric.compute(predictions=predictions, references=references)\n    >>> print({k: round(v, 2) for k, v in results.items()})\n    {\'wer\': 0.56, \'cer\': 0.27}\n\n    >>> xtreme_s_metric = datasets.load_metric(\'xtreme_s\', \'covost2\')\n    >>> references = [\"bonjour paris\", \"il est necessaire de faire du sport de temps en temp\"]\n    >>> predictions = [\"bonjour paris\", \"il est important de faire du sport souvent\"]\n    >>> results = xtreme_s_metric.compute(predictions=predictions, references=references)\n    >>> print({k: round(v, 2) for k, v in results.items()})\n    {\'bleu\': 31.65}\n\n    >>> xtreme_s_metric = datasets.load_metric(\'xtreme_s\', \'fleurs-lang_id\')\n    >>> references = [0, 1, 0, 0, 1]\n    >>> predictions = [0, 1, 1, 0, 0]\n    >>> results = xtreme_s_metric.compute(predictions=predictions, references=references)\n    >>> print({k: round(v, 2) for k, v in results.items()})\n    {\'accuracy\': 0.6}\n\n    >>> xtreme_s_metric = datasets.load_metric(\'xtreme_s\', \'minds14\')\n    >>> references = [0, 1, 0, 0, 1]\n    >>> predictions = [0, 1, 1, 0, 0]\n    >>> results = xtreme_s_metric.compute(predictions=predictions, references=references)\n    >>> print({k: round(v, 2) for k, v in results.items()})\n    {\'f1\': 0.58, \'accuracy\': 0.6}\n'

__UpperCAmelCase						=      ['fleurs-asr', 'mls', 'voxpopuli', 'babel', 'covost2', 'fleurs-lang_id', 'minds14']
__UpperCAmelCase						=      ''

try:
  from jiwer import transforms as tr

  __UpperCAmelCase						=      True
except ImportError:
  __UpperCAmelCase						=      False

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

  class 		__a							(	tr.AbstractTransform      ):



         def __init__(     self	:   Dict					,			UpperCAmelCase	:   Union[str, Any] = " "			):
             lowerCAmelCase_					:	Tuple						=   sentence_delimiter



         def  A							(     self	:   Optional[Any]					,			UpperCAmelCase	:   Dict			):
             return list(lowercase_			)



         def  A							(     self	:   Optional[Any]					,			UpperCAmelCase	:   Dict			):
             lowerCAmelCase_					:	List[Any]						=   []
             for sent_idx, sentence in enumerate(lowercase_			):
                 chars.extend(self.process_string(lowercase_			)			)
                 if self.sentence_delimiter is not None and self.sentence_delimiter != "" and sent_idx < len(lowercase_			) - 1:
                     chars.append(self.sentence_delimiter			)
             return chars






  __UpperCAmelCase						=      tr.Compose(
      [tr.RemoveMultipleSpaces(), tr.Strip(), SentencesToListOfCharacters(SENTENCE_DELIMITER)]
  )
elif _jiwer_available:
  __UpperCAmelCase						=      tr.Compose(
      [
          tr.RemoveMultipleSpaces(),
          tr.Strip(),
          tr.ReduceToSingleSentence(SENTENCE_DELIMITER),
          tr.ReduceToListOfListOfChars(),
      ]
  )
else:
  __UpperCAmelCase						=      None
def 			__UpperCamelCase				(			lowercase__	:       str		,    lowercase__	:       List[Any]		)	->      int:
    '''simple docstring'''





    return float((preds == labels).mean()		)
def 			__UpperCamelCase				(			lowercase__	:       int		,    lowercase__	:       Union[str, Any]		)	->      Optional[Any]:
    '''simple docstring'''





    return {
        "f1": float(fa_score(y_true=lowercase_		,    y_pred=lowercase_		,    average="""macro"""		)		),
        "accuracy": simple_accuracy(lowercase_		,    lowercase_		),
    }
def 			__UpperCamelCase				(			lowercase__	:       Tuple		,    lowercase__	:       Union[str, Any]		,    lowercase__	:       str="exp"		,    lowercase__	:       Optional[int]=None		,    lowercase__	:       Optional[Any]=False		,    lowercase__	:       Optional[int]=False		,    lowercase__	:       Dict=None		,    lowercase__	:       str=False		,    )	->      Any:
    '''simple docstring'''





    lowerCAmelCase_					:	Optional[Any]						=   [[label] for label in labels]
    lowerCAmelCase_					:	List[Any]						=   list(lowercase_		)
    try:
        import sacrebleu as scb
    except ImportError:
        raise ValueError(
            """sacrebleu has to be installed in order to apply the bleu metric for covost2."""
            """You can install it via `pip install sacrebleu`."""		)

    if version.parse(scb.__version__		) < version.parse("""1.4.12"""		):
        raise ImportWarning(
            """To use `sacrebleu`, the module `sacrebleu>=1.4.12` is required, and the current version of `sacrebleu` doesn\'t match this condition.\n"""
            """You can install it with `pip install \"sacrebleu>=1.4.12\"`."""		)

    lowerCAmelCase_					:	Optional[int]						=   len(labels[0]		)
    if any(len(lowercase_		) != references_per_prediction for refs in labels		):
        raise ValueError("""Sacrebleu requires the same number of references for each prediction"""		)
    lowerCAmelCase_					:	List[str]						=   [[refs[i] for refs in labels] for i in range(lowercase_		)]
    lowerCAmelCase_					:	int						=   scb.corpus_bleu(
        lowercase_		,    lowercase_		,    smooth_method=lowercase_		,    smooth_value=lowercase_		,    force=lowercase_		,    lowercase=lowercase_		,    use_effective_order=lowercase_		,    **({"""tokenize""": tokenize} if tokenize else {})		,    )
    return {"bleu": output.score}
def 			__UpperCamelCase				(			lowercase__	:       Tuple		,    lowercase__	:       List[str]		,    lowercase__	:       str		,    lowercase__	:       Tuple		)	->      str:
    '''simple docstring'''





    try:
        from jiwer import compute_measures
    except ImportError:
        raise ValueError(
            f'jiwer has to be installed in order to apply the wer metric for {config_name}.'
            """You can install it via `pip install jiwer`."""		)

    if concatenate_texts:
        lowerCAmelCase_					:	Any						=   compute_measures(lowercase_		,    lowercase_		)['''wer''']

        lowerCAmelCase_					:	Tuple						=   compute_measures(lowercase_		,    lowercase_		,    truth_transform=lowercase_		,    hypothesis_transform=lowercase_		)['''wer''']
        return {"wer": wer, "cer": cer}
    else:

        def compute_score(lowercase__	:       Any		,    lowercase__	:       Union[str, Any]		,    lowercase__	:       Any="wer"		):
            lowerCAmelCase_					:	List[Any]						=   0
            lowerCAmelCase_					:	Union[str, Any]						=   0
            for prediction, reference in zip(lowercase_		,    lowercase_		):
                if score_type == "wer":
                    lowerCAmelCase_					:	Optional[int]						=   compute_measures(lowercase_		,    lowercase_		)
                elif score_type == "cer":
                    lowerCAmelCase_					:	Any						=   compute_measures(
                        lowercase_		,    lowercase_		,    truth_transform=lowercase_		,    hypothesis_transform=lowercase_		)
                incorrect += measures["substitutions"] + measures["deletions"] + measures["insertions"]
                total += measures["substitutions"] + measures["deletions"] + measures["hits"]
            return incorrect / total

        return {"wer": compute_score(lowercase_		,    lowercase_		,    """wer"""		), "cer": compute_score(lowercase_		,    lowercase_		,    """cer"""		)}

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



       def  A							(     self	:   Optional[Any]			):

           if self.config_name not in _CONFIG_NAMES:
               raise KeyError(F'You should supply a configuration name selected in {_CONFIG_NAMES}'			)

           lowerCAmelCase_					:	int						=   '''int64''' if self.config_name in ['''fleurs-lang_id''', '''minds14'''] else '''string'''

           return datasets.MetricInfo(
               description=_DESCRIPTION					,			citation=_CITATION					,			inputs_description=_KWARGS_DESCRIPTION					,			features=datasets.Features(
                   {"""predictions""": datasets.Value(lowercase_			), """references""": datasets.Value(lowercase_			)}			)					,			codebase_urls=[]					,			reference_urls=[]					,			format="""numpy"""					,			)



       def  A							(     self	:   List[Any]					,			UpperCAmelCase	:   List[str]					,			UpperCAmelCase	:   Tuple					,			UpperCAmelCase	:   Any=None					,			UpperCAmelCase	:   Tuple=None			):
           lowerCAmelCase_					:	List[str]						=   bleu_kwargs if bleu_kwargs is not None else {}
           lowerCAmelCase_					:	str						=   wer_kwargs if wer_kwargs is not None else {}

           if self.config_name == "fleurs-lang_id":
               return {"accuracy": simple_accuracy(lowercase_					,			lowercase_			)}
           elif self.config_name == "minds14":
               return fa_and_simple_accuracy(lowercase_					,			lowercase_			)
           elif self.config_name == "covost2":
               lowerCAmelCase_					:	Tuple						=   bleu_kwargs.pop("""smooth_method"""					,			"""exp"""			)
               lowerCAmelCase_					:	List[Any]						=   bleu_kwargs.pop("""smooth_value"""					,			lowercase_			)
               lowerCAmelCase_					:	int						=   bleu_kwargs.pop("""force"""					,			lowercase_			)
               lowerCAmelCase_					:	List[Any]						=   bleu_kwargs.pop("""lowercase"""					,			lowercase_			)
               lowerCAmelCase_					:	List[str]						=   bleu_kwargs.pop("""tokenize"""					,			lowercase_			)
               lowerCAmelCase_					:	Tuple						=   bleu_kwargs.pop("""use_effective_order"""					,			lowercase_			)
               return bleu(
                   preds=lowercase_					,			labels=lowercase_					,			smooth_method=lowercase_					,			smooth_value=lowercase_					,			force=lowercase_					,			lowercase=lowercase_					,			tokenize=lowercase_					,			use_effective_order=lowercase_					,			)
           elif self.config_name in ["fleurs-asr", "mls", "voxpopuli", "babel"]:
               lowerCAmelCase_					:	Any						=   wer_kwargs.pop("""concatenate_texts"""					,			lowercase_			)
               return wer_and_cer(lowercase_					,			lowercase_					,			lowercase_					,			self.config_name			)
           else:
               raise KeyError(F'You should supply a configuration name selected in {_CONFIG_NAMES}'			)











import math
def 			__UpperCamelCase				(			lowercase__	:       int		)	->      list:
    '''simple docstring'''





    if n <= 0:
        raise ValueError("""Only positive integers have prime factors"""		)
    lowerCAmelCase_					:	str						=   []
    while n % 2 == 0:
        pf.append(2		)
        lowerCAmelCase_					:	str						=   int(n / 2		)
    for i in range(3		,    int(math.sqrt(lowercase__		)		) + 1		,    2		):
        while n % i == 0:
            pf.append(lowercase__		)
            lowerCAmelCase_					:	List[Any]						=   int(n / i		)
    if n > 2:
        pf.append(lowercase__		)
    return pf
def 			__UpperCamelCase				(			lowercase__	:       int		)	->      int:
    '''simple docstring'''





    if n <= 0:
        raise ValueError("""Only positive numbers are accepted"""		)
    lowerCAmelCase_					:	Union[str, Any]						=   1
    lowerCAmelCase_					:	str						=   1
    while n % 2 == 0:
        temp += 1
        lowerCAmelCase_					:	Optional[Any]						=   int(n / 2		)
    div *= temp
    for i in range(3		,    int(math.sqrt(lowercase__		)		) + 1		,    2		):
        lowerCAmelCase_					:	Tuple						=   1
        while n % i == 0:
            temp += 1
            lowerCAmelCase_					:	Any						=   int(n / i		)
        div *= temp
    if n > 1:
        div *= 2
    return div
def 			__UpperCamelCase				(			lowercase__	:       int		)	->      int:
    '''simple docstring'''





    if n <= 0:
        raise ValueError("""Only positive numbers are accepted"""		)
    lowerCAmelCase_					:	Tuple						=   1
    lowerCAmelCase_					:	str						=   1
    while n % 2 == 0:
        temp += 1
        lowerCAmelCase_					:	Optional[int]						=   int(n / 2		)
    if temp > 1:
        s *= (2**temp - 1) / (2 - 1)
    for i in range(3		,    int(math.sqrt(lowercase__		)		) + 1		,    2		):
        lowerCAmelCase_					:	int						=   1
        while n % i == 0:
            temp += 1
            lowerCAmelCase_					:	Any						=   int(n / i		)
        if temp > 1:
            s *= (i**temp - 1) / (i - 1)
    return int(lowercase__		)
def 			__UpperCamelCase				(			lowercase__	:       int		)	->      int:
    '''simple docstring'''





    lowerCAmelCase_					:	str						=   n
    for x in set(prime_factors(lowercase__		)		):
        s *= (x - 1) / x
    return int(lowercase__		)


if __name__ == "__main__":
  import doctest

  doctest.testmod()


