





import json
from typing import List, Optional, Tuple

from tokenizers import normalizers

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from .tokenization_electra import ElectraTokenizer


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

UpperCAmelCase	:	Union[str, Any]		     =       {
    """vocab_file""": {
        """google/electra-small-generator""": (
            """https://huggingface.co/google/electra-small-generator/resolve/main/vocab.txt"""
        ),
        """google/electra-base-generator""": """https://huggingface.co/google/electra-base-generator/resolve/main/vocab.txt""",
        """google/electra-large-generator""": (
            """https://huggingface.co/google/electra-large-generator/resolve/main/vocab.txt"""
        ),
        """google/electra-small-discriminator""": (
            """https://huggingface.co/google/electra-small-discriminator/resolve/main/vocab.txt"""
        ),
        """google/electra-base-discriminator""": (
            """https://huggingface.co/google/electra-base-discriminator/resolve/main/vocab.txt"""
        ),
        """google/electra-large-discriminator""": (
            """https://huggingface.co/google/electra-large-discriminator/resolve/main/vocab.txt"""
        ),
    },
    """tokenizer_file""": {
        """google/electra-small-generator""": (
            """https://huggingface.co/google/electra-small-generator/resolve/main/tokenizer.json"""
        ),
        """google/electra-base-generator""": (
            """https://huggingface.co/google/electra-base-generator/resolve/main/tokenizer.json"""
        ),
        """google/electra-large-generator""": (
            """https://huggingface.co/google/electra-large-generator/resolve/main/tokenizer.json"""
        ),
        """google/electra-small-discriminator""": (
            """https://huggingface.co/google/electra-small-discriminator/resolve/main/tokenizer.json"""
        ),
        """google/electra-base-discriminator""": (
            """https://huggingface.co/google/electra-base-discriminator/resolve/main/tokenizer.json"""
        ),
        """google/electra-large-discriminator""": (
            """https://huggingface.co/google/electra-large-discriminator/resolve/main/tokenizer.json"""
        ),
    },
}

UpperCAmelCase	:	List[str]		     =       {
    """google/electra-small-generator""": 512,
    """google/electra-base-generator""": 512,
    """google/electra-large-generator""": 512,
    """google/electra-small-discriminator""": 512,
    """google/electra-base-discriminator""": 512,
    """google/electra-large-discriminator""": 512,
}

UpperCAmelCase	:	Tuple		     =       {
    """google/electra-small-generator""": {"""do_lower_case""": True},
    """google/electra-base-generator""": {"""do_lower_case""": True},
    """google/electra-large-generator""": {"""do_lower_case""": True},
    """google/electra-small-discriminator""": {"""do_lower_case""": True},
    """google/electra-base-discriminator""": {"""do_lower_case""": True},
    """google/electra-large-discriminator""": {"""do_lower_case""": True},
}







