




import re
import string

import numpy as np

import datasets


SCREAMING_SNAKE_CASE__ 						="""
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.
"""

SCREAMING_SNAKE_CASE__ 						="""
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

"""

SCREAMING_SNAKE_CASE__ 						="""
"""






@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION    ,  _KWARGS_DESCRIPTION)
class  __magic_name__						(  datasets.Metric):
				'''simple docstring'''







				def     _A							(							self:   Optional[int]		):
											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     _A							(							self:   Tuple		,					_lowerCamelCase:   int		,					_lowerCamelCase:   int		,					_lowerCamelCase:   Tuple=None		,					_lowerCamelCase:   str=False		,					_lowerCamelCase:   List[str]=False		,					_lowerCamelCase:   List[str]=False		,					):
											if regexes_to_ignore is not None:
																		for s in regexes_to_ignore:
																									SCREAMING_SNAKE_CASE_   	=    np.array([re.sub(_lowerCamelCase		,					''''''		,					_lowerCamelCase		) for x in predictions]		)
																									SCREAMING_SNAKE_CASE_   	=    np.array([re.sub(_lowerCamelCase		,					''''''		,					_lowerCamelCase		) for x in references]		)
											else:
																		SCREAMING_SNAKE_CASE_   	=    np.asarray(_lowerCamelCase		)
																		SCREAMING_SNAKE_CASE_   	=    np.asarray(_lowerCamelCase		)

											if ignore_case:
																		SCREAMING_SNAKE_CASE_   	=    np.char.lower(_lowerCamelCase		)
																		SCREAMING_SNAKE_CASE_   	=    np.char.lower(_lowerCamelCase		)

											if ignore_punctuation:
																		SCREAMING_SNAKE_CASE_   	=    string.punctuation.maketrans(''''''		,					''''''		,					string.punctuation		)
																		SCREAMING_SNAKE_CASE_   	=    np.char.translate(_lowerCamelCase		,					table=_lowerCamelCase		)
																		SCREAMING_SNAKE_CASE_   	=    np.char.translate(_lowerCamelCase		,					table=_lowerCamelCase		)

											if ignore_numbers:
																		SCREAMING_SNAKE_CASE_   	=    string.digits.maketrans(''''''		,					''''''		,					string.digits		)
																		SCREAMING_SNAKE_CASE_   	=    np.char.translate(_lowerCamelCase		,					table=_lowerCamelCase		)
																		SCREAMING_SNAKE_CASE_   	=    np.char.translate(_lowerCamelCase		,					table=_lowerCamelCase		)

											SCREAMING_SNAKE_CASE_   	=    predictions == references

											return {"exact_match": np.mean(_lowerCamelCase		) * 1_00}








# Lint as: python3
import sys
from collections.abc import Mapping
from typing import TYPE_CHECKING

import numpy as np
import pyarrow as pa

from .. import config
from ..utils.py_utils import map_nested
from .formatting import TensorFormatter


if TYPE_CHECKING:
			import torch






