codingutf8 2022 ucla nlp the facebook ai research team s 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 construct an plbart tokenizer adapted from robertatokenizer and xlnettokenizer based on sentencepiecehttps github comgooglesentencepiece the tokenization method is tokens eos language code for source language documents and language code tokens eos for target language documents args vocabfile str path to the vocabulary file srclang str optional a string representing the source language tgtlang str optional a string representing the target language bostoken str optional defaults to s the start of sequence token eostoken str optional defaults to s the end of sequence token septoken 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 clstoken str optional defaults to s the cls token which is a special token used as the first token for all tasks unktoken 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 padtoken str optional defaults to pad the token used for padding for example when batching sequences of different lengths masktokenstr optional defaults to mask the token used for masking values this is the token used when training this model with masking tasks this is only used in the base tokenizer type for multi tokenizer masking is never done for the downstream tasks languagecodes str optional defaults to base what language codes to use should be one of base or multi spmodelkwargs dict optional will be passed to the sentencepieceprocessor init method the python wrapper for sentencepiecehttps github comgooglesentencepiecetreemasterpython can be used among other things to set enablesampling enable subword regularization nbestsize sampling parameters for unigram invalid for bpedropout nbestsize 0 1 no sampling is performed nbestsize 1 samples from the nbestsize results nbestsize 0 assuming that nbestsize is infinite and samples from the all hypothesis lattice using forwardfilteringandbackwardsampling algorithm alpha smoothing parameter for unigram sampling and dropout probability of merge operations for bpedropout examples python from transformers import plbarttokenizer tokenizer plbarttokenizer frompretraineduclanlpplbartpythonenxx srclangpython tgtlangenxx examplepythonphrase def maximuma b c newlineindentreturn maxa b c expectedtranslationenglish returns the maximum value of a b c inputs tokenizerexamplepythonphrase texttargetexpectedtranslationenglish returntensorspt vocabfilesnames vocabfilesnames maxmodelinputsizes pretrainedpositionalembeddingssizes pretrainedvocabfilesmap pretrainedvocabfilesmap modelinputnames inputids attentionmask prefixtokens listint suffixtokens listint def init self vocabfile bostokens eostokens septokens clstokens unktokenunk padtokenpad masktokenmask languagecodesbase tokenizerfilenone srclangnone tgtlangnone spmodelkwargs optionaldictstr any none additionalspecialtokensnone kwargs mask token behave like a normal word i e include the space before it masktoken addedtokenmasktoken lstriptrue rstripfalse if isinstancemasktoken str else masktoken self spmodelkwargs if spmodelkwargs is none else spmodelkwargs srclang self convertlangcodespecialformatsrclang tgtlang self convertlangcodespecialformattgtlang self spmodel spm sentencepieceprocessorself spmodelkwargs self spmodel loadstrvocabfile self vocabfile vocabfile self languagecodes languagecodes fairseqlanguagecodes fairseqlanguagecodesself languagecodes original fairseq vocab and spm vocab must be aligned vocab 0 1 2 3 4 5 6 7 8 9 fairseq s pad s unk s de spm unk s s s de a mimic fairseq tokentoid alignment for the first 4 token self fairseqtokenstoids s 0 pad 1 s 2 unk 3 the first real token has position 4 in the original fairseq vocab and position 3 in the spm vocab self fairseqoffset 1 self spmodelsize lenself spmodel self langcodetoid code self spmodelsize i self fairseqoffset for i code in enumeratefairseqlanguagecodes self idtolangcode v k for k v in self langcodetoid items if self languagecodes base self fairseqtokenstoidsmask lenself spmodel lenself langcodetoid self fairseqoffset self fairseqtokenstoids updateself langcodetoid self fairseqidstotokens v k for k v in self fairseqtokenstoids items additionalspecialtokens listself langcodetoid keys if additionalspecialtokens is not none only add those special tokens if they are not already there additionalspecialtokens extend t for t in additionalspecialtokens if t not in additionalspecialtokens if self languagecodes base self srclang srclang self curlangcodeid self langcodetoidself srclang if self srclang is not none else self srclang else self srclang srclang if srclang is not none else enxx self curlangcodeid self langcodetoidself srclang super init bostokenbostoken eostokeneostoken unktokenunktoken septokenseptoken clstokenclstoken padtokenpadtoken masktokenmasktoken languagecodeslanguagecodes tokenizerfiletokenizerfile srclangsrclang tgtlangtgtlang additionalspecialtokensadditionalspecialtokens spmodelkwargsself spmodelkwargs kwargs self tgtlang tgtlang self setsrclangspecialtokensself srclang def getstateself state self dict copy statespmodel none statespmodelproto self spmodel serializedmodelproto return state def setstateself d self dict d for backward compatibility if not hasattrself spmodelkwargs self spmodelkwargs self spmodel spm sentencepieceprocessorself spmodelkwargs self spmodel loadfromserializedprotoself spmodelproto property def vocabsizeself if self languagecodes base return lenself spmodel lenself langcodetoid self fairseqoffset 1 plus 1 for the mask token else return lenself spmodel lenself langcodetoid self fairseqoffset property def srclangself str return self srclang srclang setter def srclangself newsrclang str none newsrclang self convertlangcodespecialformatnewsrclang self srclang newsrclang self setsrclangspecialtokensself srclang def getspecialtokensmask self tokenids0 listint tokenids1 optionallistint none alreadyhasspecialtokens bool false listint if alreadyhasspecialtokens return super getspecialtokensmask tokenids0tokenids0 tokenids1tokenids1 alreadyhasspecialtokenstrue prefixones 1 lenself prefixtokens suffixones 1 lenself suffixtokens if tokenids1 is none return prefixones 0 lentokenids0 suffixones return prefixones 0 lentokenids0 0 lentokenids1 suffixones def buildinputswithspecialtokens self tokenids0 listint tokenids1 optionallistint none listint if tokenids1 is none return self prefixtokens tokenids0 self suffixtokens we don t expect to process pairs but leave the pair logic for api consistency return self prefixtokens tokenids0 tokenids1 self suffixtokens def createtokentypeidsfromsequences self tokenids0 listint tokenids1 optionallistint none listint sep self septokenid cls self clstokenid if tokenids1 is none return lencls tokenids0 sep 0 return lencls tokenids0 sep sep tokenids1 sep 0 def buildtranslationinputs self rawinputs returntensors str srclang optionalstr tgtlang optionalstr extrakwargs converts a token str in an id using the vocab if token in self fairseqtokenstoids return self fairseqtokenstoidstoken spmid self spmodel piecetoidtoken need to return unknown token if the sp model returned 0 return spmid self fairseqoffset if spmid else self unktokenid def convertidtotokenself index converts a sequence of tokens strings for subwords in a single string outstring jointokens replacespieceunderline strip return outstring def savevocabularyself savedirectory str filenameprefix optionalstr none tuplestr if not os path isdirsavedirectory logger errorfvocabulary path savedirectory should be a directory return outvocabfile os path join savedirectory filenameprefix if filenameprefix else vocabfilesnamesvocabfile if os path abspathself vocabfile os path abspathoutvocabfile and os path isfileself vocabfile copyfileself vocabfile outvocabfile elif not os path isfileself vocabfile with openoutvocabfile wb as fi contentspiecemodel self spmodel serializedmodelproto fi writecontentspiecemodel return outvocabfile def prepareseq2seqbatch self srctexts liststr srclang str enxx tgttexts optionalliststr none tgtlang str python kwargs batchencoding self srclang self convertlangcodespecialformatsrclang self tgtlang self convertlangcodespecialformattgtlang return super prepareseq2seqbatchsrctexts tgttexts kwargs def switchtoinputmodeself return self setsrclangspecialtokensself srclang def switchtotargetmodeself return self settgtlangspecialtokensself tgtlang def setsrclangspecialtokensself srclang none reset the special tokens to the target language setting no prefix and suffixeos tgtlangcode lang self convertlangcodespecialformatlang self curlangcode self langcodetoidlang if lang is not none else none self prefixtokens if self curlangcode is not none self suffixtokens self eostokenid self curlangcode else self suffixtokens self eostokenid def convertlangcodespecialformatself lang str str coding utf 8 2022 ucla nlp the facebook ai research team s 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 construct an plbart tokenizer adapted from robertatokenizer and xlnettokenizer based on sentencepiece https github com google sentencepiece the tokenization method is tokens eos language code for source language documents and language code tokens eos for target language documents args vocab_file str path to the vocabulary file src_lang str optional a string representing the source language tgt_lang str optional a string representing the target language bos_token str optional defaults to s the start of sequence token eos_token str optional defaults to s the end of sequence token 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 cls_token str optional defaults to s the cls token which is a special token used as the first token for all tasks 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 pad_token str optional defaults to pad the token used for padding for example when batching sequences of different lengths mask_token str optional defaults to mask the token used for masking values this is the token used when training this model with masking tasks this is only used in the base tokenizer type for multi tokenizer masking is never done for the downstream tasks language_codes str optional defaults to base what language codes to use should be one of base or multi sp_model_kwargs dict optional will be passed to the sentencepieceprocessor __init__ method the python wrapper for sentencepiece https github com google sentencepiece tree master python can be used among other things to set enable_sampling enable subword regularization nbest_size sampling parameters for unigram invalid for bpe dropout nbest_size 0 1 no sampling is performed nbest_size 1 samples from the nbest_size results nbest_size 0 assuming that nbest_size is infinite and samples from the all hypothesis lattice using forward filtering and backward sampling algorithm alpha smoothing parameter for unigram sampling and dropout probability of merge operations for bpe dropout examples python from transformers import plbarttokenizer tokenizer plbarttokenizer from_pretrained uclanlp plbart python en_xx src_lang python tgt_lang en_xx example_python_phrase def maximum a b c new_line_indentreturn max a b c expected_translation_english returns the maximum value of a b c inputs tokenizer example_python_phrase text_target expected_translation_english return_tensors pt mask token behave like a normal word i e include the space before it original fairseq vocab and spm vocab must be aligned vocab 0 1 2 3 4 5 6 7 8 9 fairseq s pad s unk s de spm unk s s s de a mimic fairseq token to id alignment for the first 4 token the first real token has position 4 in the original fairseq vocab and position 3 in the spm vocab only add those special tokens if they are not already there for backward compatibility plus 1 for the mask token 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 build model inputs from a sequence or a pair of sequence for sequence classification tasks by concatenating and adding special tokens an plbart sequence has the following format where x represents the sequence input_ids for encoder x eos src_lang_code decoder_input_ids for decoder x eos tgt_lang_code bos is never used pairs of sequences are not the expected use case but they will be handled without a separator 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 we don t expect to process pairs but leave the pair logic for api consistency create a mask from the two sequences passed to be used in a sequence pair classification task plbart does not make use of token type ids therefore a list of zeros is returned 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 zeros used by translation pipeline to prepare inputs for the generate function converts a token str in an id using the vocab need to return unknown token if the sp model returned 0 converts an index integer in a token str using the vocab converts a sequence of tokens strings for sub words in a single string reset the special tokens to the source lang setting no prefix and suffix eos src_lang_code reset the special tokens to the target language setting no prefix and suffix eos tgt_lang_code convert language codes to format tokenizer uses if required
import os
from shutil import copyfile
from typing import Any, Dict, List, Optional, Tuple

