




'''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)
UpperCAmelCase_       :  str      =		'''\
'''

UpperCAmelCase_       :  int      =		'''\
    XTREME-S is a benchmark to evaluate universal cross-lingual speech representations in many languages.
    XTREME-S covers four task families: speech recognition, classification, speech-to-text translation and retrieval.
'''

UpperCAmelCase_       :  int      =		'''
Compute XTREME-S evaluation metric associated to each XTREME-S dataset.
Args:
    predictions: list of predictions to score.
        Each translation should be tokenized into a list of tokens.
    references: list of lists of references for each translation.
        Each reference should be tokenized into a list of tokens.
    bleu_kwargs: optional dict of keywords to be passed when computing \'bleu\'.
        Keywords include Dict can be one of \'smooth_method\', \'smooth_value\', \'force\', \'lowercase\',
        \'tokenize\', \'use_effective_order\'.
    wer_kwargs: optional dict of keywords to be passed when computing \'wer\' and \'cer\'.
        Keywords include \'concatenate_texts\'.
Returns: depending on the XTREME-S task, one or several of:
    "accuracy": Accuracy - for \'fleurs-lang_id\', \'minds14\'
    "f1": F1 score - for \'minds14\'
    "wer": Word error rate - for \'mls\', \'fleurs-asr\', \'voxpopuli\', \'babel\'
    "cer": Character error rate - for \'mls\', \'fleurs-asr\', \'voxpopuli\', \'babel\'
    "bleu": BLEU score according to the `sacrebleu` metric - for \'covost2\'
Examples:

    >>> xtreme_s_metric = datasets.load_metric(\'xtreme_s\', \'mls\')  # \'mls\', \'voxpopuli\', \'fleurs-asr\' or \'babel\'
    >>> references = ["it is sunny here", "paper and pen are essentials"]
    >>> predictions = ["it\'s sunny", "paper pen are essential"]
    >>> results = xtreme_s_metric.compute(predictions=predictions, references=references)
    >>> print({k: round(v, 2) for k, v in results.items()})
    {\'wer\': 0.56, \'cer\': 0.27}

    >>> xtreme_s_metric = datasets.load_metric(\'xtreme_s\', \'covost2\')
    >>> references = ["bonjour paris", "il est necessaire de faire du sport de temps en temp"]
    >>> predictions = ["bonjour paris", "il est important de faire du sport souvent"]
    >>> results = xtreme_s_metric.compute(predictions=predictions, references=references)
    >>> print({k: round(v, 2) for k, v in results.items()})
    {\'bleu\': 31.65}

    >>> xtreme_s_metric = datasets.load_metric(\'xtreme_s\', \'fleurs-lang_id\')
    >>> references = [0, 1, 0, 0, 1]
    >>> predictions = [0, 1, 1, 0, 0]
    >>> results = xtreme_s_metric.compute(predictions=predictions, references=references)
    >>> print({k: round(v, 2) for k, v in results.items()})
    {\'accuracy\': 0.6}

    >>> xtreme_s_metric = datasets.load_metric(\'xtreme_s\', \'minds14\')
    >>> references = [0, 1, 0, 0, 1]
    >>> predictions = [0, 1, 1, 0, 0]
    >>> results = xtreme_s_metric.compute(predictions=predictions, references=references)
    >>> print({k: round(v, 2) for k, v in results.items()})
    {\'f1\': 0.58, \'accuracy\': 0.6}
'''

UpperCAmelCase_       :  Union[str, Any]      =		['''fleurs-asr''', '''mls''', '''voxpopuli''', '''babel''', '''covost2''', '''fleurs-lang_id''', '''minds14''']
UpperCAmelCase_       :  int      =		''''''

try:
     from jiwer import transforms as tr

     UpperCAmelCase_       :  Optional[int]      =		True
except ImportError:
     UpperCAmelCase_       :  Union[str, Any]      =		False

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





     class     lowerCAmelCase   ( tr.AbstractTransform):


            def __init__(   self    ,  __SCREAMING_SNAKE_CASE = " "  )      ->  List[str]:



                 '''simple docstring'''




                 __snake_case    					=  sentence_delimiter


            def       lowerCAmelCase      (   self    ,  __SCREAMING_SNAKE_CASE  )      ->  Any:



                 '''simple docstring'''




                 return list(__SCREAMING_SNAKE_CASE  )




            def       lowerCAmelCase      (   self    ,  __SCREAMING_SNAKE_CASE  )      ->  int:



                 '''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





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







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




     '''simple docstring'''





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







def 			_UpperCamelCase (_lowerCamelCase							:     Optional[int]   ,	_lowerCamelCase							:     Union[str, Any]	)->   List[str]:




     '''simple docstring'''





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







def 			_UpperCamelCase (_lowerCamelCase							:     str   ,	_lowerCamelCase							:     List[Any]   ,	_lowerCamelCase							:     int="exp"   ,	_lowerCamelCase							:     Optional[int]=None   ,	_lowerCamelCase							:     Dict=False   ,	_lowerCamelCase							:     str=False   ,	_lowerCamelCase							:     List[str]=None   ,	_lowerCamelCase							:     Tuple=False   ,	)->   str:




     '''simple docstring'''





     __snake_case    					=  [[label] for label in labels]
     __snake_case    					=  list(_lowerCamelCase	)
     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(_lowerCamelCase	) != 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(_lowerCamelCase	)]
     __snake_case    					=  scb.corpus_bleu(
         _lowerCamelCase   ,	_lowerCamelCase   ,	smooth_method=_lowerCamelCase   ,	smooth_value=_lowerCamelCase   ,	force=_lowerCamelCase   ,	lowercase=_lowerCamelCase   ,	use_effective_order=_lowerCamelCase   ,	**({'''tokenize''': tokenize} if tokenize else {})   ,	)
     return {"bleu": output.score}







def 			_UpperCamelCase (_lowerCamelCase							:     Optional[Any]   ,	_lowerCamelCase							:     Dict   ,	_lowerCamelCase							:     Union[str, Any]   ,	_lowerCamelCase							:     int	)->   Optional[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(_lowerCamelCase   ,	_lowerCamelCase	)['''wer''']

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

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

          return {"wer": compute_score(_lowerCamelCase   ,	_lowerCamelCase   ,	'''wer'''	), "cer": compute_score(_lowerCamelCase   ,	_lowerCamelCase   ,	'''cer'''	)}







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


       def       lowerCAmelCase      (   self  )      ->  Any:



            '''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    ,  __SCREAMING_SNAKE_CASE    ,  __SCREAMING_SNAKE_CASE    ,  __SCREAMING_SNAKE_CASE=None    ,  __SCREAMING_SNAKE_CASE=None  )      ->  List[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'''



from datetime import date

import requests

UpperCAmelCase_       :  str      =		'''https://api.carbonintensity.org.uk/intensity'''







def 			_UpperCamelCase ()->   str:




     '''simple docstring'''





     __snake_case    					=  requests.get(_lowerCamelCase	).json()['''data'''][0]
     return last_half_hour["intensity"]["actual"]







def 			_UpperCamelCase (_lowerCamelCase							:     Dict   ,	_lowerCamelCase							:     List[Any]	)->   list:




     '''simple docstring'''





     return requests.get(f'''{BASE_URL}/{start}/{end}'''	).json()["data"]


if __name__ == "__main__":
     for entry in fetch_from_to(start=date(2_0_2_0, 1_0, 1), end=date(2_0_2_0, 1_0, 3)):
          print('''from {from} to {to}: {intensity[actual]}'''.format(**entry))
     print(F"""{fetch_last_half_hour() = }""")






