codingutf8 2019present cnrs facebook inc and the huggingface inc team licensed under the apache license version 2 0 the license you may not use this file except in compliance with the license you may obtain a copy of the license at http www apache orglicenseslicense2 0 unless required by applicable law or agreed to in writing software distributed under the license is distributed on an as is basis without warranties or conditions of any kind either express or implied see the license for the specific language governing permissions and limitations under the license tokenization classes for flaubert import json import os import re import unicodedata from typing import list optional tuple from tokenizationutils import pretrainedtokenizer from utils import logging logger logging getloggername vocabfilesnames vocabfile vocab json mergesfile merges txt pretrainedvocabfilesmap vocabfile flaubertflaubertsmallcased https huggingface coflaubertflaubertsmallcasedresolvemainvocab json flaubertflaubertbaseuncased https huggingface coflaubertflaubertbaseuncasedresolvemainvocab json flaubertflaubertbasecased https huggingface coflaubertflaubertbasecasedresolvemainvocab json flaubertflaubertlargecased https huggingface coflaubertflaubertlargecasedresolvemainvocab json mergesfile flaubertflaubertsmallcased https huggingface coflaubertflaubertsmallcasedresolvemainmerges txt flaubertflaubertbaseuncased https huggingface coflaubertflaubertbaseuncasedresolvemainmerges txt flaubertflaubertbasecased https huggingface coflaubertflaubertbasecasedresolvemainmerges txt flaubertflaubertlargecased https huggingface coflaubertflaubertlargecasedresolvemainmerges txt pretrainedpositionalembeddingssizes flaubertflaubertsmallcased 512 flaubertflaubertbaseuncased 512 flaubertflaubertbasecased 512 flaubertflaubertlargecased 512 pretrainedinitconfiguration flaubertflaubertsmallcased dolowercase false flaubertflaubertbaseuncased dolowercase true flaubertflaubertbasecased dolowercase false flaubertflaubertlargecased dolowercase false def converttounicodetext def ensuretexts encodingutf8 errorsstrict if isinstances bytes return s decodeencoding errors elif isinstances str return s else raise typeerrorfnot expecting type types return ensuretexttext encodingutf8 errorsignore copied from transformers models xlm tokenizationxlm getpairs def getpairsword pairs set prevchar word0 for char in word1 pairs addprevchar char prevchar char return pairs copied from transformers models xlm tokenizationxlm replaceunicodepunct def replaceunicodepuncttext text text replace text re subrs text text text replace text text replace text text replace text text replace text text replace text text replace text text replace text text replace text text replace text text replace text text replace text text replace text text replace 1 text text replace text text replace text text replace 0 text text replace 3 text text replace 2 text text replace 5 text text replace 6 text text replace 9 text text replace 7 text text replace 8 text text replace 4 text re subrs text text text replace text text replace text text replace text text replace text text replace text text replace text text replace text text replace text text replace return text copied from transformers models xlm tokenizationxlm removenonprintingchar def removenonprintingchartext output for char in text cat unicodedata categorychar if cat startswithc continue output appendchar return joinoutput class flauberttokenizerpretrainedtokenizer vocabfilesnames vocabfilesnames pretrainedvocabfilesmap pretrainedvocabfilesmap pretrainedinitconfiguration pretrainedinitconfiguration maxmodelinputsizes pretrainedpositionalembeddingssizes def init self vocabfile mergesfile dolowercasefalse unktokenunk bostokens septokens padtokenpad clstokens masktokenspecial1 additionalspecialtokens special0 special1 special2 special3 special4 special5 special6 special7 special8 special9 lang2idnone id2langnone kwargs dolowercaseandremoveaccent kwargs popdolowercaseandremoveaccent none if dolowercaseandremoveaccent is not none logger warning dolowercaseandremoveaccent is passed as a keyword argument but this won t do anything flauberttokenizer will always set it to false always false self dolowercaseandremoveaccent false self dolowercase dolowercase try import sacremoses except importerror raise importerror you need to install sacremoses to use flauberttokenizer see https pypi orgprojectsacremoses for installation self sm sacremoses cache of sm mosespunctnormalizer instance self cachemosespunctnormalizer cache of sm mosestokenizer instance self cachemosestokenizer self langwithcustomtokenizer zh th ja self lang2id lang2id self id2lang id2lang if lang2id is not none and id2lang is not none assert lenlang2id lenid2lang self jawordtokenizer none self zhwordtokenizer none with openvocabfile encodingutf8 as vocabhandle self encoder json loadvocabhandle self decoder v k for k v in self encoder items with openmergesfile encodingutf8 as mergeshandle merges mergeshandle read splitn 1 merges tuplemerge split 2 for merge in merges self bperanks dictzipmerges rangelenmerges self cache super init unktokenunktoken bostokenbostoken septokenseptoken padtokenpadtoken clstokenclstoken masktokenmasktoken additionalspecialtokensadditionalspecialtokens lang2idlang2id id2langid2lang kwargs property copied from transformers models xlm tokenizationxlm xlmtokenizer dolowercase def dolowercaseself return self dolowercaseandremoveaccent copied from transformers models xlm tokenizationxlm xlmtokenizer mosespunctnorm def mosespunctnormself text lang if lang not in self cachemosespunctnormalizer punctnormalizer self sm mosespunctnormalizerlanglang self cachemosespunctnormalizerlang punctnormalizer else punctnormalizer self cachemosespunctnormalizerlang return punctnormalizer normalizetext copied from transformers models xlm tokenizationxlm xlmtokenizer mosestokenize def mosestokenizeself text lang if lang not in self cachemosestokenizer mosestokenizer self sm mosestokenizerlanglang self cachemosestokenizerlang mosestokenizer else mosestokenizer self cachemosestokenizerlang return mosestokenizer tokenizetext returnstrfalse escapefalse copied from transformers models xlm tokenizationxlm xlmtokenizer mosespipeline def mosespipelineself text lang text replaceunicodepuncttext text self mosespunctnormtext lang text removenonprintingchartext return text copied from transformers models xlm tokenizationxlm xlmtokenizer jatokenize def jatokenizeself text if self jawordtokenizer is none try import mykytea self jawordtokenizer mykytea mykytea fmodel os path expanduser localsharekyteamodel bin except attributeerror importerror logger error make sure you install kytea https github comneubigkytea and it s python wrapper https github comchezoumykyteapython with the following steps logger error1 git clone gitgithub com neubigkytea git cd kytea logger error2 autoreconf i logger error3 configure prefixhomelocal logger error4 make make install logger error5 pip install kytea raise return listself jawordtokenizer getwstext property copied from transformers models xlm tokenizationxlm xlmtokenizer vocabsize def vocabsizeself return lenself encoder copied from transformers models xlm tokenizationxlm xlmtokenizer getvocab def getvocabself return dictself encoder self addedtokensencoder copied from transformers models xlm tokenizationxlm xlmtokenizer bpe def bpeself token word tupletoken 1 token1 w if token in self cache return self cachetoken pairs getpairsword if not pairs return token w while true bigram minpairs keylambda pair self bperanks getpair floatinf if bigram not in self bperanks break first second bigram newword i 0 while i lenword try j word indexfirst i except valueerror newword extendwordi break else newword extendwordi j i j if wordi first and i lenword 1 and wordi 1 second newword appendfirst second i 2 else newword appendwordi i 1 newword tuplenewword word newword if lenword 1 break else pairs getpairsword word joinword if word n w word nw self cachetoken word return word def preprocesstextself text text text replace replace text converttounicodetext text unicodedata normalizenfc text if self dolowercase text text lower return text def tokenizeself text bypasstokenizerfalse lang fr if lang and self lang2id and lang not in self lang2id logger error supplied language code not found in lang2id mapping please check that your language is supported by the loaded pretrained model if bypasstokenizer text text split else text self preprocesstexttext text self mosespipelinetext langlang text self mosestokenizetext langlang splittokens for token in text if token splittokens extendlistself bpetoken split return splittokens copied from transformers models xlm tokenizationxlm xlmtokenizer converttokentoid def converttokentoidself token copied from transformers models xlm tokenizationxlm xlmtokenizer convertidtotoken converts an index integer in a token str using the vocab return self decoder getindex self unktoken copied from transformers models xlm tokenizationxlm xlmtokenizer converttokenstostring def converttokenstostringself tokens copied from transformers models xlm tokenizationxlm xlmtokenizer buildinputswithspecialtokens build model inputs from a sequence or a pair of sequence for sequence classification tasks by concatenating and adding special tokens an xlm sequence has the following format single sequence s x s pair of sequences s a s b s args tokenids0 listint list of ids to which the special tokens will be added tokenids1 listint optional optional second list of ids for sequence pairs returns listint list of input ids glossaryinputids with the appropriate special tokens copied from transformers models xlm tokenizationxlm xlmtokenizer getspecialtokensmask retrieve sequence ids from a token list that has no special tokens added this method is called when adding special tokens using the tokenizer prepareformodel method args tokenids0 listint list of ids tokenids1 listint optional optional second list of ids for sequence pairs alreadyhasspecialtokens bool optional defaults to false whether or not the token list is already formatted with special tokens for the model returns listint a list of integers in the range 0 1 1 for a special token 0 for a sequence token copied from transformers models xlm tokenizationxlm xlmtokenizer createtokentypeidsfromsequences create a mask from the two sequences passed to be used in a sequencepair classification task an xlm sequence pair mask has the following format 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 first sequence second sequence if tokenids1 is none this method only returns the first portion of the mask 0s args tokenids0 listint list of ids tokenids1 listint optional optional second list of ids for sequence pairs returns listint list of token type ids glossarytokentypeids according to the given sequences copied from transformers models xlm tokenizationxlm xlmtokenizer savevocabulary copied from transformers models xlm tokenizationxlm xlmtokenizer getstate copied from transformers models xlm tokenizationxlm xlmtokenizer setstate coding utf 8 2019 present cnrs facebook inc and the huggingface inc team licensed under the apache license version 2 0 the license you may not use this file except in compliance with the license you may obtain a copy of the license at http www apache org licenses license 2 0 unless required by applicable law or agreed to in writing software distributed under the license is distributed on an as is basis without warranties or conditions of any kind either express or implied see the license for the specific language governing permissions and limitations under the license tokenization classes for flaubert converts text to unicode if it s not already assuming utf 8 input copied from transformers models xlm tokenization_xlm get_pairs return set of symbol pairs in a word word is represented as tuple of symbols symbols being variable length strings copied from transformers models xlm tokenization_xlm replace_unicode_punct port of https github com moses smt mosesdecoder blob master scripts tokenizer replace unicode punctuation perl copied from transformers models xlm tokenization_xlm remove_non_printing_char port of https github com moses smt mosesdecoder blob master scripts tokenizer remove non printing char perl construct a flaubert tokenizer based on byte pair encoding the tokenization process is the following moses preprocessing and tokenization normalizing all inputs text the arguments special_tokens and the function set_special_tokens can be used to add additional symbols like __classify__ to a vocabulary the argument do_lowercase controls lower casing automatically set for pretrained vocabularies this tokenizer inherits from pretrainedtokenizer which contains most of the main methods users should refer to this superclass for more information regarding those methods args vocab_file str vocabulary file merges_file str merges file do_lowercase bool optional defaults to false controls lower casing unk_token str optional defaults to unk the unknown token a token that is not in the vocabulary cannot be converted to an id and is set to be this token instead bos_token str optional defaults to s the beginning of sequence token that was used during pretraining can be used a sequence classifier token tip when building a sequence using special tokens this is not the token that is used for the beginning of sequence the token used is the cls_token tip sep_token str optional defaults to s the separator token which is used when building a sequence from multiple sequences e g two sequences for sequence classification or for a text and a question for question answering it is also used as the last token of a sequence built with special tokens pad_token str optional defaults to pad the token used for padding for example when batching sequences of different lengths cls_token str optional defaults to s the classifier token which is used when doing sequence classification classification of the whole sequence instead of per token classification it is the first token of the sequence when built with special tokens mask_token str optional defaults to special1 the token used for masking values this is the token used when training this model with masked language modeling this is the token which the model will try to predict additional_special_tokens list str optional defaults to special0 special1 special2 special3 special4 special5 special6 special7 special8 special9 list of additional special tokens lang2id dict str int optional dictionary mapping languages string identifiers to their ids id2lang dict int str optional dictionary mapping language ids to their string identifiers always false cache of sm mosespunctnormalizer instance cache of sm mosestokenizer instance copied from transformers models xlm tokenization_xlm xlmtokenizer do_lower_case copied from transformers models xlm tokenization_xlm xlmtokenizer moses_punct_norm copied from transformers models xlm tokenization_xlm xlmtokenizer moses_tokenize copied from transformers models xlm tokenization_xlm xlmtokenizer moses_pipeline copied from transformers models xlm tokenization_xlm xlmtokenizer ja_tokenize copied from transformers models xlm tokenization_xlm xlmtokenizer vocab_size copied from transformers models xlm tokenization_xlm xlmtokenizer get_vocab copied from transformers models xlm tokenization_xlm xlmtokenizer bpe tokenize a string given language code using moses details of tokenization sacremoses https github com alvations sacremoses port of moses install with pip install sacremoses args bypass_tokenizer allow users to preprocess and tokenize the sentences externally default false bool if true we only apply bpe returns list of tokens copied from transformers models xlm tokenization_xlm xlmtokenizer _convert_token_to_id converts a token str in an id using the vocab copied from transformers models xlm tokenization_xlm xlmtokenizer _convert_id_to_token converts an index integer in a token str using the vocab copied from transformers models xlm tokenization_xlm xlmtokenizer convert_tokens_to_string converts a sequence of tokens string in a single string copied from transformers models xlm tokenization_xlm xlmtokenizer build_inputs_with_special_tokens build model inputs from a sequence or a pair of sequence for sequence classification tasks by concatenating and adding special tokens an xlm sequence has the following format single sequence s x s pair of sequences s a s b s args token_ids_0 list int list of ids to which the special tokens will be added token_ids_1 list int optional optional second list of ids for sequence pairs returns list int list of input ids glossary input ids with the appropriate special tokens copied from transformers models xlm tokenization_xlm xlmtokenizer get_special_tokens_mask retrieve sequence ids from a token list that has no special tokens added this method is called when adding special tokens using the tokenizer prepare_for_model method args token_ids_0 list int list of ids token_ids_1 list int optional optional second list of ids for sequence pairs already_has_special_tokens bool optional defaults to false whether or not the token list is already formatted with special tokens for the model returns list int a list of integers in the range 0 1 1 for a special token 0 for a sequence token copied from transformers models xlm tokenization_xlm xlmtokenizer create_token_type_ids_from_sequences create a mask from the two sequences passed to be used in a sequence pair classification task an xlm sequence pair mask has the following format 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 first sequence second sequence if token_ids_1 is none this method only returns the first portion of the mask 0s args token_ids_0 list int list of ids token_ids_1 list int optional optional second list of ids for sequence pairs returns list int list of token type ids glossary token type ids according to the given sequence s copied from transformers models xlm tokenization_xlm xlmtokenizer save_vocabulary copied from transformers models xlm tokenization_xlm xlmtokenizer __getstate__ copied from transformers models xlm tokenization_xlm xlmtokenizer __setstate__
import json
import os
import re
import unicodedata
from typing import List, Optional, Tuple

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