import sentencepiece as spm

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


logger = logging.get_logger(__name__)

SPIECE_UNDERLINE = "▁"

VOCAB_FILES_NAMES = {"vocab_file": "sentencepiece.bpe.model", "tokenizer_file": "tokenizer.json"}

PRETRAINED_VOCAB_FILES_MAP = {
    "vocab_file": {
        "uclanlp/plbart-base": "https://huggingface.co/uclanlp/plbart-base/resolve/main/sentencepiece.bpe.model",
        "uclanlp/plbart-c-cpp-defect-detection": (
            "https://huggingface.co/uclanlp/plbart-c-cpp-defect-detection/resolve/main/sentencepiece.bpe.model"
        ),
        "uclanlp/plbart-cs-java": "https://huggingface.co/uclanlp/plbart-cs-java/resolve/main/sentencepiece.bpe.model",
        "uclanlp/plbart-en_XX-java": (
            "https://huggingface.co/uclanlp/plbart-en_XX-java/resolve/main/sentencepiece.bpe.model"
        ),
        "uclanlp/plbart-go-en_XX": (
            "https://huggingface.co/uclanlp/plbart-go-en_XX/resolve/main/sentencepiece.bpe.model"
        ),
        "uclanlp/plbart-java-clone-detection": (
            "https://huggingface.co/uclanlp/plbart-java-clone-detection/resolve/main/sentencepiece.bpe.model"
        ),
        "uclanlp/plbart-java-cs": "https://huggingface.co/uclanlp/plbart-java-cs/resolve/main/sentencepiece.bpe.model",
        "uclanlp/plbart-java-en_XX": (
            "https://huggingface.co/uclanlp/plbart-java-en_XX/resolve/main/sentencepiece.bpe.model"
        ),
        "uclanlp/plbart-javascript-en_XX": (
            "https://huggingface.co/uclanlp/plbart-javascript-en_XX/resolve/main/sentencepiece.bpe.model"
        ),
        "uclanlp/plbart-php-en_XX": (
            "https://huggingface.co/uclanlp/plbart-php-en_XX/resolve/main/sentencepiece.bpe.model"
        ),
        "uclanlp/plbart-python-en_XX": (
            "https://huggingface.co/uclanlp/plbart-python-en_XX/resolve/main/sentencepiece.bpe.model"
        ),
        "uclanlp/plbart-refine-java-medium": (
            "https://huggingface.co/uclanlp/plbart-refine-java-medium/resolve/main/sentencepiece.bpe.model"
        ),
        "uclanlp/plbart-refine-java-small": (
            "https://huggingface.co/uclanlp/plbart-refine-java-small/resolve/main/sentencepiece.bpe.model"
        ),
        "uclanlp/plbart-ruby-en_XX": (
            "https://huggingface.co/uclanlp/plbart-ruby-en_XX/resolve/main/sentencepiece.bpe.model"
        ),
    }
}

PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES = {
    "uclanlp/plbart-base": 1024,
    "uclanlp/plbart-c-cpp-defect-detection": 1024,
    "uclanlp/plbart-cs-java": 1024,
    "uclanlp/plbart-en_XX-java": 1024,
    "uclanlp/plbart-go-en_XX": 1024,
    "uclanlp/plbart-java-clone-detection": 1024,
    "uclanlp/plbart-java-cs": 1024,
    "uclanlp/plbart-java-en_XX": 1024,
    "uclanlp/plbart-javascript-en_XX": 1024,
    "uclanlp/plbart-php-en_XX": 1024,
    "uclanlp/plbart-python-en_XX": 1024,
    "uclanlp/plbart-refine-java-medium": 1024,
    "uclanlp/plbart-refine-java-small": 1024,
    "uclanlp/plbart-ruby-en_XX": 1024,
}

FAIRSEQ_LANGUAGE_CODES = {
    "base": ["__java__", "__python__", "__en_XX__"],
    "multi": ["__java__", "__python__", "__en_XX__", "__javascript__", "__php__", "__ruby__", "__go__"],
}

FAIRSEQ_LANGUAGE_CODES_MAP = {
    "java": "__java__",
    "python": "__python__",
    "en_XX": "__en_XX__",
    "javascript": "__javascript__",
    "php": "__php__",
    "ruby": "__ruby__",
    "go": "__go__",
}


