





'''simple docstring'''
import json
from typing import Iterator, List, Union

from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, trainers
from tokenizers.implementations.base_tokenizer import BaseTokenizer
from tokenizers.models import Unigram
from tokenizers.processors import TemplateProcessing

class      snake_case     (    __lowerCamelCase       ):




 """simple docstring"""



 def __init__(       self       :							str							,	__A       :							str = "▁"							,	__A       :							bool = True							,	__A       :							Union[str, AddedToken] = "<unk>"							,	__A       :							Union[str, AddedToken] = "</s>"							,	__A       :							Union[str, AddedToken] = "<pad>"							,	):
        __UpperCamelCase       =  {
            'pad': {'id': 0, 'token': pad_token},
            'eos': {'id': 1, 'token': eos_token},
            'unk': {'id': 2, 'token': unk_token},
        }

        __UpperCamelCase       =  [None] * len(self.special_tokens	)
        for token_dict in self.special_tokens.values():
               __UpperCamelCase       =  token_dict['token']

        __UpperCamelCase       =  Tokenizer(Unigram()	)

        __UpperCamelCase       =  normalizers.Sequence(
            [
                normalizers.Nmt(),
                normalizers.NFKC(),
                normalizers.Replace(Regex(' {2,}'	)							,	' '	),
                normalizers.Lowercase(),
            ]	)
        __UpperCamelCase       =  pre_tokenizers.Sequence(
            [
                pre_tokenizers.Metaspace(replacement=__A							,	add_prefix_space=__A	),
                pre_tokenizers.Digits(individual_digits=__A	),
                pre_tokenizers.Punctuation(),
            ]	)
        __UpperCamelCase       =  decoders.Metaspace(replacement=__A							,	add_prefix_space=__A	)

        __UpperCamelCase       =  TemplateProcessing(
            single=f'''$A {self.special_tokens['eos']['token']}'''							,	special_tokens=[(self.special_tokens['eos']['token'], self.special_tokens['eos']['id'])]							,	)

        __UpperCamelCase       =  {
            'model': 'SentencePieceUnigram',
            'replacement': replacement,
            'add_prefix_space': add_prefix_space,
        }

        super().__init__(__A							,	__A	)






 def        _lowerCamelCase					(       self       :							List[Any]							,	__A       :							Union[str, List[str]]							,	__A       :							int = 8_0_0_0							,	__A       :							bool = True							,	):
        __UpperCamelCase       =  trainers.UnigramTrainer(
            vocab_size=__A							,	special_tokens=self.special_tokens_list							,	show_progress=__A							,	)

        if isinstance(__A							,	__A	):
               __UpperCamelCase       =  [files]
        self._tokenizer.train(__A							,	trainer=__A	)

        self.add_unk_id()






 def        _lowerCamelCase					(       self       :							List[str]							,	__A       :							Union[Iterator[str], Iterator[Iterator[str]]]							,	__A       :							int = 8_0_0_0							,	__A       :							bool = True							,	):
        __UpperCamelCase       =  trainers.UnigramTrainer(
            vocab_size=__A							,	special_tokens=self.special_tokens_list							,	show_progress=__A							,	)

        self._tokenizer.train_from_iterator(__A							,	trainer=__A	)

        self.add_unk_id()






 def        _lowerCamelCase					(       self       :							Dict	):
        __UpperCamelCase       =  json.loads(self._tokenizer.to_str()	)

        __UpperCamelCase       =  self.special_tokens['unk']['id']

        __UpperCamelCase       =  Tokenizer.from_str(json.dumps(__A	)	)







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


a__:      Dict									=		logging.get_logger(__name__)

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

a__:      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'
        ),
    },
}

a__:      Any									=		{
    'distilbert-base-uncased': 512,
    'distilbert-base-uncased-distilled-squad': 512,
    'distilbert-base-cased': 512,
    'distilbert-base-cased-distilled-squad': 512,
    'distilbert-base-german-cased': 512,
    'distilbert-base-multilingual-cased': 512,
}


a__:      Optional[Any]									=		{
    '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__ (						UpperCamelCase__      ):
 __SCREAMING_SNAKE_CASE							       =	VOCAB_FILES_NAMES
 __SCREAMING_SNAKE_CASE							       =	PRETRAINED_VOCAB_FILES_MAP
 __SCREAMING_SNAKE_CASE							       =	PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
 __SCREAMING_SNAKE_CASE							       =	PRETRAINED_INIT_CONFIGURATION
 __SCREAMING_SNAKE_CASE							       =	['''input_ids''', '''attention_mask''']
 __SCREAMING_SNAKE_CASE							       =	DistilBertTokenizer



 def __init__(							self,__lowerCamelCase=None,__lowerCamelCase=None,__lowerCamelCase=True,__lowerCamelCase="[UNK]",__lowerCamelCase="[SEP]",__lowerCamelCase="[PAD]",__lowerCamelCase="[CLS]",__lowerCamelCase="[MASK]",__lowerCamelCase=True,__lowerCamelCase=None,**__lowerCamelCase,):
        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__											=						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__											=						getattr(__lowerCamelCase,normalizer_state.pop('''type''' ) )
               A__											=						do_lower_case
               A__											=						strip_accents
               A__											=						tokenize_chinese_chars
               A__											=						normalizer_class(**__lowerCamelCase )

        A__											=						do_lower_case



 def 				UpperCamelCase			(							self,__lowerCamelCase,__lowerCamelCase=None ):
        A__											=						[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 				UpperCamelCase			(							self,__lowerCamelCase,__lowerCamelCase = None ):
        A__											=						[self.sep_token_id]
        A__											=						[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 				UpperCamelCase			(							self,__lowerCamelCase,__lowerCamelCase = None ):
        A__											=						self._tokenizer.model.save(__lowerCamelCase,name=__lowerCamelCase )
        return tuple(__lowerCamelCase )





