



import os
import unicodedata
from shutil import copyfile
from typing import Any, Dict, List, Optional, Tuple

import sentencepiece as spm

from ...tokenization_utils import AddedToken, PreTrainedTokenizer
from ...utils import SPIECE_UNDERLINE, logging


A__								=						logging.get_logger(__name__)

A__								=						{'''vocab_file''': '''spiece.model'''}

A__								=						{
    '''vocab_file''': {
        '''TsinghuaAI/CPM-Generate''': '''https://huggingface.co/TsinghuaAI/CPM-Generate/resolve/main/spiece.model''',
    }
}


class       a							(			__lowerCamelCase				):



		def __init__(     self     :Union[str, Any]   ,__lowercase     :Optional[Any]   ,__lowercase     :int=False   ,__lowercase     :int=True   ,__lowercase     :Optional[int]=False   ,__lowercase     :List[str]="<s>"   ,__lowercase     :str="</s>"   ,__lowercase     :Dict="<unk>"   ,__lowercase     :Optional[int]="<sep>"   ,__lowercase     :Tuple="<pad>"   ,__lowercase     :Union[str, Any]="<cls>"   ,__lowercase     :Dict="<mask>"   ,__lowercase     :List[Any]=["<eop>", "<eod>"]   ,__lowercase     :Optional[Dict[str, Any]] = None   ,**__lowercase     :int   ,):
						snake_case__	:      Any     		=	AddedToken(__lowercase   ,lstrip=__lowercase   ,rstrip=__lowercase  ) if isinstance(__lowercase   ,__lowercase  ) else mask_token

						snake_case__	:      Tuple     		=	{} if sp_model_kwargs is None else sp_model_kwargs

						super().__init__(
						    do_lower_case=__lowercase   ,remove_space=__lowercase   ,keep_accents=__lowercase   ,bos_token=__lowercase   ,eos_token=__lowercase   ,unk_token=__lowercase   ,sep_token=__lowercase   ,pad_token=__lowercase   ,cls_token=__lowercase   ,mask_token=__lowercase   ,additional_special_tokens=__lowercase   ,sp_model_kwargs=self.sp_model_kwargs   ,**__lowercase   ,)

						snake_case__	:      Optional[Any]     		=	3

						snake_case__	:      List[str]     		=	do_lower_case
						snake_case__	:      Union[str, Any]     		=	remove_space
						snake_case__	:      Tuple     		=	keep_accents
						snake_case__	:      List[str]     		=	vocab_file

						snake_case__	:      Optional[Any]     		=	spm.SentencePieceProcessor(**self.sp_model_kwargs  )
						self.sp_model.Load(__lowercase  )

						try:
										import jieba
						except ModuleNotFoundError as error:
										raise error.__class__(
										    '''You need to install jieba to use CpmTokenizer or CpmTokenizerFast. '''
										    '''See https://pypi.org/project/jieba/ for installation.'''  )
						snake_case__	:      List[Any]     		=	jieba
						snake_case__	:      Union[str, Any]     		=	str.maketrans(''' \n'''   ,'''\u2582\u2583'''  )



		@property
		# Copied from transformers.models.xlnet.tokenization_xlnet.XLNetTokenizer.vocab_size
		def 	__lowerCamelCase			(     self     :Union[str, Any]  ):
						return len(self.sp_model  )



		def 	__lowerCamelCase			(     self     :Any  ):
						snake_case__	:      Optional[Any]     		=	{self.convert_ids_to_tokens(__lowercase  ): i for i in range(self.vocab_size  )}
						vocab.update(self.added_tokens_encoder  )
						return vocab



		def __getstate__(     self     :List[str]  ):
						snake_case__	:      Optional[Any]     		=	self.__dict__.copy()
						snake_case__	:      Optional[int]     		=	None
						return state



		def __setstate__(     self     :int   ,__lowercase     :str  ):
						snake_case__	:      Tuple     		=	d

						# for backward compatibility
						if not hasattr(self   ,'''sp_model_kwargs'''  ):
										snake_case__	:      List[Any]     		=	{}

						snake_case__	:      List[Any]     		=	spm.SentencePieceProcessor(**self.sp_model_kwargs  )
						self.sp_model.Load(self.vocab_file  )



		def 	__lowerCamelCase			(     self     :Dict   ,__lowercase     :Optional[int]  ):
						if self.remove_space:
										snake_case__	:      int     		=	''' '''.join(inputs.strip().split()  )
						else:
										snake_case__	:      Tuple     		=	inputs
						snake_case__	:      List[Any]     		=	outputs.replace('''``'''   ,'''"'''  ).replace('''\'\''''   ,'''"'''  )

						if not self.keep_accents:
										snake_case__	:      Any     		=	unicodedata.normalize('''NFKD'''   ,__lowercase  )
										snake_case__	:      Dict     		=	''''''.join([c for c in outputs if not unicodedata.combining(__lowercase  )]  )
						if self.do_lower_case:
										snake_case__	:      str     		=	outputs.lower()

						return outputs



		def 	__lowerCamelCase			(     self     :Optional[Any]   ,__lowercase     :str  ):
						snake_case__	:      Dict     		=	self.preprocess_text(__lowercase  )
						snake_case__	:      Any     		=	self.sp_model.encode(__lowercase   ,out_type=__lowercase  )
						snake_case__	:      List[str]     		=	[]
						for piece in pieces:
										if len(__lowercase  ) > 1 and piece[-1] == str(''','''  ) and piece[-2].isdigit():
														snake_case__	:      Union[str, Any]     		=	self.sp_model.EncodeAsPieces(piece[:-1].replace(__lowercase   ,''''''  )  )
														if piece[0] != SPIECE_UNDERLINE and cur_pieces[0][0] == SPIECE_UNDERLINE:
																		if len(cur_pieces[0]  ) == 1:
																						snake_case__	:      Optional[Any]     		=	cur_pieces[1:]
																		else:
																						snake_case__	:      Optional[Any]     		=	cur_pieces[0][1:]
														cur_pieces.append(piece[-1]  )
														new_pieces.extend(__lowercase  )
										else:
														new_pieces.append(__lowercase  )

						return new_pieces



		def 	__lowerCamelCase			(     self     :Union[str, Any]   ,__lowercase     :Dict  ):
						return self.sp_model.PieceToId(__lowercase  )



		def 	__lowerCamelCase			(     self     :Tuple   ,__lowercase     :Optional[int]  ):
						return self.sp_model.IdToPiece(__lowercase  )



		def 	__lowerCamelCase			(     self     :Tuple   ,__lowercase     :List[Any]  ):
						snake_case__	:      Union[str, Any]     		=	''''''.join(__lowercase  ).replace(__lowercase   ,''' '''  ).strip()
						return out_string



		def 	__lowerCamelCase			(     self     :List[Any]   ,__lowercase     :List[int]   ,__lowercase     :Optional[List[int]] = None  ):
						snake_case__	:      Optional[Any]     		=	[self.sep_token_id]
						snake_case__	:      str     		=	[self.cls_token_id]
						if token_ids_a is None:
										return token_ids_a + sep + cls
						return token_ids_a + sep + token_ids_a + sep + cls



		def 	__lowerCamelCase			(     self     :str   ,__lowercase     :List[int]   ,__lowercase     :Optional[List[int]] = None   ,__lowercase     :bool = False  ):

						if already_has_special_tokens:
										return super().get_special_tokens_mask(
										    token_ids_a=__lowercase   ,token_ids_a=__lowercase   ,already_has_special_tokens=__lowercase  )

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



		def 	__lowerCamelCase			(     self     :List[str]   ,__lowercase     :List[int]   ,__lowercase     :Optional[List[int]] = None  ):
						snake_case__	:      List[Any]     		=	[self.sep_token_id]
						snake_case__	:      Optional[Any]     		=	[2]

						if token_ids_a is None:
										return len(token_ids_a + sep  ) * [0] + cls_segment_id
						return len(token_ids_a + sep  ) * [0] + len(token_ids_a + sep  ) * [1] + cls_segment_id



		def 	__lowerCamelCase			(     self     :Optional[int]   ,__lowercase     :str   ,__lowercase     :Optional[str] = None  ):
						if not os.path.isdir(__lowercase  ):
										logger.error(F"""Vocabulary path ({save_directory}) should be a directory"""  )
										return
						snake_case__	:      Union[str, Any]     		=	os.path.join(
						    __lowercase   ,(filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''vocab_file''']  )

						if os.path.abspath(self.vocab_file  ) != os.path.abspath(__lowercase  ) and os.path.isfile(self.vocab_file  ):
										copyfile(self.vocab_file   ,__lowercase  )
						elif not os.path.isfile(self.vocab_file  ):
										with open(__lowercase   ,'''wb'''  ) as fi:
														snake_case__	:      str     		=	self.sp_model.serialized_model_proto()
														fi.write(__lowercase  )

						return (out_vocab_file,)






		def 	__lowerCamelCase			(     self     :Union[str, Any]   ,*__lowercase     :Optional[int]   ,**__lowercase     :Dict  ):
						snake_case__	:      Dict     		=	super()._decode(*__lowercase   ,**__lowercase  )
						snake_case__	:      List[Any]     		=	text.replace(''' '''   ,''''''  ).replace('''\u2582'''   ,''' '''  ).replace('''\u2583'''   ,'''\n'''  )
						return text






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


A__								=						logging.get_logger(__name__)

A__								=						{'''vocab_file''': '''vocab.txt''', '''tokenizer_file''': '''tokenizer.json'''}

A__								=						{
    '''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'''
        ),
    },
}

A__								=						{
    '''google/realm-cc-news-pretrained-embedder''': 512,
    '''google/realm-cc-news-pretrained-encoder''': 512,
    '''google/realm-cc-news-pretrained-scorer''': 512,
    '''google/realm-cc-news-pretrained-openqa''': 512,
    '''google/realm-orqa-nq-openqa''': 512,
    '''google/realm-orqa-nq-reader''': 512,
    '''google/realm-orqa-wq-openqa''': 512,
    '''google/realm-orqa-wq-reader''': 512,
}

A__								=						{
    '''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							(			__lowerCamelCase				):
		__lowerCAmelCase	:    List[Any]											=					VOCAB_FILES_NAMES
		__lowerCAmelCase	:    Optional[Any]											=					PRETRAINED_VOCAB_FILES_MAP
		__lowerCAmelCase	:    Optional[Any]											=					PRETRAINED_INIT_CONFIGURATION
		__lowerCAmelCase	:    Optional[Any]											=					PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
		__lowerCAmelCase	:    Optional[Any]											=					RealmTokenizer



		def __init__(     self     :Optional[Any]   ,__lowercase     :Dict=None   ,__lowercase     :Optional[int]=None   ,__lowercase     :Optional[Any]=True   ,__lowercase     :Optional[int]="[UNK]"   ,__lowercase     :List[str]="[SEP]"   ,__lowercase     :List[str]="[PAD]"   ,__lowercase     :int="[CLS]"   ,__lowercase     :str="[MASK]"   ,__lowercase     :Dict=True   ,__lowercase     :List[str]=None   ,**__lowercase     :Any   ,):
						super().__init__(
						    __lowercase   ,tokenizer_file=__lowercase   ,do_lower_case=__lowercase   ,unk_token=__lowercase   ,sep_token=__lowercase   ,pad_token=__lowercase   ,cls_token=__lowercase   ,mask_token=__lowercase   ,tokenize_chinese_chars=__lowercase   ,strip_accents=__lowercase   ,**__lowercase   ,)

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

						snake_case__	:      Tuple     		=	do_lower_case



		def 	__lowerCamelCase			(     self     :Union[str, Any]   ,__lowercase     :Union[str, Any]   ,**__lowercase     :Any  ):
						snake_case__	:      Dict     		=	PaddingStrategy.MAX_LENGTH

						snake_case__	:      List[str]     		=	text
						snake_case__	:      int     		=	kwargs.pop('''text_pair'''   ,__lowercase  )
						snake_case__	:      Optional[int]     		=	kwargs.pop('''return_tensors'''   ,__lowercase  )

						snake_case__	:      str     		=	{
						    '''input_ids''': [],
						    '''attention_mask''': [],
						    '''token_type_ids''': [],
						}

						for idx, candidate_text in enumerate(__lowercase  ):
										if batch_text_pair is not None:
														snake_case__	:      Optional[int]     		=	batch_text_pair[idx]
										else:
														snake_case__	:      Tuple     		=	None

										snake_case__	:      List[str]     		=	super().__call__(__lowercase   ,__lowercase   ,return_tensors=__lowercase   ,**__lowercase  )

										snake_case__	:      Optional[Any]     		=	encoded_candidates.get('''input_ids'''  )
										snake_case__	:      Optional[Any]     		=	encoded_candidates.get('''attention_mask'''  )
										snake_case__	:      List[Any]     		=	encoded_candidates.get('''token_type_ids'''  )

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

						snake_case__	:      Any     		=	{key: item for key, item in output_data.items() if len(__lowercase  ) != 0}

						return BatchEncoding(__lowercase   ,tensor_type=__lowercase  )



		def 	__lowerCamelCase			(     self     :List[Any]   ,__lowercase     :Tuple   ,__lowercase     :Tuple=None  ):
						snake_case__	:      List[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 	__lowerCamelCase			(     self     :List[str]   ,__lowercase     :List[int]   ,__lowercase     :Optional[List[int]] = None  ):
						snake_case__	:      Tuple     		=	[self.sep_token_id]
						snake_case__	:      Union[str, Any]     		=	[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 	__lowerCamelCase			(     self     :Optional[Any]   ,__lowercase     :str   ,__lowercase     :Optional[str] = None  ):
						snake_case__	:      Tuple     		=	self._tokenizer.model.save(__lowercase   ,name=__lowercase  )
						return tuple(__lowercase  )

