
"""simple docstring"""


import re
import string

import numpy as np

import datasets


_lowercase				 =					'''
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.
'''

_lowercase				 =					'''
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

'''

_lowercase				 =					'''
'''







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



						'''simple docstring'''


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

							if ignore_case:
								A     = np.char.lower(A_   )
								A     = np.char.lower(A_   )

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

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

							A     = predictions == references

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

"""simple docstring"""


import json
import os
import unittest

from transformers.models.blenderbot_small.tokenization_blenderbot_small import (
    VOCAB_FILES_NAMES,
    BlenderbotSmallTokenizer,
)

from ...test_tokenization_common import TokenizerTesterMixin







class 					lowerCAmelCase_					(   _lowercase		,       unittest.TestCase     ):



						'''simple docstring'''


						_lowerCamelCase:     Optional[int]   =     BlenderbotSmallTokenizer
						_lowerCamelCase:     List[Any]   =     False


						def     _SCREAMING_SNAKE_CASE   (			self  :   Optional[Any]   )  -> Tuple:
							super().setUp()

							A     = ['__start__', 'adapt', 'act', 'ap@@', 'te', '__end__', '__unk__']
							A     = dict(zip(A_	,range(len(A_   )   )   )   )

							A     = ['#version: 0.2', 'a p', 't e</w>', 'ap t</w>', 'a d', 'ad apt</w>', 'a c', 'ac t</w>', '']
							A     = {'unk_token': '__unk__', 'bos_token': '__start__', 'eos_token': '__end__'}

							A     = os.path.join(self.tmpdirname	,VOCAB_FILES_NAMES['vocab_file']   )
							A     = os.path.join(self.tmpdirname	,VOCAB_FILES_NAMES['merges_file']   )
							with open(self.vocab_file	,'w'	,encoding='utf-8'   ) as fp:
								fp.write(json.dumps(A_   ) + '\n'   )
							with open(self.merges_file	,'w'	,encoding='utf-8'   ) as fp:
								fp.write('\n'.join(A_   )   )


						def     _SCREAMING_SNAKE_CASE   (			self  :   List[Any]	,**A_  :   Union[str, Any]   )  -> Optional[int]:
							kwargs.update(self.special_tokens_map   )
							return BlenderbotSmallTokenizer.from_pretrained(self.tmpdirname	,**A_   )


						def     _SCREAMING_SNAKE_CASE   (			self  :   Optional[Any]	,A_  :   Tuple   )  -> List[Any]:
							A     = 'adapt act apte'
							A     = 'adapt act apte'
							return input_text, output_text


						def     _SCREAMING_SNAKE_CASE   (			self  :   List[Any]   )  -> List[str]:
							A     = BlenderbotSmallTokenizer(self.vocab_file	,self.merges_file	,**self.special_tokens_map   )
							A     = 'adapt act apte'
							A     = ['adapt', 'act', 'ap@@', 'te']
							A     = tokenizer.tokenize(A_   )
							self.assertListEqual(A_	,A_   )

							A     = [tokenizer.bos_token] + tokens + [tokenizer.eos_token]

							A     = [0, 1, 2, 3, 4, 5]
							self.assertListEqual(tokenizer.convert_tokens_to_ids(A_   )	,A_   )


						def     _SCREAMING_SNAKE_CASE   (			self  :   Optional[Any]   )  -> Tuple:
							A     = BlenderbotSmallTokenizer.from_pretrained('facebook/blenderbot-90M'   )
							assert tok('sam'   ).input_ids == [1384]
							A     = 'I am a small frog.'
							A     = tok([src_text]	,padding=A_	,truncation=A_   )['input_ids']
							A     = tok.batch_decode(A_	,skip_special_tokens=A_	,clean_up_tokenization_spaces=A_   )[0]
							assert src_text != decoded  # I wish it did!
							assert decoded == "i am a small frog ."




						def     _SCREAMING_SNAKE_CASE   (			self  :   Dict   )  -> int:
							A     = BlenderbotSmallTokenizer.from_pretrained('facebook/blenderbot-90M'   )
							A     = 'I am a small frog .'
							A     = '.'
							A     = tok(A_   )['input_ids']
							A     = tok(A_   )['input_ids']

							assert encoded[-1] == encoded_dot[0]