
import re
import string

import numpy as np

import datasets


A     :  List[Any]					     =       "\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"

A     :  int					     =       "\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"

A     :  List[str]					     =       "\n"


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







  def    __A     (							self :       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    __A     (							self :       str  ,     __magic_name__ :       Union[str, Any]  ,     __magic_name__ :       Optional[int]  ,     __magic_name__ :       int=None  ,     __magic_name__ :       List[Any]=False  ,     __magic_name__ :       Union[str, Any]=False  ,     __magic_name__ :       int=False  ,     )  ->	Any:




        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_   ) * 100}



from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_sentencepiece_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


A     :  str					     =       {
    "configuration_rembert": ["REMBERT_PRETRAINED_CONFIG_ARCHIVE_MAP", "RemBertConfig", "RemBertOnnxConfig"]
}

try:
      if not is_sentencepiece_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      A     :  Tuple					     =       ["RemBertTokenizer"]

try:
      if not is_tokenizers_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      A     :  Tuple					     =       ["RemBertTokenizerFast"]

try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      A     :  Tuple					     =       [
          "REMBERT_PRETRAINED_MODEL_ARCHIVE_LIST",
          "RemBertForCausalLM",
          "RemBertForMaskedLM",
          "RemBertForMultipleChoice",
          "RemBertForQuestionAnswering",
          "RemBertForSequenceClassification",
          "RemBertForTokenClassification",
          "RemBertLayer",
          "RemBertModel",
          "RemBertPreTrainedModel",
          "load_tf_weights_in_rembert",
      ]


try:
      if not is_tf_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      A     :  List[str]					     =       [
          "TF_REMBERT_PRETRAINED_MODEL_ARCHIVE_LIST",
          "TFRemBertForCausalLM",
          "TFRemBertForMaskedLM",
          "TFRemBertForMultipleChoice",
          "TFRemBertForQuestionAnswering",
          "TFRemBertForSequenceClassification",
          "TFRemBertForTokenClassification",
          "TFRemBertLayer",
          "TFRemBertModel",
          "TFRemBertPreTrainedModel",
      ]


if TYPE_CHECKING:
      from .configuration_rembert import REMBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, RemBertConfig, RemBertOnnxConfig

      try:
            if not is_sentencepiece_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .tokenization_rembert import RemBertTokenizer

      try:
            if not is_tokenizers_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .tokenization_rembert_fast import RemBertTokenizerFast

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_rembert import (
                REMBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
                RemBertForCausalLM,
                RemBertForMaskedLM,
                RemBertForMultipleChoice,
                RemBertForQuestionAnswering,
                RemBertForSequenceClassification,
                RemBertForTokenClassification,
                RemBertLayer,
                RemBertModel,
                RemBertPreTrainedModel,
                load_tf_weights_in_rembert,
            )

      try:
            if not is_tf_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_tf_rembert import (
                TF_REMBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
                TFRemBertForCausalLM,
                TFRemBertForMaskedLM,
                TFRemBertForMultipleChoice,
                TFRemBertForQuestionAnswering,
                TFRemBertForSequenceClassification,
                TFRemBertForTokenClassification,
                TFRemBertLayer,
                TFRemBertModel,
                TFRemBertPreTrainedModel,
            )


else:
      import sys

      A     :  Tuple					     =       _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)


