

'''simple docstring'''
import json
from typing import List, Optional, Tuple

from tokenizers import normalizers

from ...tokenization_utils_base import BatchEncoding
from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import PaddingStrategy, logging
from .tokenization_realm import RealmTokenizer


lowerCamelCase			:				Optional[int] 			=					logging.get_logger(__name__)

lowerCamelCase			:				Optional[int] 			=					{"vocab_file": "vocab.txt", "tokenizer_file": "tokenizer.json"}

lowerCamelCase			:				int 			=					{
    "vocab_file": {
        "google/realm-cc-news-pretrained-embedder": (
            "https://huggingface.co/google/realm-cc-news-pretrained-embedder/resolve/main/vocab.txt"
        ),
        "google/realm-cc-news-pretrained-encoder": (
            "https://huggingface.co/google/realm-cc-news-pretrained-encoder/resolve/main/vocab.txt"
        ),
        "google/realm-cc-news-pretrained-scorer": (
            "https://huggingface.co/google/realm-cc-news-pretrained-scorer/resolve/main/vocab.txt"
        ),
        "google/realm-cc-news-pretrained-openqa": (
            "https://huggingface.co/google/realm-cc-news-pretrained-openqa/aresolve/main/vocab.txt"
        ),
        "google/realm-orqa-nq-openqa": "https://huggingface.co/google/realm-orqa-nq-openqa/resolve/main/vocab.txt",
        "google/realm-orqa-nq-reader": "https://huggingface.co/google/realm-orqa-nq-reader/resolve/main/vocab.txt",
        "google/realm-orqa-wq-openqa": "https://huggingface.co/google/realm-orqa-wq-openqa/resolve/main/vocab.txt",
        "google/realm-orqa-wq-reader": "https://huggingface.co/google/realm-orqa-wq-reader/resolve/main/vocab.txt",
    },
    "tokenizer_file": {
        "google/realm-cc-news-pretrained-embedder": (
            "https://huggingface.co/google/realm-cc-news-pretrained-embedder/resolve/main/tokenizer.jsont"
        ),
        "google/realm-cc-news-pretrained-encoder": (
            "https://huggingface.co/google/realm-cc-news-pretrained-encoder/resolve/main/tokenizer.json"
        ),
        "google/realm-cc-news-pretrained-scorer": (
            "https://huggingface.co/google/realm-cc-news-pretrained-scorer/resolve/main/tokenizer.json"
        ),
        "google/realm-cc-news-pretrained-openqa": (
            "https://huggingface.co/google/realm-cc-news-pretrained-openqa/aresolve/main/tokenizer.json"
        ),
        "google/realm-orqa-nq-openqa": (
            "https://huggingface.co/google/realm-orqa-nq-openqa/resolve/main/tokenizer.json"
        ),
        "google/realm-orqa-nq-reader": (
            "https://huggingface.co/google/realm-orqa-nq-reader/resolve/main/tokenizer.json"
        ),
        "google/realm-orqa-wq-openqa": (
            "https://huggingface.co/google/realm-orqa-wq-openqa/resolve/main/tokenizer.json"
        ),
        "google/realm-orqa-wq-reader": (
            "https://huggingface.co/google/realm-orqa-wq-reader/resolve/main/tokenizer.json"
        ),
    },
}

lowerCamelCase			:				Optional[int] 			=					{
    "google/realm-cc-news-pretrained-embedder": 5_1_2,
    "google/realm-cc-news-pretrained-encoder": 5_1_2,
    "google/realm-cc-news-pretrained-scorer": 5_1_2,
    "google/realm-cc-news-pretrained-openqa": 5_1_2,
    "google/realm-orqa-nq-openqa": 5_1_2,
    "google/realm-orqa-nq-reader": 5_1_2,
    "google/realm-orqa-wq-openqa": 5_1_2,
    "google/realm-orqa-wq-reader": 5_1_2,
}

lowerCamelCase			:				Tuple 			=					{
    "google/realm-cc-news-pretrained-embedder": {"do_lower_case": True},
    "google/realm-cc-news-pretrained-encoder": {"do_lower_case": True},
    "google/realm-cc-news-pretrained-scorer": {"do_lower_case": True},
    "google/realm-cc-news-pretrained-openqa": {"do_lower_case": True},
    "google/realm-orqa-nq-openqa": {"do_lower_case": True},
    "google/realm-orqa-nq-reader": {"do_lower_case": True},
    "google/realm-orqa-wq-openqa": {"do_lower_case": True},
    "google/realm-orqa-wq-reader": {"do_lower_case": True},
}







