




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)
SCREAMING_SNAKE_CASE__ :   Any						=     '\\n'

SCREAMING_SNAKE_CASE__ :   List[str]						=     '\\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'

SCREAMING_SNAKE_CASE__ :   Optional[Any]						=     '\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'

SCREAMING_SNAKE_CASE__ :   Tuple						=     ['fleurs-asr', 'mls', 'voxpopuli', 'babel', 'covost2', 'fleurs-lang_id', 'minds14']
SCREAMING_SNAKE_CASE__ :   Any						=     ''

try:
       from jiwer import transforms as tr

       SCREAMING_SNAKE_CASE__ :   str						=     True
except ImportError:
       SCREAMING_SNAKE_CASE__ :   int						=     False

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




       class 	UpperCamelCase__			(tr.AbstractTransform  ):

           '''simple docstring'''



           def __init__(					self  ,						UpperCamelCase__ = " "  )  ->   Optional[int]:
                  lowerCamelCase     :   int    				=      sentence_delimiter







           def 					_lowercase  (					self  ,						UpperCamelCase__  )  ->   List[str]:
                  return list(UpperCamelCase__  )







           def 					_lowercase  (					self  ,						UpperCamelCase__  )  ->   Union[str, Any]:
                  lowerCamelCase     :   List[Any]    				=      []
                  for sent_idx, sentence in enumerate(UpperCamelCase__  ):
                         chars.extend(self.process_string(UpperCamelCase__  )  )
                         if self.sentence_delimiter is not None and self.sentence_delimiter != "" and sent_idx < len(UpperCamelCase__  ) - 1:
                                chars.append(self.sentence_delimiter  )
                  return chars




       SCREAMING_SNAKE_CASE__ :   Tuple						=     tr.Compose(
           [tr.RemoveMultipleSpaces(), tr.Strip(), SentencesToListOfCharacters(SENTENCE_DELIMITER)]
       )
elif _jiwer_available:
       SCREAMING_SNAKE_CASE__ :   str						=     tr.Compose(
           [
               tr.RemoveMultipleSpaces(),
               tr.Strip(),
               tr.ReduceToSingleSentence(SENTENCE_DELIMITER),
               tr.ReduceToListOfListOfChars(),
           ]
       )
else:
       SCREAMING_SNAKE_CASE__ :   Any						=     None

def   A   (   _SCREAMING_SNAKE_CASE				,_SCREAMING_SNAKE_CASE					)			->				Tuple:
       return float((preds == labels).mean()					)

def   A   (   _SCREAMING_SNAKE_CASE				,_SCREAMING_SNAKE_CASE					)			->				str:
       return {
           "f1": float(fa_score(y_true=_SCREAMING_SNAKE_CASE				,y_pred=_SCREAMING_SNAKE_CASE				,average="macro"					)					),
           "accuracy": simple_accuracy(_SCREAMING_SNAKE_CASE				,_SCREAMING_SNAKE_CASE					),
       }

def   A   (   _SCREAMING_SNAKE_CASE				,_SCREAMING_SNAKE_CASE				,_SCREAMING_SNAKE_CASE="exp"				,_SCREAMING_SNAKE_CASE=None				,_SCREAMING_SNAKE_CASE=False				,_SCREAMING_SNAKE_CASE=False				,_SCREAMING_SNAKE_CASE=None				,_SCREAMING_SNAKE_CASE=False				,)			->				int:
       # xtreme-s can only have one label
       lowerCamelCase     :   List[Any]    				=      [[label] for label in labels]
       lowerCamelCase     :   List[str]    				=      list(_SCREAMING_SNAKE_CASE					)
       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(_SCREAMING_SNAKE_CASE					) != references_per_prediction for refs in labels					):
              raise ValueError("Sacrebleu requires the same number of references for each prediction"					)
       lowerCamelCase     :   int    				=      [[refs[i] for refs in labels] for i in range(_SCREAMING_SNAKE_CASE					)]
       lowerCamelCase     :   Optional[Any]    				=      scb.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				,**({"tokenize": tokenize} if tokenize else {})				,)
       return {"bleu": output.score}

def   A   (   _SCREAMING_SNAKE_CASE				,_SCREAMING_SNAKE_CASE				,_SCREAMING_SNAKE_CASE				,_SCREAMING_SNAKE_CASE					)			->				str:
       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     :   List[Any]    				=      compute_measures(_SCREAMING_SNAKE_CASE				,_SCREAMING_SNAKE_CASE					)["wer"]

              lowerCamelCase     :   Optional[int]    				=      compute_measures(_SCREAMING_SNAKE_CASE				,_SCREAMING_SNAKE_CASE				,truth_transform=_SCREAMING_SNAKE_CASE				,hypothesis_transform=_SCREAMING_SNAKE_CASE					)["wer"]
              return {"wer": wer, "cer": cer}
       else:

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

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




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

    '''simple docstring'''



    def 					_lowercase  (					self  )  ->   Union[str, Any]:
           if self.config_name not in _CONFIG_NAMES:
                  raise KeyError(F'''You should supply a configuration name selected in {_CONFIG_NAMES}'''  )

           lowerCamelCase     :   Union[str, Any]    				=      "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(UpperCamelCase__  ), "references": datasets.Value(UpperCamelCase__  )}  )  ,						codebase_urls=[]  ,						reference_urls=[]  ,						format="numpy"  ,						)







    def 					_lowercase  (					self  ,						UpperCamelCase__  ,						UpperCamelCase__  ,						UpperCamelCase__=None  ,						UpperCamelCase__=None  )  ->   List[str]:
           lowerCamelCase     :   Any    				=      bleu_kwargs if bleu_kwargs is not None else {}
           lowerCamelCase     :   int    				=      wer_kwargs if wer_kwargs is not None else {}

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












from __future__ import annotations

def   A   (   _SCREAMING_SNAKE_CASE					)			->				list[int]:
       assert (
           isinstance(_SCREAMING_SNAKE_CASE				,_SCREAMING_SNAKE_CASE					) and mask > 0
       ), f'''mask needs to be positive integer, your input {mask}'''
       lowerCamelCase     :   str    				=      []
       lowerCamelCase     :   Any    				=      mask

       while submask:
              all_submasks.append(_SCREAMING_SNAKE_CASE					)
              lowerCamelCase     :   Union[str, Any]    				=      (submask - 1) & mask

       return all_submasks


if __name__ == "__main__":
       import doctest

       doctest.testmod()






