import math_equivalence  # From: git+https://github.com/hendrycks/math.git

import datasets


__lowerCamelCase    :				Any							     =	"""\
@article{hendrycksmath2021,
  title={Measuring Mathematical Problem Solving With the MATH Dataset},
  author={Dan Hendrycks
    and Collin Burns
    and Saurav Kadavath
    and Akul Arora
    and Steven Basart
    and Eric Tang
    and Dawn Song
    and Jacob Steinhardt},
  journal={arXiv preprint arXiv:2103.03874},
  year={2021}
}
"""


__lowerCamelCase    :				Optional[int]							     =	"""\
This metric is used to assess performance on the Mathematics Aptitude Test of Heuristics (MATH) dataset.
It first canonicalizes the inputs (e.g., converting \"1/2\" to \"\\frac{1}{2}\") and then computes accuracy.
"""


__lowerCamelCase    :				Any							     =	r"""
Calculates accuracy after canonicalizing inputs.

Args:
    predictions: list of predictions to score. Each prediction
        is a string that contains natural language and LaTex.
    references: list of reference for each prediction. Each
        reference is a string that contains natural language
        and LaTex.
Returns:
    accuracy: accuracy after canonicalizing inputs
        (e.g., converting \"1/2\" to \"\\frac{1}{2}\")

Examples:
    >>> metric = datasets.load_metric(\"competition_math\")
    >>> results = metric.compute(references=[\"\\frac{1}{2}\"], predictions=[\"1/2\"])
    >>> print(results)
    {'accuracy': 1.0}
"""