class 							A__   (	A__  ):
  A__					=    VOCAB_FILES_NAMES
  A__					=    PRETRAINED_VOCAB_FILES_MAP
  A__					=    PRETRAINED_INIT_CONFIGURATION
  A__					=    PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
  A__					=    RealmTokenizer





  def __init__(		self				:     Optional[Any]							, _a				:     Dict=None							, _a				:     Any=None							, _a				:     List[Any]=True							, _a				:     List[Any]="[UNK]"							, _a				:     Dict="[SEP]"							, _a				:     Optional[int]="[PAD]"							, _a				:     Optional[Any]="[CLS]"							, _a				:     Optional[int]="[MASK]"							, _a				:     Optional[int]=True							, _a				:     int=None							, **_a				:     int							, )     ->   Optional[int]:





       '''simple docstring'''






       super().__init__(
           _a							, tokenizer_file=_a							, do_lower_case=_a							, unk_token=_a							, sep_token=_a							, pad_token=_a							, cls_token=_a							, mask_token=_a							, tokenize_chinese_chars=_a							, strip_accents=_a							, **_a							, )

       _SCREAMING_SNAKE_CASE							   =json.loads(self.backend_tokenizer.normalizer.__getstate__()			)
       if (
           normalizer_state.get('lowercase'							, _a			) != do_lower_case
           or normalizer_state.get('strip_accents'							, _a			) != strip_accents
           or normalizer_state.get('handle_chinese_chars'							, _a			) != tokenize_chinese_chars
       ):
            _SCREAMING_SNAKE_CASE							   =getattr(_a							, normalizer_state.pop('type'			)			)
            _SCREAMING_SNAKE_CASE							   =do_lower_case
            _SCREAMING_SNAKE_CASE							   =strip_accents
            _SCREAMING_SNAKE_CASE							   =tokenize_chinese_chars
            _SCREAMING_SNAKE_CASE							   =normalizer_class(**_a			)

       _SCREAMING_SNAKE_CASE							   =do_lower_case





  def 						A  (		self				:     Tuple							, _a				:     str							, **_a				:     Optional[Any]			)     ->   str:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =PaddingStrategy.MAX_LENGTH

       _SCREAMING_SNAKE_CASE							   =text
       _SCREAMING_SNAKE_CASE							   =kwargs.pop('text_pair'							, _a			)
       _SCREAMING_SNAKE_CASE							   =kwargs.pop('return_tensors'							, _a			)

       _SCREAMING_SNAKE_CASE							   ={
           'input_ids': [],
           'attention_mask': [],
           'token_type_ids': [],
       }

       for idx, candidate_text in enumerate(_a			):
            if batch_text_pair is not None:
                 _SCREAMING_SNAKE_CASE							   =batch_text_pair[idx]
            else:
                 _SCREAMING_SNAKE_CASE							   =None

            _SCREAMING_SNAKE_CASE							   =super().__call__(_a							, _a							, return_tensors=_a							, **_a			)

            _SCREAMING_SNAKE_CASE							   =encoded_candidates.get('input_ids'			)
            _SCREAMING_SNAKE_CASE							   =encoded_candidates.get('attention_mask'			)
            _SCREAMING_SNAKE_CASE							   =encoded_candidates.get('token_type_ids'			)

            if encoded_input_ids is not None:
                 output_data["input_ids"].append(_a			)
            if encoded_attention_mask is not None:
                 output_data["attention_mask"].append(_a			)
            if encoded_token_type_ids is not None:
                 output_data["token_type_ids"].append(_a			)

       _SCREAMING_SNAKE_CASE							   ={key: item for key, item in output_data.items() if len(_a			) != 0}

       return BatchEncoding(_a							, tensor_type=_a			)





  def 						A  (		self				:     List[str]							, _a				:     List[str]							, _a				:     Tuple=None			)     ->   str:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =[self.cls_token_id] + token_ids_a + [self.sep_token_id]

       if token_ids_a:
            output += token_ids_a + [self.sep_token_id]

       return output





  def 						A  (		self				:     Dict							, _a				:     List[int]							, _a				:     Optional[List[int]] = None			)     ->   List[int]:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =[self.sep_token_id]
       _SCREAMING_SNAKE_CASE							   =[self.cls_token_id]
       if token_ids_a is None:
            return len(cls + token_ids_a + sep			) * [0]
       return len(cls + token_ids_a + sep			) * [0] + len(token_ids_a + sep			) * [1]





  def 						A  (		self				:     Dict							, _a				:     str							, _a				:     Optional[str] = None			)     ->   Tuple[str]:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =self._tokenizer.model.save(_a							, name=_a			)
       return tuple(_a			)



'''simple docstring'''
from scipy.stats import pearsonr, spearmanr
from sklearn.metrics import fa_score, matthews_corrcoef

import datasets


lowerCamelCase			:				List[Any] 			=					"\\n@inproceedings{wang2019glue,\n  title={{GLUE}: A Multi-Task Benchmark and Analysis Platform for Natural Language Understanding},\n  author={Wang, Alex and Singh, Amanpreet and Michael, Julian and Hill, Felix and Levy, Omer and Bowman, Samuel R.},\n  note={In the Proceedings of ICLR.},\n  year={2019}\n}\n"

lowerCamelCase			:				List[str] 			=					"\\nGLUE, the General Language Understanding Evaluation benchmark\n(https://gluebenchmark.com/) is a collection of resources for training,\nevaluating, and analyzing natural language understanding systems.\n"

