

"""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    : Dict				 =						logging.get_logger(__name__)

__UpperCamelCase    : List[Any]				 =						{'''vocab_file''': '''sentencepiece.model'''}

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

__UpperCamelCase    : Any				 =						{
    '''google/rembert''': 2_5_6,
}







class 							SCREAMING_SNAKE_CASE   (						a_			):






					"""simple docstring"""



					lowercase__												=			VOCAB_FILES_NAMES
					lowercase__												=			PRETRAINED_VOCAB_FILES_MAP
					lowercase__												=			PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES







					def __init__(			self     :							str  ,lowercase_     :							Tuple  ,lowercase_     :							Tuple=False  ,lowercase_     :							List[Any]=True  ,lowercase_     :							List[Any]=True  ,lowercase_     :							Optional[int]="[CLS]"  ,lowercase_     :							Optional[Any]="[SEP]"  ,lowercase_     :							str="[UNK]"  ,lowercase_     :							List[str]="[SEP]"  ,lowercase_     :							Union[str, Any]="[PAD]"  ,lowercase_     :							Dict="[CLS]"  ,lowercase_     :							Union[str, Any]="[MASK]"  ,**lowercase_     :							Optional[int]  ,):
						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_  ,**lowercase_  ,)

						lowerCAmelCase__      :		Dict    							=      do_lower_case
						lowerCAmelCase__      :		Optional[int]    							=      remove_space
						lowerCAmelCase__      :		str    							=      keep_accents
						lowerCAmelCase__      :		str    							=      vocab_file

						lowerCAmelCase__      :		Any    							=      spm.SentencePieceProcessor()
						self.sp_model.Load(lowercase_						)







					@property
					def 			__lowerCAmelCase					(			self     :							str						):
						return len(self.sp_model						)







					def 			__lowerCAmelCase					(			self     :							List[str]						):
						lowerCAmelCase__      :		List[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     :							Any						):
						lowerCAmelCase__      :		Union[str, Any]    							=      self.__dict__.copy()
						lowerCAmelCase__      :		str    							=      None
						return state







					def __setstate__(			self     :							Tuple  ,lowercase_     :							Any						):
						lowerCAmelCase__      :		Tuple    							=      d
						lowerCAmelCase__      :		Optional[Any]    							=      spm.SentencePieceProcessor()
						self.sp_model.Load(self.vocab_file						)







					def 			__lowerCAmelCase					(			self     :							Union[str, Any]  ,lowercase_     :							Optional[Any]  ,lowercase_     :							Dict=False						):
						lowerCAmelCase__      :		Optional[int]    							=      self.sp_model.EncodeAsPieces(lowercase_						)
						return pieces







					def 			__lowerCAmelCase					(			self     :							Tuple  ,lowercase_     :							Union[str, Any]						):
						return self.sp_model.PieceToId(lowercase_						)







					def 			__lowerCAmelCase					(			self     :							Dict  ,lowercase_     :							List[str]						):
						return self.sp_model.IdToPiece(lowercase_						)







					def 			__lowerCAmelCase					(			self     :							Union[str, Any]  ,lowercase_     :							Tuple						):
						lowerCAmelCase__      :		List[Any]    							=      self.sp_model.decode_pieces(lowercase_						)
						return out_string







					def 			__lowerCAmelCase					(			self     :							int  ,lowercase_     :							List[int]  ,lowercase_     :							Optional[List[int]] = None						):
						lowerCAmelCase__      :		str    							=      [self.sep_token_id]
						lowerCAmelCase__      :		Union[str, Any]    							=      [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 			__lowerCAmelCase					(			self     :							Optional[int]  ,lowercase_     :							List[int]  ,lowercase_     :							Optional[List[int]] = None  ,lowercase_     :							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(lowercase_						)) + [1] + ([0] * len(lowercase_						)) + [1]
						return [1] + ([0] * len(lowercase_						)) + [1]







					def 			__lowerCAmelCase					(			self     :							Union[str, Any]  ,lowercase_     :							List[int]  ,lowercase_     :							Optional[List[int]] = None						):
						lowerCAmelCase__      :		List[Any]    							=      [self.sep_token_id]
						lowerCAmelCase__      :		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     :							int  ,lowercase_     :							str  ,lowercase_     :							Optional[str] = None						):
						if not os.path.isdir(lowercase_						):
							logger.error('''Vocabulary path ({}) should be a directory'''.format(lowercase_						)						)
							return
						lowerCAmelCase__      :		str    							=      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_						):
							copyfile(self.vocab_file  ,lowercase_						)

						return (out_vocab_file,)







"""simple docstring"""





import json
from typing import List, Optional, Tuple

from tokenizers import normalizers

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_distilbert import DistilBertTokenizer


__UpperCamelCase    : List[Any]				 =						logging.get_logger(__name__)

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

__UpperCamelCase    : List[Any]				 =						{
    '''vocab_file''': {
        '''distilbert-base-uncased''': '''https://huggingface.co/distilbert-base-uncased/resolve/main/vocab.txt''',
        '''distilbert-base-uncased-distilled-squad''': (
            '''https://huggingface.co/distilbert-base-uncased-distilled-squad/resolve/main/vocab.txt'''
        ),
        '''distilbert-base-cased''': '''https://huggingface.co/distilbert-base-cased/resolve/main/vocab.txt''',
        '''distilbert-base-cased-distilled-squad''': (
            '''https://huggingface.co/distilbert-base-cased-distilled-squad/resolve/main/vocab.txt'''
        ),
        '''distilbert-base-german-cased''': '''https://huggingface.co/distilbert-base-german-cased/resolve/main/vocab.txt''',
        '''distilbert-base-multilingual-cased''': (
            '''https://huggingface.co/distilbert-base-multilingual-cased/resolve/main/vocab.txt'''
        ),
    },
    '''tokenizer_file''': {
        '''distilbert-base-uncased''': '''https://huggingface.co/distilbert-base-uncased/resolve/main/tokenizer.json''',
        '''distilbert-base-uncased-distilled-squad''': (
            '''https://huggingface.co/distilbert-base-uncased-distilled-squad/resolve/main/tokenizer.json'''
        ),
        '''distilbert-base-cased''': '''https://huggingface.co/distilbert-base-cased/resolve/main/tokenizer.json''',
        '''distilbert-base-cased-distilled-squad''': (
            '''https://huggingface.co/distilbert-base-cased-distilled-squad/resolve/main/tokenizer.json'''
        ),
        '''distilbert-base-german-cased''': (
            '''https://huggingface.co/distilbert-base-german-cased/resolve/main/tokenizer.json'''
        ),
        '''distilbert-base-multilingual-cased''': (
            '''https://huggingface.co/distilbert-base-multilingual-cased/resolve/main/tokenizer.json'''
        ),
    },
}

__UpperCamelCase    : Union[str, Any]				 =						{
    '''distilbert-base-uncased''': 5_1_2,
    '''distilbert-base-uncased-distilled-squad''': 5_1_2,
    '''distilbert-base-cased''': 5_1_2,
    '''distilbert-base-cased-distilled-squad''': 5_1_2,
    '''distilbert-base-german-cased''': 5_1_2,
    '''distilbert-base-multilingual-cased''': 5_1_2,
}


__UpperCamelCase    : int				 =						{
    '''distilbert-base-uncased''': {'''do_lower_case''': True},
    '''distilbert-base-uncased-distilled-squad''': {'''do_lower_case''': True},
    '''distilbert-base-cased''': {'''do_lower_case''': False},
    '''distilbert-base-cased-distilled-squad''': {'''do_lower_case''': False},
    '''distilbert-base-german-cased''': {'''do_lower_case''': False},
    '''distilbert-base-multilingual-cased''': {'''do_lower_case''': False},
}







class 							SCREAMING_SNAKE_CASE   (						a_			):






					"""simple docstring"""



					lowercase__												=			VOCAB_FILES_NAMES
					lowercase__												=			PRETRAINED_VOCAB_FILES_MAP
					lowercase__												=			PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
					lowercase__												=			PRETRAINED_INIT_CONFIGURATION
					lowercase__												=			["input_ids", "attention_mask"]
					lowercase__												=			DistilBertTokenizer







					def __init__(			self     :							int  ,lowercase_     :							List[str]=None  ,lowercase_     :							int=None  ,lowercase_     :							str=True  ,lowercase_     :							Union[str, Any]="[UNK]"  ,lowercase_     :							List[str]="[SEP]"  ,lowercase_     :							List[str]="[PAD]"  ,lowercase_     :							List[str]="[CLS]"  ,lowercase_     :							List[str]="[MASK]"  ,lowercase_     :							Tuple=True  ,lowercase_     :							Tuple=None  ,**lowercase_     :							str  ,):
						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_  ,)

						lowerCAmelCase__      :		Tuple    							=      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
						):
							lowerCAmelCase__      :		Union[str, Any]    							=      getattr(lowercase_  ,normalizer_state.pop('''type'''						)						)
							lowerCAmelCase__      :		Optional[int]    							=      do_lower_case
							lowerCAmelCase__      :		List[str]    							=      strip_accents
							lowerCAmelCase__      :		int    							=      tokenize_chinese_chars
							lowerCAmelCase__      :		Dict    							=      normalizer_class(**lowercase_						)

						lowerCAmelCase__      :		Tuple    							=      do_lower_case







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




