code: 
  
  
  
  
  
  
  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)
  __A  							=  "\\n"
  
  __A  							=  "\\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"
  
  __A  							=  "\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"
  
  __A  							=  ["fleurs-asr", "mls", "voxpopuli", "babel", "covost2", "fleurs-lang_id", "minds14"]
  __A  							=  ""
  
  try:
     from jiwer import transforms as tr
  
     __A  							=  True
  except ImportError:
     __A  							=  False
  
  if _jiwer_available and version.parse(importlib_metadata.version("jiwer")) < version.parse("2.3.0"):
  
  
  
     class 							_A (    tr.AbstractTransform							):
         """simple docstring"""
  
         def __init__(							self			:    List[str]   ,    __SCREAMING_SNAKE_CASE			:    Optional[int] = " "			)			->       int:
                __UpperCAmelCase    							=sentence_delimiter
  
  
  
         def _a       (							self			:    Tuple   ,    __SCREAMING_SNAKE_CASE			:    Tuple			)			->       str:
                return list(SCREAMING_SNAKE_CASE_			)
  
  
  
         def _a       (							self			:    Union[str, Any]   ,    __SCREAMING_SNAKE_CASE			:    int			)			->       List[Any]:
                __UpperCAmelCase    							=[]
                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
  
  
  
  
     __A  							=  tr.Compose(
         [tr.RemoveMultipleSpaces(), tr.Strip(), SentencesToListOfCharacters(SENTENCE_DELIMITER)]
     )
  elif _jiwer_available:
     __A  							=  tr.Compose(
         [
             tr.RemoveMultipleSpaces(),
             tr.Strip(),
             tr.ReduceToSingleSentence(SENTENCE_DELIMITER),
             tr.ReduceToListOfListOfChars(),
         ]
     )
  else:
     __A  							=  None
  
  
  
  
  
  
  
  def 			lowercase__  (				A_:	Optional[Any]     ,			A_:	Dict		)  ->							Optional[Any]:
  
  
  
  
  
  
  
         """simple docstring"""
  
  
  
  
  
  
         return float((preds == labels).mean()		)
  
  
  
  
  
  
  
  def 			lowercase__  (				A_:	Any     ,			A_:	Optional[int]		)  ->							List[Any]:
  
  
  
  
  
  
  
         """simple docstring"""
  
  
  
  
  
  
         return {
             "f1": float(fa_score(y_true=snake_case__     ,			y_pred=snake_case__     ,			average="""macro"""		)		),
             "accuracy": simple_accuracy(snake_case__     ,			snake_case__		),
         }
  
  
  
  
  
  
  
  def 			lowercase__  (				A_:	Dict     ,			A_:	Dict     ,			A_:	List[str]="exp"     ,			A_:	Optional[int]=None     ,			A_:	Dict=False     ,			A_:	List[str]=False     ,			A_:	Any=None     ,			A_:	List[Any]=False     ,			)  ->							str:
  
  
  
  
  
  
  
         """simple docstring"""
  
  
  
  
  
  
         __UpperCAmelCase    							=[[label] for label in labels]
         __UpperCAmelCase    							=list(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\"`."""		)
  
         __UpperCAmelCase    							=len(labels[0]		)
         if any(len(snake_case__		) != references_per_prediction for refs in labels		):
                raise ValueError("""Sacrebleu requires the same number of references for each prediction"""		)
         __UpperCAmelCase    							=[[refs[i] for refs in labels] for i in range(snake_case__		)]
         __UpperCAmelCase    							=scb.corpus_bleu(
             snake_case__     ,			snake_case__     ,			smooth_method=snake_case__     ,			smooth_value=snake_case__     ,			force=snake_case__     ,			lowercase=snake_case__     ,			use_effective_order=snake_case__     ,			**({"""tokenize""": tokenize} if tokenize else {})     ,			)
         return {"bleu": output.score}
  
  
  
  
  
  
  
  def 			lowercase__  (				A_:	Tuple     ,			A_:	List[str]     ,			A_:	Optional[int]     ,			A_:	Any		)  ->							Dict:
  
  
  
  
  
  
  
         """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    							=compute_measures(snake_case__     ,			snake_case__		)['wer']
  
                __UpperCAmelCase    							=compute_measures(snake_case__     ,			snake_case__     ,			truth_transform=snake_case__     ,			hypothesis_transform=snake_case__		)['wer']
                return {"wer": wer, "cer": cer}
         else:
  
                def compute_score(A_:	Optional[int]     ,			A_:	Union[str, Any]     ,			A_:	Any="wer"		):
                       __UpperCAmelCase    							=0
                       __UpperCAmelCase    							=0
                       for prediction, reference in zip(snake_case__     ,			snake_case__		):
                              if score_type == "wer":
                                     __UpperCAmelCase    							=compute_measures(snake_case__     ,			snake_case__		)
                              elif score_type == "cer":
                                     __UpperCAmelCase    							=compute_measures(
                                         snake_case__     ,			snake_case__     ,			truth_transform=snake_case__     ,			hypothesis_transform=snake_case__		)
                              incorrect += measures["substitutions"] + measures["deletions"] + measures["insertions"]
                              total += measures["substitutions"] + measures["deletions"] + measures["hits"]
                       return incorrect / total
  
                return {"wer": compute_score(snake_case__     ,			snake_case__     ,			"""wer"""		), "cer": compute_score(snake_case__     ,			snake_case__     ,			"""cer"""		)}
  
  
  
  
  
  @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION				,				_KWARGS_DESCRIPTION							)
  class 							_A (    datasets.Metric							):
      """simple docstring"""
  
      def _a       (							self			:    Dict			)			->       Dict:
             if self.config_name not in _CONFIG_NAMES:
                    raise KeyError(f'''You should supply a configuration name selected in {_CONFIG_NAMES}'''			)
  
             __UpperCAmelCase    							='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 _a       (							self			:    Union[str, Any]   ,    __SCREAMING_SNAKE_CASE			:    Optional[int]   ,    __SCREAMING_SNAKE_CASE			:    List[str]   ,    __SCREAMING_SNAKE_CASE			:    Tuple=None   ,    __SCREAMING_SNAKE_CASE			:    List[Any]=None			)			->       Union[str, Any]:
             __UpperCAmelCase    							=bleu_kwargs if bleu_kwargs is not None else {}
             __UpperCAmelCase    							=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    							=bleu_kwargs.pop("""smooth_method"""   ,    """exp"""			)
                    __UpperCAmelCase    							=bleu_kwargs.pop("""smooth_value"""   ,    SCREAMING_SNAKE_CASE_			)
                    __UpperCAmelCase    							=bleu_kwargs.pop("""force"""   ,    SCREAMING_SNAKE_CASE_			)
                    __UpperCAmelCase    							=bleu_kwargs.pop("""lowercase"""   ,    SCREAMING_SNAKE_CASE_			)
                    __UpperCAmelCase    							=bleu_kwargs.pop("""tokenize"""   ,    SCREAMING_SNAKE_CASE_			)
                    __UpperCAmelCase    							=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    							=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}'''			)
  
  
  
  
  
style_context: 
  
  
  
  
  
  
  from __future__ import annotations
  
  __A  							=  [2, 1, 4, 5, 6, 0, 8, 9, 1, 2, 0, 6, 4, 2, 0, 6, 5, 3, 2, 7]
  
  
  
  class 							_A :
      """simple docstring"""
  
      def __init__(							self			:    List[str]   ,    __SCREAMING_SNAKE_CASE			:    int			)			->       None:
             __UpperCAmelCase    							=-1
             __UpperCAmelCase    							=-1
             __UpperCAmelCase    							=[-1] * length
             __UpperCAmelCase    							=None
             __UpperCAmelCase    							=None
  
  
  
      def __repr__(							self			:    Optional[int]			)			->       str:
             return f'''Node(min_value={self.minn} max_value={self.maxx})'''
  
  
  
  
  
  
  
  def 			lowercase__  (				A_:	list[int]		)  ->							Node | None:
  
  
  
  
  
  
  
         """simple docstring"""
  
  
  
  
  
  
         __UpperCAmelCase    							=Node(len(A_		)		)
         __UpperCAmelCase							,   __UpperCAmelCase    							=min(A_		), max(A_		)
         # Leaf node case where the node contains only one unique value
         if root.minn == root.maxx:
                return root
         __UpperCAmelCase    							=(root.minn + root.maxx) // 2
  
         __UpperCAmelCase    							=[]
         __UpperCAmelCase    							=[]
  
         for index, num in enumerate(A_		):
                if num <= pivot:
                       left_arr.append(A_		)
                else:
                       right_arr.append(A_		)
                __UpperCAmelCase    							=len(A_		)
         __UpperCAmelCase    							=build_tree(A_		)
         __UpperCAmelCase    							=build_tree(A_		)
         return root
  
  
  
  
  
  
  
  def 			lowercase__  (				A_:	Node | None     ,			A_:	int     ,			A_:	int		)  ->							int:
  
  
  
  
  
  
  
         """simple docstring"""
  
  
  
  
  
  
         if index < 0 or node is None:
                return 0
         # Leaf node cases
         if node.minn == node.maxx:
                return index + 1 if node.minn == num else 0
         __UpperCAmelCase    							=(node.minn + node.maxx) // 2
         if num <= pivot:
                # go the left subtree and map index to the left subtree
                return rank_till_index(node.left     ,			A_     ,			node.map_left[index] - 1		)
         else:
                # go to the right subtree and map index to the right subtree
                return rank_till_index(node.right     ,			A_     ,			index - node.map_left[index]		)
  
  
  
  
  
  
  
  def 			lowercase__  (				A_:	Node | None     ,			A_:	int     ,			A_:	int     ,			A_:	int		)  ->							int:
  
  
  
  
  
  
  
         """simple docstring"""
  
  
  
  
  
  
         if start > end:
                return 0
         __UpperCAmelCase    							=rank_till_index(A_     ,			A_     ,			A_		)
         __UpperCAmelCase    							=rank_till_index(A_     ,			A_     ,			start - 1		)
         return rank_till_end - rank_before_start
  
  
  
  
  
  
  
  def 			lowercase__  (				A_:	Node | None     ,			A_:	int     ,			A_:	int     ,			A_:	int		)  ->							int:
  
  
  
  
  
  
  
         """simple docstring"""
  
  
  
  
  
  
         if index > (end - start) or start > end or node is None:
                return -1
         # Leaf node case
         if node.minn == node.maxx:
                return node.minn
         # Number of elements in the left subtree in interval [start, end]
         __UpperCAmelCase    							=node.map_left[end] - (
             node.map_left[start - 1] if start else 0
         )
         if num_elements_in_left_tree > index:
                return quantile(
                    node.left     ,			A_     ,			(node.map_left[start - 1] if start else 0)     ,			node.map_left[end] - 1     ,			)
         else:
                return quantile(
                    node.right     ,			index - num_elements_in_left_tree     ,			start - (node.map_left[start - 1] if start else 0)     ,			end - node.map_left[end]     ,			)
  
  
  
  
  
  
  
  def 			lowercase__  (				A_:	Node | None     ,			A_:	int     ,			A_:	int     ,			A_:	int     ,			A_:	int		)  ->							int:
  
  
  
  
  
  
  
         """simple docstring"""
  
  
  
  
  
  
         if (
             start > end
             or node is None
             or start_num > end_num
             or node.minn > end_num
             or node.maxx < start_num
         ):
                return 0
         if start_num <= node.minn and node.maxx <= end_num:
                return end - start + 1
         __UpperCAmelCase    							=range_counting(
             node.left     ,			(node.map_left[start - 1] if start else 0)     ,			node.map_left[end] - 1     ,			A_     ,			A_     ,			)
         __UpperCAmelCase    							=range_counting(
             node.right     ,			start - (node.map_left[start - 1] if start else 0)     ,			end - node.map_left[end]     ,			A_     ,			A_     ,			)
         return left + right
  
  
  if __name__ == "__main__":
     import doctest
  
     doctest.testmod()
  
  
  
  
  