@datasets.utils.file_utils.add_end_docstrings(_DESCRIPTION     ,	_KWARGS_DESCRIPTION	)
class __snake_case       (		datasets.Metric	):




   def 			__a		(					self    :       Dict   ):



     """simple docstring"""






     return datasets.MetricInfo(
         description=_DESCRIPTION ,			citation=_CITATION ,			inputs_description=_KWARGS_DESCRIPTION ,			features=datasets.Features(
             {
                 """predictions""": datasets.Value("""string"""   ),
                 """references""": datasets.Value("""string"""   ),
             }   ) ,			homepage="""https://github.com/hendrycks/math""" ,			codebase_urls=["""https://github.com/hendrycks/math"""] ,			)




   def 			__a		(					self    :       Optional[Any] ,			_lowercase    :       Optional[Any] ,			_lowercase    :       Dict   ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__    							=   0.0
     for i, j in zip(A_ ,			A_   ):
       n_correct += 1.0 if math_equivalence.is_equiv(A_ ,			A_   ) else 0.0
     SCREAMING_SNAKE_CASE__    							=   n_correct / len(A_   )
     return {
         "accuracy": accuracy,
     }

from typing import List, Optional

import numpy as np

from ...processing_utils import ProcessorMixin
from ...utils import to_numpy







class __snake_case       (		lowerCamelCase_	):
   lowerCAmelCase_														=							"EncodecFeatureExtractor"
   lowerCAmelCase_														=							("T5Tokenizer", "T5TokenizerFast")




   def __init__(					self    :       List[Any] ,			_lowercase    :       int ,			_lowercase    :       Any   ):



     """simple docstring"""






     super().__init__(_lowercase ,			_lowercase   )
     SCREAMING_SNAKE_CASE__    							=   self.feature_extractor
     SCREAMING_SNAKE_CASE__    							=   False




   def 			__a		(					self    :       Tuple ,			_lowercase    :       str=None ,			_lowercase    :       int=None ,			_lowercase    :       Any=True   ):



     """simple docstring"""






     return self.tokenizer.get_decoder_prompt_ids(task=_lowercase ,			language=_lowercase ,			no_timestamps=_lowercase   )




   def __call__(					self    :       Tuple ,			*_lowercase    :       Tuple ,			**_lowercase    :       Union[str, Any]   ):



     """simple docstring"""






     if self._in_target_context_manager:
       return self.current_processor(*_lowercase ,			**_lowercase   )

     SCREAMING_SNAKE_CASE__    							=   kwargs.pop("""audio""" ,			_lowercase   )
     SCREAMING_SNAKE_CASE__    							=   kwargs.pop("""sampling_rate""" ,			_lowercase   )
     SCREAMING_SNAKE_CASE__    							=   kwargs.pop("""text""" ,			_lowercase   )
     if len(_lowercase   ) > 0:
       SCREAMING_SNAKE_CASE__    							=   args[0]
       SCREAMING_SNAKE_CASE__    							=   args[1:]

     if audio is None and text is None:
       raise ValueError("""You need to specify either an `audio` or `text` input to process."""   )

     if text is not None:
       SCREAMING_SNAKE_CASE__    							=   self.tokenizer(_lowercase ,			**_lowercase   )

     if audio is not None:
       SCREAMING_SNAKE_CASE__    							=   self.feature_extractor(_lowercase ,			*_lowercase ,			sampling_rate=_lowercase ,			**_lowercase   )

     if audio is None:
       return inputs

     elif text is None:
       return audio_inputs

     else:
       SCREAMING_SNAKE_CASE__    							=   audio_inputs["""input_values"""]
       if "padding_mask" in audio_inputs:
         SCREAMING_SNAKE_CASE__    							=   audio_inputs["""padding_mask"""]
       return inputs




   def 			__a		(					self    :       Dict ,			*_lowercase    :       Any ,			**_lowercase    :       Optional[Any]   ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__    							=   kwargs.pop("""audio""" ,			_lowercase   )
     SCREAMING_SNAKE_CASE__    							=   kwargs.pop("""padding_mask""" ,			_lowercase   )

     if len(_lowercase   ) > 0:
       SCREAMING_SNAKE_CASE__    							=   args[0]
       SCREAMING_SNAKE_CASE__    							=   args[1:]

     if audio_values is not None:
       return self._decode_audio(_lowercase ,			padding_mask=_lowercase   )
     else:
       return self.tokenizer.batch_decode(*_lowercase ,			**_lowercase   )




   def 			__a		(					self    :       List[str] ,			*_lowercase    :       Tuple ,			**_lowercase    :       Optional[Any]   ):



     """simple docstring"""






     return self.tokenizer.decode(*_lowercase ,			**_lowercase   )




   def 			__a		(					self    :       List[str] ,			_lowercase    :       Tuple ,			_lowercase    :       Optional = None   ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__    							=   to_numpy(_lowercase   )
     SCREAMING_SNAKE_CASE__							,  SCREAMING_SNAKE_CASE__							,  SCREAMING_SNAKE_CASE__    							=   audio_values.shape

     if padding_mask is None:
       return list(_lowercase   )

     SCREAMING_SNAKE_CASE__    							=   to_numpy(_lowercase   )

     # match the sequence length of the padding mask to the generated audio arrays by padding with the **non-padding**
     # token (so that the generated audio values are **not** treated as padded tokens)
     SCREAMING_SNAKE_CASE__    							=   seq_len - padding_mask.shape[-1]
     SCREAMING_SNAKE_CASE__    							=   1 - self.feature_extractor.padding_value
     SCREAMING_SNAKE_CASE__    							=   np.pad(_lowercase ,			((0, 0), (0, difference)) ,			"""constant""" ,			constant_values=_lowercase   )

     SCREAMING_SNAKE_CASE__    							=   audio_values.tolist()
     for i in range(_lowercase   ):
       SCREAMING_SNAKE_CASE__    							=   np.asarray(audio_values[i]   )[
           padding_mask[i][None, :] != self.feature_extractor.padding_value
       ]
       SCREAMING_SNAKE_CASE__    							=   sliced_audio.reshape(_lowercase ,			-1   )

     return audio_values