class PLBartTokenizer(PreTrainedTokenizer):
    

    vocab_files_names = VOCAB_FILES_NAMES
    max_model_input_sizes = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
    pretrained_vocab_files_map = PRETRAINED_VOCAB_FILES_MAP
    model_input_names = ["input_ids", "attention_mask"]

    prefix_tokens: List[int] = []
    suffix_tokens: List[int] = []

    def __init__(
        self,
        vocab_file,
        bos_token="<s>",
        eos_token="</s>",
        sep_token="</s>",
        cls_token="<s>",
        unk_token="<unk>",
        pad_token="<pad>",
        mask_token="<mask>",
        language_codes="base",
        tokenizer_file=None,
        src_lang=None,
        tgt_lang=None,
        sp_model_kwargs: Optional[Dict[str, Any]] = None,
        additional_special_tokens=None,
        **kwargs,
    ):
        
        mask_token = AddedToken(mask_token, lstrip=True, rstrip=False) if isinstance(mask_token, str) else mask_token

        self.sp_model_kwargs = {} if sp_model_kwargs is None else sp_model_kwargs
        src_lang = self._convert_lang_code_special_format(src_lang)
        tgt_lang = self._convert_lang_code_special_format(tgt_lang)

        self.sp_model = spm.SentencePieceProcessor(**self.sp_model_kwargs)
        self.sp_model.Load(str(vocab_file))
        self.vocab_file = vocab_file
        self.language_codes = language_codes

        fairseq_language_codes = FAIRSEQ_LANGUAGE_CODES[self.language_codes]

        
        
        
        
        

        
        self.fairseq_tokens_to_ids = {"<s>": 0, "<pad>": 1, "</s>": 2, "<unk>": 3}

        
        self.fairseq_offset = 1

        self.sp_model_size = len(self.sp_model)
        self.lang_code_to_id = {
            code: self.sp_model_size + i + self.fairseq_offset for i, code in enumerate(fairseq_language_codes)
        }
        self.id_to_lang_code = {v: k for k, v in self.lang_code_to_id.items()}

        if self.language_codes == "base":
            self.fairseq_tokens_to_ids["<mask>"] = len(self.sp_model) + len(self.lang_code_to_id) + self.fairseq_offset

        self.fairseq_tokens_to_ids.update(self.lang_code_to_id)
        self.fairseq_ids_to_tokens = {v: k for k, v in self.fairseq_tokens_to_ids.items()}
        _additional_special_tokens = list(self.lang_code_to_id.keys())

        if additional_special_tokens is not None:
            
            _additional_special_tokens.extend(
                [t for t in additional_special_tokens if t not in _additional_special_tokens]
            )

        if self.language_codes == "base":
            self._src_lang = src_lang
            self.cur_lang_code_id = (
                self.lang_code_to_id[self._src_lang] if self._src_lang is not None else self._src_lang
            )
        else:
            self._src_lang = src_lang if src_lang is not None else "__en_XX__"
            self.cur_lang_code_id = self.lang_code_to_id[self._src_lang]

        super().__init__(
            bos_token=bos_token,
            eos_token=eos_token,
            unk_token=unk_token,
            sep_token=sep_token,
            cls_token=cls_token,
            pad_token=pad_token,
            mask_token=mask_token,
            language_codes=language_codes,
            tokenizer_file=tokenizer_file,
            src_lang=src_lang,
            tgt_lang=tgt_lang,
            additional_special_tokens=_additional_special_tokens,
            sp_model_kwargs=self.sp_model_kwargs,
            **kwargs,
        )

        self.tgt_lang = tgt_lang
        self.set_src_lang_special_tokens(self._src_lang)

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

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

        
        if not hasattr(self, "sp_model_kwargs"):
            self.sp_model_kwargs = {}

        self.sp_model = spm.SentencePieceProcessor(**self.sp_model_kwargs)
        self.sp_model.LoadFromSerializedProto(self.sp_model_proto)

    @property
    def vocab_size(self):
        if self.language_codes == "base":
            return (
                len(self.sp_model) + len(self.lang_code_to_id) + self.fairseq_offset + 1
            )  
        else:
            return len(self.sp_model) + len(self.lang_code_to_id) + self.fairseq_offset

    @property
    def src_lang(self) -> str:
        return self._src_lang

    @src_lang.setter
    def src_lang(self, new_src_lang: str) -> None:
        new_src_lang = self._convert_lang_code_special_format(new_src_lang)
        self._src_lang = new_src_lang
        self.set_src_lang_special_tokens(self._src_lang)

    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
            )

        prefix_ones = [1] * len(self.prefix_tokens)
        suffix_ones = [1] * len(self.suffix_tokens)
        if token_ids_1 is None:
            return prefix_ones + ([0] * len(token_ids_0)) + suffix_ones
        return prefix_ones + ([0] * len(token_ids_0)) + ([0] * len(token_ids_1)) + suffix_ones

    def build_inputs_with_special_tokens(
        self, token_ids_0: List[int], token_ids_1: Optional[List[int]] = None
    ) -> List[int]:
        
        if token_ids_1 is None:
            return self.prefix_tokens + token_ids_0 + self.suffix_tokens
        
        return self.prefix_tokens + token_ids_0 + token_ids_1 + self.suffix_tokens

    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 + sep + token_ids_1 + sep) * [0]

    def _build_translation_inputs(
        self, raw_inputs, return_tensors: str, src_lang: Optional[str], tgt_lang: Optional[str], **extra_kwargs
    ):
        
        if src_lang is None or tgt_lang is None:
            raise ValueError("Translation requires a `src_lang` and a `tgt_lang` for this model")
        self.src_lang = self._convert_lang_code_special_format(src_lang)
        self.tgt_lang = self._convert_lang_code_special_format(tgt_lang)
        inputs = self(raw_inputs, add_special_tokens=True, return_tensors=return_tensors, **extra_kwargs)
        tgt_lang_id = self.convert_tokens_to_ids(self.tgt_lang)
        inputs["forced_bos_token_id"] = tgt_lang_id
        return inputs

    def get_vocab(self):
        vocab = {self.convert_ids_to_tokens(i): i for i in range(self.vocab_size)}
        vocab.update(self.added_tokens_encoder)
        return vocab

    def _tokenize(self, text: str) -> List[str]:
        return self.sp_model.encode(text, out_type=str)

    def _convert_token_to_id(self, token):
        
        if token in self.fairseq_tokens_to_ids:
            return self.fairseq_tokens_to_ids[token]
        spm_id = self.sp_model.PieceToId(token)

        
        return spm_id + self.fairseq_offset if spm_id else self.unk_token_id

    def _convert_id_to_token(self, index):
        
        if index in self.fairseq_ids_to_tokens:
            return self.fairseq_ids_to_tokens[index]
        return self.sp_model.IdToPiece(index - self.fairseq_offset)

    def convert_tokens_to_string(self, tokens):
        
        out_string = "".join(tokens).replace(SPIECE_UNDERLINE, " ").strip()
        return out_string

    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
        out_vocab_file = os.path.join(
            save_directory, (filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"]
        )

        if os.path.abspath(self.vocab_file) != os.path.abspath(out_vocab_file) and os.path.isfile(self.vocab_file):
            copyfile(self.vocab_file, out_vocab_file)
        elif not os.path.isfile(self.vocab_file):
            with open(out_vocab_file, "wb") as fi:
                content_spiece_model = self.sp_model.serialized_model_proto()
                fi.write(content_spiece_model)

        return (out_vocab_file,)

    def prepare_seq2seq_batch(
        self,
        src_texts: List[str],
        src_lang: str = "en_XX",
        tgt_texts: Optional[List[str]] = None,
        tgt_lang: str = "python",
        **kwargs,
    ) -> BatchEncoding:
        self.src_lang = self._convert_lang_code_special_format(src_lang)
        self.tgt_lang = self._convert_lang_code_special_format(tgt_lang)
        return super().prepare_seq2seq_batch(src_texts, tgt_texts, **kwargs)

    def _switch_to_input_mode(self):
        return self.set_src_lang_special_tokens(self.src_lang)

    def _switch_to_target_mode(self):
        return self.set_tgt_lang_special_tokens(self.tgt_lang)

    def set_src_lang_special_tokens(self, src_lang) -> None:
        
        src_lang = self._convert_lang_code_special_format(src_lang)
        self.cur_lang_code = self.lang_code_to_id[src_lang] if src_lang is not None else None
        self.prefix_tokens = []
        if self.cur_lang_code is not None:
            self.suffix_tokens = [self.eos_token_id, self.cur_lang_code]
        else:
            self.suffix_tokens = [self.eos_token_id]

    def set_tgt_lang_special_tokens(self, lang: str) -> None:
        
        lang = self._convert_lang_code_special_format(lang)

        self.cur_lang_code = self.lang_code_to_id[lang] if lang is not None else None
        self.prefix_tokens = []
        if self.cur_lang_code is not None:
            self.suffix_tokens = [self.eos_token_id, self.cur_lang_code]
        else:
            self.suffix_tokens = [self.eos_token_id]

    def _convert_lang_code_special_format(self, lang: str) -> str:
        
        lang = FAIRSEQ_LANGUAGE_CODES_MAP[lang] if lang in FAIRSEQ_LANGUAGE_CODES_MAP.keys() else lang
        return lang