class  __magic_name__						(  TensorFormatter[Mapping, "torch.Tensor", Mapping]):
				'''simple docstring'''







				def __init__(							self:   int		,					_lowerCamelCase:   int=None		,					**_lowerCamelCase:   List[Any]		):
											super().__init__(features=_lowerCamelCase		)
											SCREAMING_SNAKE_CASE_   	=    torch_tensor_kwargs
											import torch  # noqa import torch at initialization


				def     _A							(							self:   Union[str, Any]		,					_lowerCamelCase:   Optional[Any]		):
											import torch

											if isinstance(_lowerCamelCase		,					_lowerCamelCase		) and column:
																		if all(
																		    isinstance(_lowerCamelCase		,					torch.Tensor		) and x.shape == column[0].shape and x.dtype == column[0].dtype
																		    for x in column		):
																									return torch.stack(_lowerCamelCase		)
											return column


				def     _A							(							self:   Tuple		,					_lowerCamelCase:   List[str]		):
											import torch

											if isinstance(_lowerCamelCase		,					(str, bytes, type(_lowerCamelCase		))		):
																		return value
											elif isinstance(_lowerCamelCase		,					(np.character, np.ndarray)		) and np.issubdtype(value.dtype		,					np.character		):
																		return value.tolist()

											SCREAMING_SNAKE_CASE_   	=    {}

											if isinstance(_lowerCamelCase		,					(np.number, np.ndarray)		) and np.issubdtype(value.dtype		,					np.integer		):
																		SCREAMING_SNAKE_CASE_   	=    {'''dtype''': torch.intaa}
											elif isinstance(_lowerCamelCase		,					(np.number, np.ndarray)		) and np.issubdtype(value.dtype		,					np.floating		):
																		SCREAMING_SNAKE_CASE_   	=    {'''dtype''': torch.floataa}
											elif config.PIL_AVAILABLE and "PIL" in sys.modules:
																		import PIL.Image

																		if isinstance(_lowerCamelCase		,					PIL.Image.Image		):
																									SCREAMING_SNAKE_CASE_   	=    np.asarray(_lowerCamelCase		)
											return torch.tensor(_lowerCamelCase		,					**{**default_dtype, **self.torch_tensor_kwargs}		)


				def     _A							(							self:   Union[str, Any]		,					_lowerCamelCase:   Dict		):
											import torch

											# support for torch, tf, jax etc.
											if hasattr(_lowerCamelCase		,					'''__array__'''		) and not isinstance(_lowerCamelCase		,					torch.Tensor		):
																		SCREAMING_SNAKE_CASE_   	=    data_struct.__array__()
											# support for nested types like struct of list of struct
											if isinstance(_lowerCamelCase		,					np.ndarray		):
																		if data_struct.dtype == object:  # torch tensors cannot be instantied from an array of objects
																									return self._consolidate([self.recursive_tensorize(_lowerCamelCase		) for substruct in data_struct]		)
											elif isinstance(_lowerCamelCase		,					(list, tuple)		):
																		return self._consolidate([self.recursive_tensorize(_lowerCamelCase		) for substruct in data_struct]		)
											return self._tensorize(_lowerCamelCase		)


				def     _A							(							self:   str		,					_lowerCamelCase:   dict		):
											return map_nested(self._recursive_tensorize		,					_lowerCamelCase		,					map_list=_lowerCamelCase		)


				def     _A							(							self:   Optional[int]		,					_lowerCamelCase:   pa.Table		):
											SCREAMING_SNAKE_CASE_   	=    self.numpy_arrow_extractor().extract_row(_lowerCamelCase		)
											SCREAMING_SNAKE_CASE_   	=    self.python_features_decoder.decode_row(_lowerCamelCase		)
											return self.recursive_tensorize(_lowerCamelCase		)


				def     _A							(							self:   Optional[Any]		,					_lowerCamelCase:   pa.Table		):
											SCREAMING_SNAKE_CASE_   	=    self.numpy_arrow_extractor().extract_column(_lowerCamelCase		)
											SCREAMING_SNAKE_CASE_   	=    self.python_features_decoder.decode_column(_lowerCamelCase		,					pa_table.column_names[0]		)
											SCREAMING_SNAKE_CASE_   	=    self.recursive_tensorize(_lowerCamelCase		)
											SCREAMING_SNAKE_CASE_   	=    self._consolidate(_lowerCamelCase		)
											return column





				def     _A							(							self:   Optional[Any]		,					_lowerCamelCase:   pa.Table		):
											SCREAMING_SNAKE_CASE_   	=    self.numpy_arrow_extractor().extract_batch(_lowerCamelCase		)
											SCREAMING_SNAKE_CASE_   	=    self.python_features_decoder.decode_batch(_lowerCamelCase		)
											SCREAMING_SNAKE_CASE_   	=    self.recursive_tensorize(_lowerCamelCase		)
											for column_name in batch:
																		SCREAMING_SNAKE_CASE_   	=    self._consolidate(batch[column_name]		)
											return batch


