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							=       "\\n"

UpperCAmelCase							=       "\\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"

UpperCAmelCase							=       "\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"

UpperCAmelCase							=       ["fleurs-asr", "mls", "voxpopuli", "babel", "covost2", "fleurs-lang_id", "minds14"]
UpperCAmelCase							=       ""

try:
     from jiwer import transforms as tr

     UpperCAmelCase							=       True
except ImportError:
     UpperCAmelCase							=       False

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



     class 					snake_case__       (				tr.AbstractTransform							):



        def __init__(				self   :   str			,	A__   :   str = " "   )							->     Union[str, Any]:




              '''simple docstring'''




              snake_case_     :			Dict       =       sentence_delimiter



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




              '''simple docstring'''




              return list(A__   )



        def 					UpperCAmelCase__       (				self   :   Dict			,	A__   :   List[str]   )							->     int:




              '''simple docstring'''




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


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






def 					SCREAMING_SNAKE_CASE_			(		lowerCAmelCase_: Tuple ,	lowerCAmelCase_: Tuple     ):
      return float((preds == labels).mean()     )






def 					SCREAMING_SNAKE_CASE_			(		lowerCAmelCase_: Optional[Any] ,	lowerCAmelCase_: Union[str, Any]     ):
      return {
          "f1": float(fa_score(y_true=lowerCAmelCase_ ,	y_pred=lowerCAmelCase_ ,	average="macro"     )     ),
          "accuracy": simple_accuracy(lowerCAmelCase_ ,	lowerCAmelCase_     ),
      }






def 					SCREAMING_SNAKE_CASE_			(		lowerCAmelCase_: Tuple ,	lowerCAmelCase_: Any ,	lowerCAmelCase_: Dict="exp" ,	lowerCAmelCase_: List[Any]=None ,	lowerCAmelCase_: Optional[int]=False ,	lowerCAmelCase_: Dict=False ,	lowerCAmelCase_: Any=None ,	lowerCAmelCase_: Any=False ,	):
      # xtreme-s can only have one label
      snake_case_     :			List[Any]       =       [[label] for label in labels]
      snake_case_     :			List[Any]       =       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_     :			List[str]       =       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_     :			List[str]       =       [[refs[i] for refs in labels] for i in range(lowerCAmelCase_     )]
      snake_case_     :			List[str]       =       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 					SCREAMING_SNAKE_CASE_			(		lowerCAmelCase_: Any ,	lowerCAmelCase_: Dict ,	lowerCAmelCase_: Tuple ,	lowerCAmelCase_: Optional[int]     ):
      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_     :			List[str]       =       compute_measures(lowerCAmelCase_ ,	lowerCAmelCase_     )["wer"]

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

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



   def 					UpperCAmelCase__       (				self   :   Dict   )							->     Optional[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_     :			List[Any]       =       "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 					UpperCAmelCase__       (				self   :   Dict			,	A__   :   List[str]			,	A__   :   int			,	A__   :   Optional[int]=None			,	A__   :   Dict=None   )							->     List[Any]:




         '''simple docstring'''




         snake_case_     :			Tuple       =       bleu_kwargs if bleu_kwargs is not None else {}
         snake_case_     :			List[str]       =       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":
               snake_case_     :			Tuple       =       bleu_kwargs.pop("smooth_method"			,	"exp"   )
               snake_case_     :			Tuple       =       bleu_kwargs.pop("smooth_value"			,	A__   )
               snake_case_     :			str       =       bleu_kwargs.pop("force"			,	A__   )
               snake_case_     :			Optional[Any]       =       bleu_kwargs.pop("lowercase"			,	A__   )
               snake_case_     :			Optional[int]       =       bleu_kwargs.pop("tokenize"			,	A__   )
               snake_case_     :			Optional[int]       =       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"]:
               snake_case_     :			Optional[Any]       =       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}"   )




import requests
from bsa import BeautifulSoup






def 					SCREAMING_SNAKE_CASE_			(		lowerCAmelCase_: int ,	lowerCAmelCase_: str     ):
      snake_case_     :			Optional[int]       =       (
          "https://www.horoscope.com/us/horoscopes/general/"
          f"horoscope-general-daily-{day}.aspx?sign={zodiac_sign}"
      )
      snake_case_     :			int       =       BeautifulSoup(requests.get(lowerCAmelCase_     ).content ,	"html.parser"     )
      return soup.find("div" ,	class_="main-horoscope"     ).p.text


if __name__ == "__main__":
     print("Daily Horoscope. \n")
     print(
         "enter your Zodiac sign number:\n",
         "1. Aries\n",
         "2. Taurus\n",
         "3. Gemini\n",
         "4. Cancer\n",
         "5. Leo\n",
         "6. Virgo\n",
         "7. Libra\n",
         "8. Scorpio\n",
         "9. Sagittarius\n",
         "10. Capricorn\n",
         "11. Aquarius\n",
         "12. Pisces\n",
     )
     UpperCAmelCase							=       int(input("number> ").strip())
     print("choose some day:\n", "yesterday\n", "today\n", "tomorrow\n")
     UpperCAmelCase							=       input("enter the day> ")
     UpperCAmelCase							=       horoscope(zodiac_sign, day)
     print(horoscope_text)



