


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      			=  """\
"""

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

__UpperCAmelCase      			=  """
Compute XTREME-S evaluation metric associated to each XTREME-S dataset.
Args:
    predictions: list of predictions to score.
        Each translation should be tokenized into a list of tokens.
    references: list of lists of references for each translation.
        Each reference should be tokenized into a list of tokens.
    bleu_kwargs: optional dict of keywords to be passed when computing 'bleu'.
        Keywords include Dict can be one of 'smooth_method', 'smooth_value', 'force', 'lowercase',
        'tokenize', 'use_effective_order'.
    wer_kwargs: optional dict of keywords to be passed when computing 'wer' and 'cer'.
        Keywords include 'concatenate_texts'.
Returns: depending on the XTREME-S task, one or several of:
    \"accuracy\": Accuracy - for 'fleurs-lang_id', 'minds14'
    \"f1\": F1 score - for 'minds14'
    \"wer\": Word error rate - for 'mls', 'fleurs-asr', 'voxpopuli', 'babel'
    \"cer\": Character error rate - for 'mls', 'fleurs-asr', 'voxpopuli', 'babel'
    \"bleu\": BLEU score according to the `sacrebleu` metric - for 'covost2'
Examples:

    >>> xtreme_s_metric = datasets.load_metric('xtreme_s', 'mls')  # 'mls', 'voxpopuli', 'fleurs-asr' or 'babel'
    >>> references = [\"it is sunny here\", \"paper and pen are essentials\"]
    >>> predictions = [\"it's sunny\", \"paper pen are essential\"]
    >>> results = xtreme_s_metric.compute(predictions=predictions, references=references)
    >>> print({k: round(v, 2) for k, v in results.items()})
    {'wer': 0.56, 'cer': 0.27}

    >>> xtreme_s_metric = datasets.load_metric('xtreme_s', 'covost2')
    >>> references = [\"bonjour paris\", \"il est necessaire de faire du sport de temps en temp\"]
    >>> predictions = [\"bonjour paris\", \"il est important de faire du sport souvent\"]
    >>> results = xtreme_s_metric.compute(predictions=predictions, references=references)
    >>> print({k: round(v, 2) for k, v in results.items()})
    {'bleu': 31.65}

    >>> xtreme_s_metric = datasets.load_metric('xtreme_s', 'fleurs-lang_id')
    >>> references = [0, 1, 0, 0, 1]
    >>> predictions = [0, 1, 1, 0, 0]
    >>> results = xtreme_s_metric.compute(predictions=predictions, references=references)
    >>> print({k: round(v, 2) for k, v in results.items()})
    {'accuracy': 0.6}

    >>> xtreme_s_metric = datasets.load_metric('xtreme_s', 'minds14')
    >>> references = [0, 1, 0, 0, 1]
    >>> predictions = [0, 1, 1, 0, 0]
    >>> results = xtreme_s_metric.compute(predictions=predictions, references=references)
    >>> print({k: round(v, 2) for k, v in results.items()})
    {'f1': 0.58, 'accuracy': 0.6}
"""

__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 							lowercase__(						tr.AbstractTransform			):






           '''simple docstring'''







           def __init__(		self   ,			__SCREAMING_SNAKE_CASE = " ")					->						Any:







              """simple docstring"""







              UpperCamelCase__ :			Optional[Any] 						=sentence_delimiter




           def    UpperCAmelCase							(		self   ,			__SCREAMING_SNAKE_CASE)					->						Union[str, Any]:







              """simple docstring"""







              return list(__SCREAMING_SNAKE_CASE)




           def    UpperCAmelCase							(		self   ,			__SCREAMING_SNAKE_CASE)					->						Dict:







              """simple docstring"""







              UpperCamelCase__ :			int 						=[]
              for sent_idx, sentence in enumerate(__SCREAMING_SNAKE_CASE):
                 chars.extend(self.process_string(__SCREAMING_SNAKE_CASE))
                 if self.sentence_delimiter is not None and self.sentence_delimiter != "" and sent_idx < len(__SCREAMING_SNAKE_CASE) - 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 	_lowerCamelCase  (		A_  :	Dict							,  A_  :	Optional[int]      )			->			List[Any]:

   '''simple docstring'''






   return float((preds == labels).mean()      )
def 	_lowerCamelCase  (		A_  :	Dict							,  A_  :	List[Any]      )			->			Dict:

   '''simple docstring'''






   return {
       "f1": float(fa_score(y_true=A_							,  y_pred=A_							,  average="macro"      )      ),
       "accuracy": simple_accuracy(A_							,  A_      ),
   }
def 	_lowerCamelCase  (		A_  :	int							,  A_  :	List[Any]							,  A_  :	Tuple="exp"							,  A_  :	Optional[Any]=None							,  A_  :	Any=False							,  A_  :	Optional[Any]=False							,  A_  :	int=None							,  A_  :	Optional[int]=False							,  )			->			List[str]:

   '''simple docstring'''






   UpperCamelCase__ :			Optional[Any] 						=[[label] for label in labels]
   UpperCamelCase__ :			Dict 						=list(A_      )
   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\"`."      )

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

   '''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:
      UpperCamelCase__ :			int 						=compute_measures(A_							,  A_      )["wer"]

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

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

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



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






      '''simple docstring'''







      def    UpperCAmelCase							(		self)					->						int:







         """simple docstring"""







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

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




      def    UpperCAmelCase							(		self   ,			__SCREAMING_SNAKE_CASE   ,			__SCREAMING_SNAKE_CASE   ,			__SCREAMING_SNAKE_CASE=None   ,			__SCREAMING_SNAKE_CASE=None)					->						Union[str, Any]:







         """simple docstring"""







         UpperCamelCase__ :			List[str] 						=bleu_kwargs if bleu_kwargs is not None else {}
         UpperCamelCase__ :			Optional[Any] 						=wer_kwargs if wer_kwargs is not None else {}

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





def 	_lowerCamelCase  (		A_  :	Union[str, Any]							,  A_  :	Optional[int]      )			->			Dict:

   '''simple docstring'''






   if len(str(A_      )      ) == 1 or len(str(A_      )      ) == 1:
      return a * b

   UpperCamelCase__ :			Any 						=max(len(str(A_      )      )							,  len(str(A_      )      )      )
   UpperCamelCase__ :			Optional[int] 						=ma // 2

   UpperCamelCase__						,	UpperCamelCase__ :			Dict 						=divmod(A_							,  1_0**ma      )
   UpperCamelCase__						,	UpperCamelCase__ :			Union[str, Any] 						=divmod(A_							,  1_0**ma      )

   UpperCamelCase__ :			List[Any] 						=karatsuba(A_							,  A_      )
   UpperCamelCase__ :			Dict 						=karatsuba((aa + aa)							,  (ba + ba)      )
   UpperCamelCase__ :			Optional[int] 						=karatsuba(A_							,  A_      )

   return (z * 1_0 ** (2 * ma)) + ((y - z - x) * 1_0 ** (ma)) + (x)
def 	_lowerCamelCase  (		)			->			Any:

   '''simple docstring'''






   print(karatsuba(1_5_4_6_3							,  2_3_4_8_9      )      )


if __name__ == "__main__":
     main()

