




import re
import string

import numpy as np

import datasets


__lowerCAmelCase		:				Dict       			=		'\nReturns the rate at which the input predicted strings exactly match their references, ignoring any strings input as part of the regexes_to_ignore list.\n'

__lowerCAmelCase		:				Union[str, Any]       			=		'\nArgs:\n    predictions: List of predicted texts.\n    references: List of reference texts.\n    regexes_to_ignore: List, defaults to None. Regex expressions of characters to\n        ignore when calculating the exact matches. Note: these regexes are removed\n        from the input data before the changes based on the options below (e.g. ignore_case,\n        ignore_punctuation, ignore_numbers) are applied.\n    ignore_case: Boolean, defaults to False. If true, turns everything\n        to lowercase so that capitalization differences are ignored.\n    ignore_punctuation: Boolean, defaults to False. If true, removes all punctuation before\n        comparing predictions and references.\n    ignore_numbers: Boolean, defaults to False. If true, removes all punctuation before\n        comparing predictions and references.\nReturns:\n    exact_match: Dictionary containing exact_match rate. Possible values are between 0.0 and 100.0, inclusive.\nExamples:\n    >>> exact_match = datasets.load_metric("exact_match")\n    >>> refs = ["the cat", "theater", "YELLING", "agent007"]\n    >>> preds = ["cat?", "theater", "yelling", "agent"]\n    >>> results = exact_match.compute(references=refs, predictions=preds)\n    >>> print(round(results["exact_match"], 1))\n    25.0\n\n    >>> exact_match = datasets.load_metric("exact_match")\n    >>> refs = ["the cat", "theater", "YELLING", "agent007"]\n    >>> preds = ["cat?", "theater", "yelling", "agent"]\n    >>> results = exact_match.compute(references=refs, predictions=preds, regexes_to_ignore=["the ", "yell"], ignore_case=True, ignore_punctuation=True)\n    >>> print(round(results["exact_match"], 1))\n    50.0\n\n\n    >>> exact_match = datasets.load_metric("exact_match")\n    >>> refs = ["the cat", "theater", "YELLING", "agent007"]\n    >>> preds = ["cat?", "theater", "yelling", "agent"]\n    >>> results = exact_match.compute(references=refs, predictions=preds, regexes_to_ignore=["the ", "yell", "YELL"], ignore_case=True, ignore_punctuation=True)\n    >>> print(round(results["exact_match"], 1))\n    75.0\n\n    >>> exact_match = datasets.load_metric("exact_match")\n    >>> refs = ["the cat", "theater", "YELLING", "agent007"]\n    >>> preds = ["cat?", "theater", "yelling", "agent"]\n    >>> results = exact_match.compute(references=refs, predictions=preds, regexes_to_ignore=["the ", "yell", "YELL"], ignore_case=True, ignore_punctuation=True, ignore_numbers=True)\n    >>> print(round(results["exact_match"], 1))\n    100.0\n\n    >>> exact_match = datasets.load_metric("exact_match")\n    >>> refs = ["The cat sat on the mat.", "Theaters are great.", "It\'s like comparing oranges and apples."]\n    >>> preds = ["The cat sat on the mat?", "Theaters are great.", "It\'s like comparing apples and oranges."]\n    >>> results = exact_match.compute(references=refs, predictions=preds)\n    >>> print(round(results["exact_match"], 1))\n    33.3\n\n'

