





import re
import string

import numpy as np

import datasets


UpperCAmelCase						:   int			  =     '''
Returns the rate at which the input predicted strings exactly match their references, ignoring any strings input as part of the regexes_to_ignore list.
'''

UpperCAmelCase						:   List[Any]			  =     '''
Args:
    predictions: List of predicted texts.
    references: List of reference texts.
    regexes_to_ignore: List, defaults to None. Regex expressions of characters to
        ignore when calculating the exact matches. Note: these regexes are removed
        from the input data before the changes based on the options below (e.g. ignore_case,
        ignore_punctuation, ignore_numbers) are applied.
    ignore_case: Boolean, defaults to False. If true, turns everything
        to lowercase so that capitalization differences are ignored.
    ignore_punctuation: Boolean, defaults to False. If true, removes all punctuation before
        comparing predictions and references.
    ignore_numbers: Boolean, defaults to False. If true, removes all punctuation before
        comparing predictions and references.
Returns:
    exact_match: Dictionary containing exact_match rate. Possible values are between 0.0 and 100.0, inclusive.
Examples:
    >>> exact_match = datasets.load_metric("exact_match")
    >>> refs = ["the cat", "theater", "YELLING", "agent007"]
    >>> preds = ["cat?", "theater", "yelling", "agent"]
    >>> results = exact_match.compute(references=refs, predictions=preds)
    >>> print(round(results["exact_match"], 1))
    25.0

    >>> exact_match = datasets.load_metric("exact_match")
    >>> refs = ["the cat", "theater", "YELLING", "agent007"]
    >>> preds = ["cat?", "theater", "yelling", "agent"]
    >>> results = exact_match.compute(references=refs, predictions=preds, regexes_to_ignore=["the ", "yell"], ignore_case=True, ignore_punctuation=True)
    >>> print(round(results["exact_match"], 1))
    50.0


    >>> exact_match = datasets.load_metric("exact_match")
    >>> refs = ["the cat", "theater", "YELLING", "agent007"]
    >>> preds = ["cat?", "theater", "yelling", "agent"]
    >>> results = exact_match.compute(references=refs, predictions=preds, regexes_to_ignore=["the ", "yell", "YELL"], ignore_case=True, ignore_punctuation=True)
    >>> print(round(results["exact_match"], 1))
    75.0

    >>> exact_match = datasets.load_metric("exact_match")
    >>> refs = ["the cat", "theater", "YELLING", "agent007"]
    >>> preds = ["cat?", "theater", "yelling", "agent"]
    >>> results = exact_match.compute(references=refs, predictions=preds, regexes_to_ignore=["the ", "yell", "YELL"], ignore_case=True, ignore_punctuation=True, ignore_numbers=True)
    >>> print(round(results["exact_match"], 1))
    100.0

    >>> exact_match = datasets.load_metric("exact_match")
    >>> refs = ["The cat sat on the mat.", "Theaters are great.", "It\'s like comparing oranges and apples."]
    >>> preds = ["The cat sat on the mat?", "Theaters are great.", "It\'s like comparing apples and oranges."]
    >>> results = exact_match.compute(references=refs, predictions=preds)
    >>> print(round(results["exact_match"], 1))
    33.3

'''

UpperCAmelCase						:   int			  =     '''
'''





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


				"""simple docstring"""


				def 					UpperCAmelCase_		(			self     ):
									return datasets.MetricInfo(
									    description=_DESCRIPTION     ,					citation=_CITATION     ,					inputs_description=_KWARGS_DESCRIPTION     ,					features=datasets.Features(
									        {
									            'predictions': datasets.Value('string'     ,					id='sequence'     ),
									            'references': datasets.Value('string'     ,					id='sequence'     ),
									        }     )     ,					reference_urls=[]     ,					)





				def 					UpperCAmelCase_		(			self     ,					_A     ,					_A     ,					_A=None     ,					_A=False     ,					_A=False     ,					_A=False     ,					):
									if regexes_to_ignore is not None:
														for s in regexes_to_ignore:
																			__A	:						List[str]       =				np.array([re.sub(_A     ,					''     ,					_A     ) for x in predictions]     )
																			__A	:						Union[str, Any]       =				np.array([re.sub(_A     ,					''     ,					_A     ) for x in references]     )
									else:
														__A	:						int       =				np.asarray(_A     )
														__A	:						str       =				np.asarray(_A     )

									if ignore_case:
														__A	:						Dict       =				np.char.lower(_A     )
														__A	:						Optional[int]       =				np.char.lower(_A     )

									if ignore_punctuation:
														__A	:						int       =				string.punctuation.maketrans(''     ,					''     ,					string.punctuation     )
														__A	:						Optional[Any]       =				np.char.translate(_A     ,					table=_A     )
														__A	:						Union[str, Any]       =				np.char.translate(_A     ,					table=_A     )

									if ignore_numbers:
														__A	:						Optional[Any]       =				string.digits.maketrans(''     ,					''     ,					string.digits     )
														__A	:						Optional[int]       =				np.char.translate(_A     ,					table=_A     )
														__A	:						Optional[Any]       =				np.char.translate(_A     ,					table=_A     )

									__A	:						Any       =				predictions == references

									return {"exact_match": np.mean(_A     ) * 100}











def  _SCREAMING_SNAKE_CASE				(   a  )      ->      str:
					if number > 0:
										raise ValueError('input must be a negative integer'  )
					__A	:						Optional[int]       =				len(bin(a  )[3:]  )
					__A	:						Dict       =				bin(abs(a  ) - (1 << binary_number_length)  )[3:]
					__A	:						int       =				(
					    (
					        '1'
					        + '0' * (binary_number_length - len(a  ))
					        + twos_complement_number
					    )
					    if number < 0
					    else '0'
					)
					return "0b" + twos_complement_number


if __name__ == "__main__":
				import doctest

				doctest.testmod()




