




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)
lowercase__   :    int 					=      "\\n"

lowercase__   :    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"

lowercase__   :    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"

lowercase__   :    Tuple 					=      ["fleurs-asr", "mls", "voxpopuli", "babel", "covost2", "fleurs-lang_id", "minds14"]
lowercase__   :    List[str] 					=      ""

try:
   from jiwer import transforms as tr

   lowercase__   :    Optional[int] 					=      True
except ImportError:
   lowercase__   :    str 					=      False

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




   class     a__ (      tr.AbstractTransform   ):







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



             '''simple docstring'''



             a											=   sentence_delimiter







        def     lowerCAmelCase_       (			self						,	A				)						->					Union[str, Any]:



             '''simple docstring'''



             return list(A				)







        def     lowerCAmelCase_       (			self						,	A				)						->					List[Any]:



             '''simple docstring'''



             a											=   []
             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







   lowercase__   :    Union[str, Any] 					=      tr.Compose(
       [tr.RemoveMultipleSpaces(), tr.Strip(), SentencesToListOfCharacters(SENTENCE_DELIMITER)]
   )
elif _jiwer_available:
   lowercase__   :    Optional[Any] 					=      tr.Compose(
       [
           tr.RemoveMultipleSpaces(),
           tr.Strip(),
           tr.ReduceToSingleSentence(SENTENCE_DELIMITER),
           tr.ReduceToListOfListOfChars(),
       ]
   )
else:
   lowercase__   :    Dict 					=      None

def       SCREAMING_SNAKE_CASE							(     __UpperCamelCase	,      __UpperCamelCase)    ->  Union[str, Any]:
     return float((preds == labels).mean())

def       SCREAMING_SNAKE_CASE							(     __UpperCamelCase	,      __UpperCamelCase)    ->  Union[str, Any]:
     return {
         "f1": float(fa_score(y_true=__UpperCamelCase	,      y_pred=__UpperCamelCase	,      average="macro")),
         "accuracy": simple_accuracy(__UpperCamelCase	,      __UpperCamelCase),
     }

def       SCREAMING_SNAKE_CASE							(     __UpperCamelCase	,      __UpperCamelCase	,      __UpperCamelCase="exp"	,      __UpperCamelCase=None	,      __UpperCamelCase=False	,      __UpperCamelCase=False	,      __UpperCamelCase=None	,      __UpperCamelCase=False	,      )    ->  Optional[int]:
     # xtreme-s can only have one label
     a											=   [[label] for label in labels]
     a											=   list(__UpperCamelCase)
     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\"`.")

     a											=   len(labels[0])
     if any(len(__UpperCamelCase) != references_per_prediction for refs in labels):
          raise ValueError("Sacrebleu requires the same number of references for each prediction")
     a											=   [[refs[i] for refs in labels] for i in range(__UpperCamelCase)]
     a											=   scb.corpus_bleu(
         __UpperCamelCase	,      __UpperCamelCase	,      smooth_method=__UpperCamelCase	,      smooth_value=__UpperCamelCase	,      force=__UpperCamelCase	,      lowercase=__UpperCamelCase	,      use_effective_order=__UpperCamelCase	,      **({"tokenize": tokenize} if tokenize else {})	,      )
     return {"bleu": output.score}

def       SCREAMING_SNAKE_CASE							(     __UpperCamelCase	,      __UpperCamelCase	,      __UpperCamelCase	,      __UpperCamelCase)    ->  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:
          a											=   compute_measures(__UpperCamelCase	,      __UpperCamelCase)["wer"]

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

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

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





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







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



          '''simple docstring'''



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

          a											=   "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     lowerCAmelCase_       (			self						,	A						,	A						,	A=None						,	A=None				)						->					str:



          '''simple docstring'''



          a											=   bleu_kwargs if bleu_kwargs is not None else {}
          a											=   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":
               a											=   bleu_kwargs.pop("smooth_method"						,	"exp"				)
               a											=   bleu_kwargs.pop("smooth_value"						,	A				)
               a											=   bleu_kwargs.pop("force"						,	A				)
               a											=   bleu_kwargs.pop("lowercase"						,	A				)
               a											=   bleu_kwargs.pop("tokenize"						,	A				)
               a											=   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"]:
               a											=   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}'''				)







from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_torch_available,
)


lowercase__   :    str 					=      {
    "configuration_rwkv": ["RWKV_PRETRAINED_CONFIG_ARCHIVE_MAP", "RwkvConfig", "RwkvOnnxConfig"],
}

try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   lowercase__   :    int 					=      [
       "RWKV_PRETRAINED_MODEL_ARCHIVE_LIST",
       "RwkvForCausalLM",
       "RwkvModel",
       "RwkvPreTrainedModel",
   ]


if TYPE_CHECKING:
   from .configuration_rwkv import RWKV_PRETRAINED_CONFIG_ARCHIVE_MAP, RwkvConfig, RwkvOnnxConfig

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_rwkv import (
          RWKV_PRETRAINED_MODEL_ARCHIVE_LIST,
          RwkvForCausalLM,
          RwkvModel,
          RwkvPreTrainedModel,
      )
else:
   import sys

   lowercase__   :    List[Any] 					=      _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)

