
'''simple docstring'''



import re
import string

import numpy as np

import datasets


__A								=			"\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								=			"\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								=			"\n"





@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION						,  _KWARGS_DESCRIPTION )
class 	A							(				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"""				,   id="""sequence"""				),
									            """references""": datasets.Value("""string"""				,   id="""sequence"""				),
									        }				)				,   reference_urls=[]				,   )



			def A__       (    self				,   lowerCamelCase__				,   lowerCamelCase__				,   lowerCamelCase__=None				,   lowerCamelCase__=False				,   lowerCamelCase__=False				,   lowerCamelCase__=False				,   )	->						List[Any]:




									'''simple docstring'''



									if regexes_to_ignore is not None:
															for s in regexes_to_ignore:
																					lowercase__							       =				np.array([re.sub(__A				,   """"""				,   __A				) for x in predictions]				)
																					lowercase__							       =				np.array([re.sub(__A				,   """"""				,   __A				) for x in references]				)
									else:
															lowercase__							       =				np.asarray(__A				)
															lowercase__							       =				np.asarray(__A				)

									if ignore_case:
															lowercase__							       =				np.char.lower(__A				)
															lowercase__							       =				np.char.lower(__A				)

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

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

									lowercase__							       =				predictions == references

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










import json
import os
import unittest

from transformers.models.biogpt.tokenization_biogpt import VOCAB_FILES_NAMES, BioGptTokenizer
from transformers.testing_utils import slow

from ...test_tokenization_common import TokenizerTesterMixin
class 	UpperCAmelCase_					(					UpperCamelCase		, unittest.TestCase    ):

   '''simple docstring'''




   __A :      List[Any]     		=		BioGptTokenizer
   __A :      Optional[int]     		=		False






   def _snake_case    (		self ):






     """simple docstring"""





     super().setUp()

     # Adapted from Sennrich et al. 2015 and https://github.com/rsennrich/subword-nmt
     lowerCamelCase :					Union[str, Any]    =				[
         "l",
         "o",
         "w",
         "e",
         "r",
         "s",
         "t",
         "i",
         "d",
         "n",
         "w</w>",
         "r</w>",
         "t</w>",
         "lo",
         "low",
         "er</w>",
         "low</w>",
         "lowest</w>",
         "newer</w>",
         "wider</w>",
         "<unk>",
     ]
     lowerCamelCase :					str    =				dict(zip(__A						,				range(len(__A ) ) ) )
     lowerCamelCase :					Dict    =				["l o 123", "lo w 1456", "e r</w> 1789", ""]

     lowerCamelCase :					Dict    =				os.path.join(self.tmpdirname						,				VOCAB_FILES_NAMES["vocab_file"] )
     lowerCamelCase :					int    =				os.path.join(self.tmpdirname						,				VOCAB_FILES_NAMES["merges_file"] )
     with open(self.vocab_file						,				"w" ) as fp:
       fp.write(json.dumps(__A ) )
     with open(self.merges_file						,				"w" ) as fp:
       fp.write("\n".join(__A ) )






   def _snake_case    (		self						,				__A ):






     """simple docstring"""





     lowerCamelCase :					Dict    =				"lower newer"
     lowerCamelCase :					Union[str, Any]    =				"lower newer"
     return input_text, output_text






   def _snake_case    (		self ):






     """simple docstring"""





     lowerCamelCase :					List[str]    =				BioGptTokenizer(self.vocab_file						,				self.merges_file )

     lowerCamelCase :					Optional[int]    =				"lower"
     lowerCamelCase :					Any    =				["low", "er</w>"]
     lowerCamelCase :					List[str]    =				tokenizer.tokenize(__A )
     self.assertListEqual(__A						,				__A )

     lowerCamelCase :					Union[str, Any]    =				tokens + ["<unk>"]
     lowerCamelCase :					List[str]    =				[14, 15, 20]
     self.assertListEqual(tokenizer.convert_tokens_to_ids(__A )						,				__A )






   @slow
   def _snake_case    (		self ):






     """simple docstring"""





     lowerCamelCase :					List[str]    =				BioGptTokenizer.from_pretrained("microsoft/biogpt" )

     lowerCamelCase :					Optional[int]    =				tokenizer.encode("sequence builders"						,				add_special_tokens=__A )
     lowerCamelCase :					Tuple    =				tokenizer.encode("multi-sequence build"						,				add_special_tokens=__A )

     lowerCamelCase :					Tuple    =				tokenizer.build_inputs_with_special_tokens(__A )
     lowerCamelCase :					List[str]    =				tokenizer.build_inputs_with_special_tokens(__A						,				__A )

     self.assertTrue(encoded_sentence == [2] + text )
     self.assertTrue(encoded_pair == [2] + text + [2] + text_a )



