code: 
  
  
  """simple docstring"""
  
  
  
  
  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)
  __magic_name__	:   Tuple          =							'\\n'
  
  __magic_name__	:   Any          =							'\\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'
  
  __magic_name__	:   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'
  
  __magic_name__	:   Tuple          =							['fleurs-asr', 'mls', 'voxpopuli', 'babel', 'covost2', 'fleurs-lang_id', 'minds14']
  __magic_name__	:   Dict          =							''
  
  try:
  					from jiwer import transforms as tr
  
  					__magic_name__	:   Union[str, Any]          =							True
  except ImportError:
  					__magic_name__	:   List[str]          =							False
  
  if _jiwer_available and version.parse(importlib_metadata.version('jiwer')) < version.parse('2.3.0'):
  
  
  
  
  					class  __snake_case      (tr.AbstractTransform     ):
  
  
  
  
  												def __init__(    self:						Union[str, Any]    ,       A_:						str = " "      ):
  															__lowerCamelCase        =			sentence_delimiter
  
  
  
  
  												def      __a      (    self:						Any    ,       A_:						str      ):
  															return list(A_      )
  
  
  
  
  												def      __a      (    self:						Union[str, Any]    ,       A_:						List[str]      ):
  															__lowerCamelCase        =			[]
  															for sent_idx, sentence in enumerate(A_      ):
  																		chars.extend(self.process_string(A_      )      )
  																		if self.sentence_delimiter is not None and self.sentence_delimiter != "" and sent_idx < len(A_      ) - 1:
  																					chars.append(self.sentence_delimiter      )
  															return chars
  
  					__magic_name__	:   List[Any]          =							tr.Compose(
  					    [tr.RemoveMultipleSpaces(), tr.Strip(), SentencesToListOfCharacters(SENTENCE_DELIMITER)]
  					)
  elif _jiwer_available:
  					__magic_name__	:   Tuple          =							tr.Compose(
  					    [
  					        tr.RemoveMultipleSpaces(),
  					        tr.Strip(),
  					        tr.ReduceToSingleSentence(SENTENCE_DELIMITER),
  					        tr.ReduceToListOfListOfChars(),
  					    ]
  					)
  else:
  					__magic_name__	:   Dict          =							None
  
  
  
  
  
  def 			a_   (  lowercase__   :str, lowercase__   :Union[str, Any]    ):
  			return float((preds == labels).mean()    )
  
  
  
  
  
  def 			a_   (  lowercase__   :Dict, lowercase__   :List[str]    ):
  			return {
  			    "f1": float(fa_score(y_true=lowercase__, y_pred=lowercase__, average="""macro"""    )    ),
  			    "accuracy": simple_accuracy(lowercase__, lowercase__    ),
  			}
  
  
  
  
  
  def 			a_   (  lowercase__   :str, lowercase__   :Optional[Any], lowercase__   :List[str]="exp", lowercase__   :Dict=None, lowercase__   :List[Any]=False, lowercase__   :List[Any]=False, lowercase__   :List[str]=None, lowercase__   :Any=False, ):
  			# xtreme-s can only have one label
  			__lowerCamelCase        =			[[label] for label in labels]
  			__lowerCamelCase        =			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        =			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        =			[[refs[i] for refs in labels] for i in range(lowercase__    )]
  			__lowerCamelCase        =			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 			a_   (  lowercase__   :Union[str, Any], lowercase__   :Union[str, Any], lowercase__   :Optional[int], lowercase__   :Tuple    ):
  			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        =			compute_measures(lowercase__, lowercase__    )["""wer"""]
  
  						__lowerCamelCase        =			compute_measures(lowercase__, lowercase__, truth_transform=lowercase__, hypothesis_transform=lowercase__    )["""wer"""]
  						return {"wer": wer, "cer": cer}
  			else:
  
  						def compute_score(lowercase__   :Optional[Any], lowercase__   :List[Any], lowercase__   :Dict="wer"    ):
  									__lowerCamelCase        =			0
  									__lowerCamelCase        =			0
  									for prediction, reference in zip(lowercase__, lowercase__    ):
  												if score_type == "wer":
  															__lowerCamelCase        =			compute_measures(lowercase__, lowercase__    )
  												elif score_type == "cer":
  															__lowerCamelCase        =			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  __snake_case      (datasets.Metric     ):
  
  
  
  
  							def      __a      (    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        =			"""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(A_      ), """references""": datasets.Value(A_      )}      )    ,       codebase_urls=[]    ,       reference_urls=[]    ,       format="""numpy"""    ,       )
  
  
  
  
  							def      __a      (    self:						List[Any]    ,       A_:						Any    ,       A_:						Any    ,       A_:						Tuple=None    ,       A_:						Optional[int]=None      ):
  										__lowerCamelCase        =			bleu_kwargs if bleu_kwargs is not None else {}
  										__lowerCamelCase        =			wer_kwargs if wer_kwargs is not None else {}
  
  										if self.config_name == "fleurs-lang_id":
  													return {"accuracy": simple_accuracy(A_    ,       A_      )}
  										elif self.config_name == "minds14":
  													return fa_and_simple_accuracy(A_    ,       A_      )
  										elif self.config_name == "covost2":
  													__lowerCamelCase        =			bleu_kwargs.pop("""smooth_method"""    ,       """exp"""      )
  													__lowerCamelCase        =			bleu_kwargs.pop("""smooth_value"""    ,       A_      )
  													__lowerCamelCase        =			bleu_kwargs.pop("""force"""    ,       A_      )
  													__lowerCamelCase        =			bleu_kwargs.pop("""lowercase"""    ,       A_      )
  													__lowerCamelCase        =			bleu_kwargs.pop("""tokenize"""    ,       A_      )
  													__lowerCamelCase        =			bleu_kwargs.pop("""use_effective_order"""    ,       A_      )
  													return bleu(
  													    preds=A_    ,       labels=A_    ,       smooth_method=A_    ,       smooth_value=A_    ,       force=A_    ,       lowercase=A_    ,       tokenize=A_    ,       use_effective_order=A_    ,       )
  										elif self.config_name in ["fleurs-asr", "mls", "voxpopuli", "babel"]:
  													__lowerCamelCase        =			wer_kwargs.pop("""concatenate_texts"""    ,       A_      )
  													return wer_and_cer(A_    ,       A_    ,       A_    ,       self.config_name      )
  										else:
  													raise KeyError(f'You should supply a configuration name selected in {_CONFIG_NAMES}'      )
  
  
  
  
  
style_context: 
  
  
  """simple docstring"""
  
  
  
  
  from __future__ import annotations
  
  import re
  
  
  
  
  
  def 			a_   (  lowercase__   :list[str]    ):
  
  			def alphanum_key(lowercase__   :int    ):
  						return [int(lowercase__    ) if s.isdigit() else s.lower() for s in re.split("""([0-9]+)""", lowercase__    )]
  
  			return sorted(lowercase__, key=lowercase__    )
  
  
  if __name__ == "__main__":
  					import doctest
  
  					doctest.testmod()
  
  
  
  
  