lowerCamelCase			:				Dict 			=					"\nCompute GLUE evaluation metric associated to each GLUE dataset.\nArgs:\n    predictions: list of predictions to score.\n        Each translation should be tokenized into a list of tokens.\n    references: list of lists of references for each translation.\n        Each reference should be tokenized into a list of tokens.\nReturns: depending on the GLUE subset, one or several of:\n    \"accuracy\": Accuracy\n    \"f1\": F1 score\n    \"pearson\": Pearson Correlation\n    \"spearmanr\": Spearman Correlation\n    \"matthews_correlation\": Matthew Correlation\nExamples:\n\n    >>> glue_metric = datasets.load_metric('glue', 'sst2')  # 'sst2' or any of [\"mnli\", \"mnli_mismatched\", \"mnli_matched\", \"qnli\", \"rte\", \"wnli\", \"hans\"]\n    >>> references = [0, 1]\n    >>> predictions = [0, 1]\n    >>> results = glue_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {'accuracy': 1.0}\n\n    >>> glue_metric = datasets.load_metric('glue', 'mrpc')  # 'mrpc' or 'qqp'\n    >>> references = [0, 1]\n    >>> predictions = [0, 1]\n    >>> results = glue_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {'accuracy': 1.0, 'f1': 1.0}\n\n    >>> glue_metric = datasets.load_metric('glue', 'stsb')\n    >>> references = [0., 1., 2., 3., 4., 5.]\n    >>> predictions = [0., 1., 2., 3., 4., 5.]\n    >>> results = glue_metric.compute(predictions=predictions, references=references)\n    >>> print({\"pearson\": round(results[\"pearson\"], 2), \"spearmanr\": round(results[\"spearmanr\"], 2)})\n    {'pearson': 1.0, 'spearmanr': 1.0}\n\n    >>> glue_metric = datasets.load_metric('glue', 'cola')\n    >>> references = [0, 1]\n    >>> predictions = [0, 1]\n    >>> results = glue_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {'matthews_correlation': 1.0}\n"


def 	_lowerCAmelCase (						_UpperCamelCase						:					List[Any]							,			_UpperCamelCase						:					Dict    )				->      List[str]:
     """simple docstring"""




     return float((preds == labels).mean()    )


def 	_lowerCAmelCase (						_UpperCamelCase						:					Dict							,			_UpperCamelCase						:					Any    )				->      Tuple:
     """simple docstring"""




     _SCREAMING_SNAKE_CASE							   =simple_accuracy(_UpperCamelCase							,			_UpperCamelCase    )
     _SCREAMING_SNAKE_CASE							   =float(fa_score(y_true=_UpperCamelCase							,			y_pred=_UpperCamelCase    )    )
     return {
         "accuracy": acc,
         "f1": fa,
     }


def 	_lowerCAmelCase (						_UpperCamelCase						:					Optional[int]							,			_UpperCamelCase						:					Optional[int]    )				->      Dict:
     """simple docstring"""




     _SCREAMING_SNAKE_CASE							   =float(pearsonr(_UpperCamelCase							,			_UpperCamelCase    )[0]    )
     _SCREAMING_SNAKE_CASE							   =float(spearmanr(_UpperCamelCase							,			_UpperCamelCase    )[0]    )
     return {
         "pearson": pearson_corr,
         "spearmanr": spearman_corr,
     }







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





  def 						A  (		self				:     Optional[int]			)     ->   Any:





       '''simple docstring'''






       if self.config_name not in [
           "sst2",
           "mnli",
           "mnli_mismatched",
           "mnli_matched",
           "cola",
           "stsb",
           "mrpc",
           "qqp",
           "qnli",
           "rte",
           "wnli",
           "hans",
       ]:
            raise KeyError(
                'You should supply a configuration name selected in '
                '["sst2", "mnli", "mnli_mismatched", "mnli_matched", '
                '"cola", "stsb", "mrpc", "qqp", "qnli", "rte", "wnli", "hans"]'			)
       return datasets.MetricInfo(
           description=_DESCRIPTION							, citation=_CITATION							, inputs_description=_KWARGS_DESCRIPTION							, features=datasets.Features(
               {
                   'predictions': datasets.Value('int64' if self.config_name != 'stsb' else 'float32'			),
                   'references': datasets.Value('int64' if self.config_name != 'stsb' else 'float32'			),
               }			)							, codebase_urls=[]							, reference_urls=[]							, format='numpy'							, )





  def 						A  (		self				:     str							, _a				:     str							, _a				:     List[Any]			)     ->   str:





       '''simple docstring'''






       if self.config_name == "cola":
            return {"matthews_correlation": matthews_corrcoef(_a							, _a			)}
       elif self.config_name == "stsb":
            return pearson_and_spearman(_a							, _a			)
       elif self.config_name in ["mrpc", "qqp"]:
            return acc_and_fa(_a							, _a			)
       elif self.config_name in ["sst2", "mnli", "mnli_mismatched", "mnli_matched", "qnli", "rte", "wnli", "hans"]:
            return {"accuracy": simple_accuracy(_a							, _a			)}
       else:
            raise KeyError(
                'You should supply a configuration name selected in '
                '["sst2", "mnli", "mnli_mismatched", "mnli_matched", '
                '"cola", "stsb", "mrpc", "qqp", "qnli", "rte", "wnli", "hans"]'			)