logger = logging.get_logger(__name__)

VOCAB_FILES_NAMES = {
    "vocab_file": "vocab.json",
    "merges_file": "merges.txt",
}

PRETRAINED_VOCAB_FILES_MAP = {
    "vocab_file": {
        "flaubert/flaubert_small_cased": (
            "https://huggingface.co/flaubert/flaubert_small_cased/resolve/main/vocab.json"
        ),
        "flaubert/flaubert_base_uncased": (
            "https://huggingface.co/flaubert/flaubert_base_uncased/resolve/main/vocab.json"
        ),
        "flaubert/flaubert_base_cased": "https://huggingface.co/flaubert/flaubert_base_cased/resolve/main/vocab.json",
        "flaubert/flaubert_large_cased": (
            "https://huggingface.co/flaubert/flaubert_large_cased/resolve/main/vocab.json"
        ),
    },
    "merges_file": {
        "flaubert/flaubert_small_cased": (
            "https://huggingface.co/flaubert/flaubert_small_cased/resolve/main/merges.txt"
        ),
        "flaubert/flaubert_base_uncased": (
            "https://huggingface.co/flaubert/flaubert_base_uncased/resolve/main/merges.txt"
        ),
        "flaubert/flaubert_base_cased": "https://huggingface.co/flaubert/flaubert_base_cased/resolve/main/merges.txt",
        "flaubert/flaubert_large_cased": (
            "https://huggingface.co/flaubert/flaubert_large_cased/resolve/main/merges.txt"
        ),
    },
}

PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES = {
    "flaubert/flaubert_small_cased": 512,
    "flaubert/flaubert_base_uncased": 512,
    "flaubert/flaubert_base_cased": 512,
    "flaubert/flaubert_large_cased": 512,
}

PRETRAINED_INIT_CONFIGURATION = {
    "flaubert/flaubert_small_cased": {"do_lowercase": False},
    "flaubert/flaubert_base_uncased": {"do_lowercase": True},
    "flaubert/flaubert_base_cased": {"do_lowercase": False},
    "flaubert/flaubert_large_cased": {"do_lowercase": False},
}


def convert_to_unicode(text):
    

    def ensure_text(s, encoding="utf-8", errors="strict"):
        if isinstance(s, bytes):
            return s.decode(encoding, errors)
        elif isinstance(s, str):
            return s
        else:
            raise TypeError(f"not expecting type '{type(s)}'")

    return ensure_text(text, encoding="utf-8", errors="ignore")



def get_pairs(word):
    
    pairs = set()
    prev_char = word[0]
    for char in word[1:]:
        pairs.add((prev_char, char))
        prev_char = char
    return pairs



def replace_unicode_punct(text):
    
    text = text.replace("，", ",")
    text = re.sub(r"。\s*", ". ", text)
    text = text.replace("、", ",")
    text = text.replace("”", '"')
    text = text.replace("“", '"')
    text = text.replace("∶", ":")
    text = text.replace("：", ":")
    text = text.replace("？", "?")
    text = text.replace("《", '"')
    text = text.replace("》", '"')
    text = text.replace("）", ")")
    text = text.replace("！", "!")
    text = text.replace("（", "(")
    text = text.replace("；", ";")
    text = text.replace("１", "1")
    text = text.replace("」", '"')
    text = text.replace("「", '"')
    text = text.replace("０", "0")
    text = text.replace("３", "3")
    text = text.replace("２", "2")
    text = text.replace("５", "5")
    text = text.replace("６", "6")
    text = text.replace("９", "9")
    text = text.replace("７", "7")
    text = text.replace("８", "8")
    text = text.replace("４", "4")
    text = re.sub(r"．\s*", ". ", text)
    text = text.replace("～", "~")
    text = text.replace("’", "'")
    text = text.replace("…", "...")
    text = text.replace("━", "-")
    text = text.replace("〈", "<")
    text = text.replace("〉", ">")
    text = text.replace("【", "[")
    text = text.replace("】", "]")
    text = text.replace("％", "%")
    return text