class 				__lowerCAmelCase       (    UpperCamelCase__):
      _lowercase				:					List[str]						=			VOCAB_FILES_NAMES
      _lowercase				:					List[str]						=			PRETRAINED_VOCAB_FILES_MAP
      _lowercase				:					Tuple						=			PRETRAINED_INIT_CONFIGURATION
      _lowercase				:					Optional[Any]						=			PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
      _lowercase				:					List[Any]						=			ElectraTokenizer







      def __init__(    self		,      lowerCAmelCase__=None		,      lowerCAmelCase__=None		,      lowerCAmelCase__=True		,      lowerCAmelCase__="[UNK]"		,      lowerCAmelCase__="[SEP]"		,      lowerCAmelCase__="[PAD]"		,      lowerCAmelCase__="[CLS]"		,      lowerCAmelCase__="[MASK]"		,      lowerCAmelCase__=True		,      lowerCAmelCase__=None		,      **lowerCAmelCase__		,      )   ->						List[str]:



        '''simple docstring'''




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

        a__	:					Optional[int]										=json.loads(self.backend_tokenizer.normalizer.__getstate__()							)
        if (
            normalizer_state.get("lowercase"		,      lowerCAmelCase__							) != do_lower_case
            or normalizer_state.get("strip_accents"		,      lowerCAmelCase__							) != strip_accents
            or normalizer_state.get("handle_chinese_chars"		,      lowerCAmelCase__							) != tokenize_chinese_chars
        ):
          a__	:					Tuple										=getattr(lowerCAmelCase__		,      normalizer_state.pop("type"							)							)
          a__	:					List[Any]										=do_lower_case
          a__	:					Optional[int]										=strip_accents
          a__	:					str										=tokenize_chinese_chars
          a__	:					str										=normalizer_class(**lowerCAmelCase__							)

        a__	:					List[Any]										=do_lower_case







      def    _lowercase  (    self		,      lowerCAmelCase__		,      lowerCAmelCase__=None							)   ->						Tuple:



        '''simple docstring'''




        a__	:					str										=[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    _lowercase  (    self		,      lowerCAmelCase__		,      lowerCAmelCase__ = None							)   ->						List[int]:



        '''simple docstring'''




        a__	:					List[Any]										=[self.sep_token_id]
        a__	:					Tuple										=[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    _lowercase  (    self		,      lowerCAmelCase__		,      lowerCAmelCase__ = None							)   ->						Tuple[str]:



        '''simple docstring'''




        a__	:					List[Any]										=self._tokenizer.model.save(lowerCAmelCase__		,      name=lowerCAmelCase__							)
        return tuple(lowerCAmelCase__							)








"""simple docstring"""



import os
from shutil import copyfile
from typing import List, Optional, Tuple

import sentencepiece as spm

from ...tokenization_utils import PreTrainedTokenizer
from ...utils import logging


UpperCAmelCase__          = logging.get_logger(__name__)

UpperCAmelCase__          = {'vocab_file': 'sentencepiece.model'}

UpperCAmelCase__          = {
    'vocab_file': {
        'google/rembert': 'https://huggingface.co/google/rembert/resolve/main/sentencepiece.model',
    },
}

UpperCAmelCase__          = {
    'google/rembert': 256,
}

class       lowerCAmelCase__				(						A_	):
     __a						=					VOCAB_FILES_NAMES
     __a						=					PRETRAINED_VOCAB_FILES_MAP
     __a						=					PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES







     def __init__(							self			:			Union[str, Any]    ,      _lowerCamelCase			:			Any    ,      _lowerCamelCase			:			Union[str, Any]=False    ,      _lowerCamelCase			:			Any=True    ,      _lowerCamelCase			:			Optional[Any]=True    ,      _lowerCamelCase			:			int="[CLS]"    ,      _lowerCamelCase			:			Optional[int]="[SEP]"    ,      _lowerCamelCase			:			Optional[int]="[UNK]"    ,      _lowerCamelCase			:			Optional[Any]="[SEP]"    ,      _lowerCamelCase			:			str="[PAD]"    ,      _lowerCamelCase			:			List[Any]="[CLS]"    ,      _lowerCamelCase			:			Any="[MASK]"    ,      **_lowerCamelCase			:			Optional[int]    ,      ):
       super().__init__(
           do_lower_case=_lowerCamelCase    ,      remove_space=_lowerCamelCase    ,      keep_accents=_lowerCamelCase    ,      bos_token=_lowerCamelCase    ,      eos_token=_lowerCamelCase    ,      unk_token=_lowerCamelCase    ,      sep_token=_lowerCamelCase    ,      pad_token=_lowerCamelCase    ,      cls_token=_lowerCamelCase    ,      mask_token=_lowerCamelCase    ,      **_lowerCamelCase    ,      )

       _snake_case					     =       do_lower_case
       _snake_case					     =       remove_space
       _snake_case					     =       keep_accents
       _snake_case					     =       vocab_file

       _snake_case					     =       spm.SentencePieceProcessor()
       self.sp_model.Load(_lowerCamelCase			)







     @property
     def      lowercase	(							self			:			int			):
       return len(self.sp_model			)







     def      lowercase	(							self			:			Any			):
       _snake_case					     =       {self.convert_ids_to_tokens(_lowerCamelCase			): i for i in range(self.vocab_size			)}
       vocab.update(self.added_tokens_encoder			)
       return vocab







     def __getstate__(							self			:			List[str]			):
       _snake_case					     =       self.__dict__.copy()
       _snake_case					     =       None
       return state







     def __setstate__(							self			:			List[str]    ,      _lowerCamelCase			:			Tuple			):
       _snake_case					     =       d
       _snake_case					     =       spm.SentencePieceProcessor()
       self.sp_model.Load(self.vocab_file			)







     def      lowercase	(							self			:			str    ,      _lowerCamelCase			:			List[str]    ,      _lowerCamelCase			:			Tuple=False			):
       _snake_case					     =       self.sp_model.EncodeAsPieces(_lowerCamelCase			)
       return pieces







     def      lowercase	(							self			:			str    ,      _lowerCamelCase			:			str			):
       return self.sp_model.PieceToId(_lowerCamelCase			)







     def      lowercase	(							self			:			List[str]    ,      _lowerCamelCase			:			int			):
       return self.sp_model.IdToPiece(_lowerCamelCase			)







     def      lowercase	(							self			:			Union[str, Any]    ,      _lowerCamelCase			:			Any			):
       _snake_case					     =       self.sp_model.decode_pieces(_lowerCamelCase			)
       return out_string







     def      lowercase	(							self			:			Optional[Any]    ,      _lowerCamelCase			:			List[int]    ,      _lowerCamelCase			:			Optional[List[int]] = None			):
       _snake_case					     =       [self.sep_token_id]
       _snake_case					     =       [self.cls_token_id]
       if token_ids_a is None:
         return cls + token_ids_a + sep
       return cls + token_ids_a + sep + token_ids_a + sep







     def      lowercase	(							self			:			Tuple    ,      _lowerCamelCase			:			List[int]    ,      _lowerCamelCase			:			Optional[List[int]] = None    ,      _lowerCamelCase			:			bool = False			):

       if already_has_special_tokens:
         if token_ids_a is not None:
           raise ValueError(
               '''You should not supply a second sequence if the provided sequence of '''
               '''ids is already formatted with special tokens for the model.'''			)
         return [1 if x in [self.sep_token_id, self.cls_token_id] else 0 for x in token_ids_a]

       if token_ids_a is not None:
         return [1] + ([0] * len(_lowerCamelCase			)) + [1] + ([0] * len(_lowerCamelCase			)) + [1]
       return [1] + ([0] * len(_lowerCamelCase			)) + [1]







     def      lowercase	(							self			:			Optional[int]    ,      _lowerCamelCase			:			List[int]    ,      _lowerCamelCase			:			Optional[List[int]] = None			):
       _snake_case					     =       [self.sep_token_id]
       _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      lowercase	(							self			:			List[str]    ,      _lowerCamelCase			:			str    ,      _lowerCamelCase			:			Optional[str] = None			):
       if not os.path.isdir(_lowerCamelCase			):
         logger.error('''Vocabulary path ({}) should be a directory'''.format(_lowerCamelCase			)			)
         return
       _snake_case					     =       os.path.join(
           _lowerCamelCase    ,      (filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''vocab_file''']			)

       if os.path.abspath(self.vocab_file			) != os.path.abspath(_lowerCamelCase			):
         copyfile(self.vocab_file    ,      _lowerCamelCase			)

       return (out_vocab_file,)



