


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

a__    :   Optional[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'

a__    :   str								=			'\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__    :   Optional[Any]								=			['fleurs-asr', 'mls', 'voxpopuli', 'babel', 'covost2', 'fleurs-lang_id', 'minds14']
a__    :   Optional[Any]								=			''

try:
  from jiwer import transforms as tr

  a__    :   List[str]								=			True
except ImportError:
  a__    :   int								=			False

if _jiwer_available and version.parse(importlib_metadata.version('jiwer')) < version.parse('2.3.0'):
  class    lowercase_	(       tr.AbstractTransform  ):


      def __init__(	self    ,   a = " "       ):
            UpperCamelCase__      =							sentence_delimiter


      def   __a				(	self    ,   a       ):
            return list(a       )


      def   __a				(	self    ,   a       ):
            UpperCamelCase__      =							[]
            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

  a__    :   Any								=			tr.Compose(
      [tr.RemoveMultipleSpaces(), tr.Strip(), SentencesToListOfCharacters(SENTENCE_DELIMITER)]
  )
elif _jiwer_available:
  a__    :   List[Any]								=			tr.Compose(
      [
          tr.RemoveMultipleSpaces(),
          tr.Strip(),
          tr.ReduceToSingleSentence(SENTENCE_DELIMITER),
          tr.ReduceToListOfListOfChars(),
      ]
  )
else:
  a__    :   Optional[int]								=			None







def _UpperCamelCase			(	__A ,     __A       )				->						List[str]:


      '''simple docstring'''



      return float((preds == labels).mean()       )







def _UpperCamelCase			(	__A ,     __A       )				->						Union[str, Any]:


      '''simple docstring'''



      return {
          "f1": float(fa_score(y_true=__A ,     y_pred=__A ,     average="macro"       )       ),
          "accuracy": simple_accuracy(__A ,     __A       ),
      }







def _UpperCamelCase			(	__A ,     __A ,     __A="exp" ,     __A=None ,     __A=False ,     __A=False ,     __A=None ,     __A=False ,     )				->						Dict:


      '''simple docstring'''



      UpperCamelCase__      =							[[label] for label in labels]
      UpperCamelCase__      =							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__      =							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__      =							[[refs[i] for refs in labels] for i in range(__A       )]
      UpperCamelCase__      =							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 _UpperCamelCase			(	__A ,     __A ,     __A ,     __A       )				->						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__      =							compute_measures(__A ,     __A       )["wer"]

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

            def compute_score(__A ,     __A ,     __A="wer"       ):
                  UpperCamelCase__      =							0
                  UpperCamelCase__      =							0
                  for prediction, reference in zip(__A ,     __A       ):
                        if score_type == "wer":
                              UpperCamelCase__      =							compute_measures(__A ,     __A       )
                        elif score_type == "cer":
                              UpperCamelCase__      =							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  ):


    def   __a				(	self       ):
          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(a       ), "references": datasets.Value(a       )}       )    ,   codebase_urls=[]    ,   reference_urls=[]    ,   format="numpy"    ,   )


    def   __a				(	self    ,   a    ,   a    ,   a=None    ,   a=None       ):
          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(a    ,   a       )}
          elif self.config_name == "minds14":
                return fa_and_simple_accuracy(a    ,   a       )
          elif self.config_name == "covost2":
                UpperCamelCase__      =							bleu_kwargs.pop("smooth_method"    ,   "exp"       )
                UpperCamelCase__      =							bleu_kwargs.pop("smooth_value"    ,   a       )
                UpperCamelCase__      =							bleu_kwargs.pop("force"    ,   a       )
                UpperCamelCase__      =							bleu_kwargs.pop("lowercase"    ,   a       )
                UpperCamelCase__      =							bleu_kwargs.pop("tokenize"    ,   a       )
                UpperCamelCase__      =							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"]:
                UpperCamelCase__      =							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}'''       )









'''simple docstring'''







from __future__ import annotations

# Define the Gravitational Constant G and the function
a__    :   Optional[int]								=			6.67_43E-11  # unit of G : m^3 * kg^-1 * s^-2







def _UpperCamelCase			(	__A ,     __A ,     __A ,     __A       )				->						dict[str, float]:


      '''simple docstring'''



      UpperCamelCase__      =							mass_a * mass_a

      if (force, mass_a, mass_a, distance).count(0       ) != 1:
            raise ValueError("One and only one argument must be 0"       )
      if force < 0:
            raise ValueError("Gravitational force can not be negative"       )
      if distance < 0:
            raise ValueError("Distance can not be negative"       )
      if mass_a < 0 or mass_a < 0:
            raise ValueError("Mass can not be negative"       )
      if force == 0:
            UpperCamelCase__      =							GRAVITATIONAL_CONSTANT * product_of_mass / (distance**2)
            return {"force": force}
      elif mass_a == 0:
            UpperCamelCase__      =							(force) * (distance**2) / (GRAVITATIONAL_CONSTANT * mass_a)
            return {"mass_1": mass_a}
      elif mass_a == 0:
            UpperCamelCase__      =							(force) * (distance**2) / (GRAVITATIONAL_CONSTANT * mass_a)
            return {"mass_2": mass_a}
      elif distance == 0:
            UpperCamelCase__      =							(GRAVITATIONAL_CONSTANT * product_of_mass / (force)) ** 0.5
            return {"distance": distance}
      raise ValueError("One and only one argument must be 0"       )


# Run doctest
if __name__ == "__main__":
  import doctest

  doctest.testmod()