def remove_non_printing_char(text):
    
    output = []
    for char in text:
        cat = unicodedata.category(char)
        if cat.startswith("C"):
            continue
        output.append(char)
    return "".join(output)


class FlaubertTokenizer(PreTrainedTokenizer):
    

    vocab_files_names = VOCAB_FILES_NAMES
    pretrained_vocab_files_map = PRETRAINED_VOCAB_FILES_MAP
    pretrained_init_configuration = PRETRAINED_INIT_CONFIGURATION
    max_model_input_sizes = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES

    def __init__(
        self,
        vocab_file,
        merges_file,
        do_lowercase=False,
        unk_token="<unk>",
        bos_token="<s>",
        sep_token="</s>",
        pad_token="<pad>",
        cls_token="</s>",
        mask_token="<special1>",
        additional_special_tokens=[
            "<special0>",
            "<special1>",
            "<special2>",
            "<special3>",
            "<special4>",
            "<special5>",
            "<special6>",
            "<special7>",
            "<special8>",
            "<special9>",
        ],
        lang2id=None,
        id2lang=None,
        **kwargs,
    ):
        do_lowercase_and_remove_accent = kwargs.pop("do_lowercase_and_remove_accent", None)
        if do_lowercase_and_remove_accent is not None:
            logger.warning(
                "`do_lowercase_and_remove_accent` is passed as a keyword argument, but this won't do anything."
                " `FlaubertTokenizer` will always set it to `False`."
            )
        
        self.do_lowercase_and_remove_accent = False

        self.do_lowercase = do_lowercase

        try:
            import sacremoses
        except ImportError:
            raise ImportError(
                "You need to install sacremoses to use FlaubertTokenizer. "
                "See https://pypi.org/project/sacremoses/ for installation."
            )

        self.sm = sacremoses

        
        self.cache_moses_punct_normalizer = {}
        
        self.cache_moses_tokenizer = {}
        self.lang_with_custom_tokenizer = {"zh", "th", "ja"}
        self.lang2id = lang2id
        self.id2lang = id2lang
        if lang2id is not None and id2lang is not None:
            assert len(lang2id) == len(id2lang)

        self.ja_word_tokenizer = None
        self.zh_word_tokenizer = None

        with open(vocab_file, encoding="utf-8") as vocab_handle:
            self.encoder = json.load(vocab_handle)
        self.decoder = {v: k for k, v in self.encoder.items()}
        with open(merges_file, encoding="utf-8") as merges_handle:
            merges = merges_handle.read().split("\n")[:-1]
        merges = [tuple(merge.split()[:2]) for merge in merges]
        self.bpe_ranks = dict(zip(merges, range(len(merges))))
        self.cache = {}

        super().__init__(
            unk_token=unk_token,
            bos_token=bos_token,
            sep_token=sep_token,
            pad_token=pad_token,
            cls_token=cls_token,
            mask_token=mask_token,
            additional_special_tokens=additional_special_tokens,
            lang2id=lang2id,
            id2lang=id2lang,
            **kwargs,
        )

    @property
    
    def do_lower_case(self):
        return self.do_lowercase_and_remove_accent

    
    def moses_punct_norm(self, text, lang):
        if lang not in self.cache_moses_punct_normalizer:
            punct_normalizer = self.sm.MosesPunctNormalizer(lang=lang)
            self.cache_moses_punct_normalizer[lang] = punct_normalizer
        else:
            punct_normalizer = self.cache_moses_punct_normalizer[lang]
        return punct_normalizer.normalize(text)

    
    def moses_tokenize(self, text, lang):
        if lang not in self.cache_moses_tokenizer:
            moses_tokenizer = self.sm.MosesTokenizer(lang=lang)
            self.cache_moses_tokenizer[lang] = moses_tokenizer
        else:
            moses_tokenizer = self.cache_moses_tokenizer[lang]
        return moses_tokenizer.tokenize(text, return_str=False, escape=False)

    
    def moses_pipeline(self, text, lang):
        text = replace_unicode_punct(text)
        text = self.moses_punct_norm(text, lang)
        text = remove_non_printing_char(text)
        return text

    
    def ja_tokenize(self, text):
        if self.ja_word_tokenizer is None:
            try:
                import Mykytea

                self.ja_word_tokenizer = Mykytea.Mykytea(
                    f"-model {os.path.expanduser('~')}/local/share/kytea/model.bin"
                )
            except (AttributeError, ImportError):
                logger.error(
                    "Make sure you install KyTea (https://github.com/neubig/kytea) and it's python wrapper"
                    " (https://github.com/chezou/Mykytea-python) with the following steps"
                )
                logger.error("1. git clone git@github.com:neubig/kytea.git && cd kytea")
                logger.error("2. autoreconf -i")
                logger.error("3. ./configure --prefix=$HOME/local")
                logger.error("4. make && make install")
                logger.error("5. pip install kytea")
                raise
        return list(self.ja_word_tokenizer.getWS(text))

    @property
    
    def vocab_size(self):
        return len(self.encoder)

    
    def get_vocab(self):
        return dict(self.encoder, **self.added_tokens_encoder)

    
    def bpe(self, token):
        word = tuple(token[:-1]) + (token[-1] + "</w>",)
        if token in self.cache:
            return self.cache[token]
        pairs = get_pairs(word)

        if not pairs:
            return token + "</w>"

        while True:
            bigram = min(pairs, key=lambda pair: self.bpe_ranks.get(pair, float("inf")))
            if bigram not in self.bpe_ranks:
                break
            first, second = bigram
            new_word = []
            i = 0
            while i < len(word):
                try:
                    j = word.index(first, i)
                except ValueError:
                    new_word.extend(word[i:])
                    break
                else:
                    new_word.extend(word[i:j])
                    i = j

                if word[i] == first and i < len(word) - 1 and word[i + 1] == second:
                    new_word.append(first + second)
                    i += 2
                else:
                    new_word.append(word[i])
                    i += 1
            new_word = tuple(new_word)
            word = new_word
            if len(word) == 1:
                break
            else:
                pairs = get_pairs(word)
        word = " ".join(word)
        if word == "\n  </w>":
            word = "\n</w>"
        self.cache[token] = word
        return word

    def preprocess_text(self, text):
        text = text.replace("``", '"').replace("''", '"')
        text = convert_to_unicode(text)
        text = unicodedata.normalize("NFC", text)

        if self.do_lowercase:
            text = text.lower()

        return text

    def _tokenize(self, text, bypass_tokenizer=False):
        
        lang = "fr"
        if lang and self.lang2id and lang not in self.lang2id:
            logger.error(
                "Supplied language code not found in lang2id mapping. Please check that your language is supported by"
                " the loaded pretrained model."
            )

        if bypass_tokenizer:
            text = text.split()
        else:
            text = self.preprocess_text(text)
            text = self.moses_pipeline(text, lang=lang)
            text = self.moses_tokenize(text, lang=lang)

        split_tokens = []
        for token in text:
            if token:
                split_tokens.extend(list(self.bpe(token).split(" ")))

        return split_tokens

    
    def _convert_token_to_id(self, token):
        
        return self.encoder.get(token, self.encoder.get(self.unk_token))

    
    def _convert_id_to_token(self, index):
        
        return self.decoder.get(index, self.unk_token)

    
    def convert_tokens_to_string(self, tokens):
        
        out_string = "".join(tokens).replace("</w>", " ").strip()
        return out_string

    
    def build_inputs_with_special_tokens(
        self, token_ids_0: List[int], token_ids_1: Optional[List[int]] = None
    ) -> List[int]:
        
        bos = [self.bos_token_id]
        sep = [self.sep_token_id]

        if token_ids_1 is None:
            return bos + token_ids_0 + sep
        return bos + token_ids_0 + sep + token_ids_1 + sep

    
    def get_special_tokens_mask(
        self, token_ids_0: List[int], token_ids_1: Optional[List[int]] = None, already_has_special_tokens: bool = False
    ) -> List[int]:
        

        if already_has_special_tokens:
            return super().get_special_tokens_mask(
                token_ids_0=token_ids_0, token_ids_1=token_ids_1, already_has_special_tokens=True
            )

        if token_ids_1 is not None:
            return [1] + ([0] * len(token_ids_0)) + [1] + ([0] * len(token_ids_1)) + [1]
        return [1] + ([0] * len(token_ids_0)) + [1]

    
    def create_token_type_ids_from_sequences(
        self, token_ids_0: List[int], token_ids_1: Optional[List[int]] = None
    ) -> List[int]:
        
        sep = [self.sep_token_id]
        cls = [self.cls_token_id]
        if token_ids_1 is None:
            return len(cls + token_ids_0 + sep) * [0]
        return len(cls + token_ids_0 + sep) * [0] + len(token_ids_1 + sep) * [1]

    
    def save_vocabulary(self, save_directory: str, filename_prefix: Optional[str] = None) -> Tuple[str]:
        if not os.path.isdir(save_directory):
            logger.error(f"Vocabulary path ({save_directory}) should be a directory")
            return
        vocab_file = os.path.join(
            save_directory, (filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"]
        )
        merge_file = os.path.join(
            save_directory, (filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["merges_file"]
        )

        with open(vocab_file, "w", encoding="utf-8") as f:
            f.write(json.dumps(self.encoder, indent=2, sort_keys=True, ensure_ascii=False) + "\n")

        index = 0
        with open(merge_file, "w", encoding="utf-8") as writer:
            for bpe_tokens, token_index in sorted(self.bpe_ranks.items(), key=lambda kv: kv[1]):
                if index != token_index:
                    logger.warning(
                        f"Saving vocabulary to {merge_file}: BPE merge indices are not consecutive."
                        " Please check that the tokenizer is not corrupted!"
                    )
                    index = token_index
                writer.write(" ".join(bpe_tokens) + "\n")
                index += 1

        return vocab_file, merge_file

    
    def __getstate__(self):
        state = self.__dict__.copy()
        state["sm"] = None
        return state

    
    def __setstate__(self, d):
        self.__dict__ = d

        try:
            import sacremoses
        except ImportError:
            raise ImportError(
                "You need to install sacremoses to use XLMTokenizer. "
                "See https://pypi.org/project/sacremoses/ for installation."
            )

        self.sm = sacremoses