





'''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 ..utils import DummyObject, requires_backends







class 							A__   (	metaclass=A__  ):
  A__					=    ['note_seq']





  def __init__(		self				:     List[str]							, *_a				:     Any							, **_a				:     Dict			)     ->   Optional[Any]:





       '''simple docstring'''






       requires_backends(self							, ['note_seq']			)





  @classmethod
  def 						A  (		cls				:     Any							, *_a				:     str							, **_a				:     List[Any]			)     ->   List[str]:





       '''simple docstring'''






       requires_backends(cls							, ['note_seq']			)





  @classmethod
  def 						A  (		cls				:     int							, *_a				:     Optional[Any]							, **_a				:     Optional[int]			)     ->   Tuple:





       '''simple docstring'''






       requires_backends(cls							, ['note_seq']			)