__lowerCAmelCase		:				List[Any]       			=		'\n'




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



				def 							__UpperCAmelCase							(      self				:     Optional[int]							)					->     Union[str, Any]:
							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				:     Union[str, Any]					,      __lowerCamelCase				:     List[str]					,      __lowerCamelCase				:     Optional[int]					,      __lowerCamelCase				:     List[str]=None					,      __lowerCamelCase				:     Optional[Any]=False					,      __lowerCamelCase				:     Optional[int]=False					,      __lowerCamelCase				:     int=False					,      )					->     Dict:
							if regexes_to_ignore is not None:
										for s in regexes_to_ignore:
													a    =			np.array([re.sub(__lowerCamelCase					,      ""					,      __lowerCamelCase							) for x in predictions]							)
													a    =			np.array([re.sub(__lowerCamelCase					,      ""					,      __lowerCamelCase							) for x in references]							)
							else:
										a    =			np.asarray(__lowerCamelCase							)
										a    =			np.asarray(__lowerCamelCase							)

							if ignore_case:
										a    =			np.char.lower(__lowerCamelCase							)
										a    =			np.char.lower(__lowerCamelCase							)

							if ignore_punctuation:
										a    =			string.punctuation.maketrans(""					,      ""					,      string.punctuation							)
										a    =			np.char.translate(__lowerCamelCase					,      table=__lowerCamelCase							)
										a    =			np.char.translate(__lowerCamelCase					,      table=__lowerCamelCase							)

							if ignore_numbers:
										a    =			string.digits.maketrans(""					,      ""					,      string.digits							)
										a    =			np.char.translate(__lowerCamelCase					,      table=__lowerCamelCase							)
										a    =			np.char.translate(__lowerCamelCase					,      table=__lowerCamelCase							)

							a    =			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     snake_case__							(TensorFormatter[Mapping, """torch.Tensor""", Mapping]   ):
				"""simple docstring"""



				def __init__(      self				:     Tuple					,      __lowerCamelCase				:     Union[str, Any]=None					,      **__lowerCamelCase				:     Any							)					->     Optional[Any]:
							super().__init__(features=__lowerCamelCase							)
							a    =			torch_tensor_kwargs
							import torch  # noqa import torch at initialization





				def 							__UpperCAmelCase							(      self				:     List[str]					,      __lowerCamelCase				:     Dict							)					->     Dict:
							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 							__UpperCAmelCase							(      self				:     Optional[Any]					,      __lowerCamelCase				:     List[Any]							)					->     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()

							a    =			{}

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

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





				def 							__UpperCAmelCase							(      self				:     List[str]					,      __lowerCamelCase				:     Tuple							)					->     List[str]:
							import torch

							# support for torch, tf, jax etc.
							if hasattr(__lowerCamelCase					,      "__array__"							) and not isinstance(__lowerCamelCase					,      torch.Tensor							):
										a    =			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 							__UpperCAmelCase							(      self				:     int					,      __lowerCamelCase				:     dict							)					->     str:
							return map_nested(self._recursive_tensorize					,      __lowerCamelCase					,      map_list=__lowerCamelCase							)





				def 							__UpperCAmelCase							(      self				:     Optional[Any]					,      __lowerCamelCase				:     pa.Table							)					->     Mapping:
							a    =			self.numpy_arrow_extractor().extract_row(__lowerCamelCase							)
							a    =			self.python_features_decoder.decode_row(__lowerCamelCase							)
							return self.recursive_tensorize(__lowerCamelCase							)





				def 							__UpperCAmelCase							(      self				:     int					,      __lowerCamelCase				:     pa.Table							)					->     "torch.Tensor":
							a    =			self.numpy_arrow_extractor().extract_column(__lowerCamelCase							)
							a    =			self.python_features_decoder.decode_column(__lowerCamelCase					,      pa_table.column_names[0]							)
							a    =			self.recursive_tensorize(__lowerCamelCase							)
							a    =			self._consolidate(__lowerCamelCase							)
							return column





				def 							__UpperCAmelCase							(      self				:     Optional[Any]					,      __lowerCamelCase				:     pa.Table							)					->     Mapping:
							a    =			self.numpy_arrow_extractor().extract_batch(__lowerCamelCase							)
							a    =			self.python_features_decoder.decode_batch(__lowerCamelCase							)
							a    =			self.recursive_tensorize(__lowerCamelCase							)
							for column_name in batch:
										a    =			self._consolidate(batch[column_name]							)
							return batch






