




'''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)
_SCREAMING_SNAKE_CASE							:     Any   	=				"\\n"

_SCREAMING_SNAKE_CASE							:     int   	=				"\\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"

_SCREAMING_SNAKE_CASE							:     int   	=				"\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"

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

try:
  from jiwer import transforms as tr

  _SCREAMING_SNAKE_CASE							:     str   	=				True
except ImportError:
  _SCREAMING_SNAKE_CASE							:     Any   	=				False

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




  class 				_snake_case	(			tr.AbstractTransform							):




     def __init__(      self       ,							a__ = " "							)       ->       int:

            '''simple docstring'''




            snake_case_			      =   sentence_delimiter




     def      lowerCAmelCase__       (      self       ,							a__							)       ->       str:

            '''simple docstring'''




            return list(SCREAMING_SNAKE_CASE_							)




     def      lowerCAmelCase__       (      self       ,							a__							)       ->       List[Any]:

            '''simple docstring'''




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

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


def   UpperCamelCase_(			snake_case							: Optional[Any]							,       snake_case							: Dict  ):

       '''simple docstring'''






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


def   UpperCamelCase_(			snake_case							: Any							,       snake_case							: Optional[int]  ):

       '''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   UpperCamelCase_(			snake_case							: Dict							,       snake_case							: Dict							,       snake_case							: List[str]="exp"							,       snake_case							: Optional[int]=None							,       snake_case							: Dict=False							,       snake_case							: List[str]=False							,       snake_case							: Any=None							,       snake_case							: List[Any]=False							,       ):

       '''simple docstring'''






       snake_case_			      =   [[label] for label in labels]
       snake_case_			      =   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\"`."  )

       snake_case_			      =   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"  )
       snake_case_			      =   [[refs[i] for refs in labels] for i in range(snake_case__  )]
       snake_case_			      =   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   UpperCamelCase_(			snake_case							: Tuple							,       snake_case							: List[str]							,       snake_case							: Optional[int]							,       snake_case							: 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:
              snake_case_			      =   compute_measures(snake_case__							,       snake_case__  )['wer']

              snake_case_			      =   compute_measures(snake_case__							,       snake_case__							,       truth_transform=snake_case__							,       hypothesis_transform=snake_case__  )['wer']
              return {"wer": wer, "cer": cer}
       else:

              def compute_score(snake_case							: Optional[int]							,       snake_case							: Union[str, Any]							,       snake_case							: Any="wer"  ):
                     snake_case_			      =   0
                     snake_case_			      =   0
                     for prediction, reference in zip(snake_case__							,       snake_case__  ):
                            if score_type == "wer":
                                   snake_case_			      =   compute_measures(snake_case__							,       snake_case__  )
                            elif score_type == "cer":
                                   snake_case_			      =   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 				_snake_case	(			datasets.Metric							):




   def      lowerCAmelCase__       (      self							)       ->       Dict:

          '''simple docstring'''




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

          snake_case_			      =   '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      lowerCAmelCase__       (      self       ,							a__       ,							a__       ,							a__=None       ,							a__=None							)       ->       Union[str, Any]:

          '''simple docstring'''




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










'''simple docstring'''





import unittest
from pathlib import Path
from tempfile import TemporaryDirectory
from unittest.mock import Mock, patch

import diffusers.utils.hub_utils




class 				_snake_case	(			unittest.TestCase							):




			@patch("diffusers.utils.hub_utils.get_full_repo_name"							)
			def      lowerCAmelCase__       (      self       ,							a__							)       ->       None:

										'''simple docstring'''




										snake_case_			      =   "full_repo_name"
										with TemporaryDirectory() as tmpdir:
																	# Dummy args values
																	snake_case_			      =   Mock()
																	snake_case_			      =   tmpdir
																	snake_case_			      =   0
																	snake_case_			      =   "hub_token"
																	snake_case_			      =   "dataset_name"
																	snake_case_			      =   0.0_1
																	snake_case_			      =   100_000
																	snake_case_			      =   10_000
																	snake_case_			      =   0.0_1
																	snake_case_			      =   0.0_2
																	snake_case_			      =   0.0_3
																	snake_case_			      =   0.0_0_0_5
																	snake_case_			      =   0.0_0_0_0_0_1
																	snake_case_			      =   1
																	snake_case_			      =   10
																	snake_case_			      =   0.0_0_1
																	snake_case_			      =   0.1
																	snake_case_			      =   0.2
																	snake_case_			      =   True

																	# Model card mush be rendered and saved
																	diffusers.utils.hub_utils.create_model_card(a__       ,							model_name="model_name"							)
																	self.assertTrue((Path(a__							) / "README.md").is_file()							)




