text: # Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
  # Copyright 2018 The Google AI Language Team Authors 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.
  
  import os
  import pickle
  import six
  import shutil
  
  from paddle.utils import try_import
  from paddlenlp.utils.env import MODEL_HOME
  
  from .. import BasicTokenizer, PretrainedTokenizer, WordpieceTokenizer
  
  __all__ = ['PPMiniLMTokenizer']
  
  
  class PPMiniLMTokenizer(PretrainedTokenizer):
      r"""
      Constructs an PPMiniLM tokenizer. It uses a basic tokenizer to do punctuation
      splitting, lower casing and so on, and follows a WordPiece tokenizer to
      tokenize as subwords.
  
      This tokenizer inherits from :class:`~paddlenlp.transformers.tokenizer_utils.PretrainedTokenizer`
      which contains most of the main methods. For more information regarding those methods,
      please refer to this superclass.
  
      Args:
          vocab_file (str): 
              The vocabulary file path (ends with '.txt') required to instantiate
              a `WordpieceTokenizer`.
          do_lower_case (str, optional): 
              Whether or not to lowercase the input when tokenizing.
              Defaults to`True`.
          unk_token (str, optional): 
              A special token representing the *unknown (out-of-vocabulary)* token.
              An unknown token is set to be `unk_token` inorder to be converted to an ID.
              Defaults to "[UNK]".
          sep_token (str, optional): 
              A special token separating two different sentences in the same input.
              Defaults to "[SEP]".
          pad_token (str, optional): 
              A special token used to make arrays of tokens the same size for batching purposes.
              Defaults to "[PAD]".
          cls_token (str, optional): 
              A special token used for sequence classification. It is the last token
              of the sequence when built with special tokens. Defaults to "[CLS]".
          mask_token (str, optional): 
              A special token representing a masked token. This is the token used
              in the masked language modeling task which the model tries to predict the original unmasked ones.
              Defaults to "[MASK]".
      
      Examples:
          .. code-block::
  
              from paddlenlp.transformers import PPMiniLMTokenizer
              tokenizer = PPMiniLMTokenizer.from_pretrained('ppminilm-6l-768h')
  
              encoded_inputs = tokenizer('He was a puppeteer')
              # encoded_inputs: 
              # { 'input_ids': [1, 4444, 4385, 1545, 6712, 10062, 9568, 9756, 9500, 2],
              #  'token_type_ids': [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]}
              # }
  
      """
      resource_files_names = {"vocab_file": "vocab.txt"}  # for save_pretrained
      pretrained_resource_files_map = {
          "vocab_file": {
              "ppminilm-6l-768h":
              "https://bj.bcebos.com/paddlenlp/models/transformers/ppminilm-6l-768h/vocab.txt",
          }
      }
      pretrained_init_configuration = {
          "ppminilm-6l-768h": {
              "do_lower_case": True
          },
      }
  
      def __init__(self,
                   vocab_file,
                   do_lower_case=True,
                   unk_token="[UNK]",
                   sep_token="[SEP]",
                   pad_token="[PAD]",
                   cls_token="[CLS]",
                   mask_token="[MASK]",
                   **kwargs):
  
          if not os.path.isfile(vocab_file):
              raise ValueError(
                  "Can't find a vocabulary file at path '{}'. To load the "
                  "vocabulary from a pretrained model please use "
                  "`tokenizer = PPMiniLMTokenizer.from_pretrained(PRETRAINED_MODEL_NAME)`"
                  .format(vocab_file))
          self.do_lower_case = do_lower_case
          self.vocab = self.load_vocabulary(vocab_file, unk_token=unk_token)
          self.basic_tokenizer = BasicTokenizer(do_lower_case=do_lower_case)
          self.wordpiece_tokenizer = WordpieceTokenizer(vocab=self.vocab,
                                                        unk_token=unk_token)
  
      @property
      def vocab_size(self):
          """
          Return the size of vocabulary.
  
          Returns:
              int: The size of vocabulary.
          """
          return len(self.vocab)
  
      def _tokenize(self, text):
          r"""
          End-to-end tokenization for PPMiniM models.
  
          Args:
              text (str): The text to be tokenized.
          
          Returns:
              List[str]: A list of string representing converted tokens.
          """
          split_tokens = []
          for token in self.basic_tokenizer.tokenize(text):
              for sub_token in self.wordpiece_tokenizer.tokenize(token):
                  split_tokens.append(sub_token)
          return split_tokens
  
      def convert_tokens_to_string(self, tokens):
          r"""
          Converts a sequence of tokens (list of string) in a single string. Since
          the usage of WordPiece introducing `##` to concat subwords, also remove
          `##` when converting.
  
          Args:
              tokens (List[str]): A list of string representing tokens to be converted.
  
          Returns:
              str: Converted string from tokens.
  
          Examples:
              .. code-block::
  
                  from paddlenlp.transformers import PPMiniLMTokenizer
                  tokenizer = PPMiniLMTokenizer.from_pretrained('ppminilm-6l-768h')
  
                  tokens = tokenizer.tokenize('He was a puppeteer')
                  strings = tokenizer.convert_tokens_to_string(tokens)
                  #he was a puppeteer
  
          """
          out_string = " ".join(tokens).replace(" ##", "").strip()
          return out_string
  
      def num_special_tokens_to_add(self, pair=False):
          r"""
          Returns the number of added tokens when encoding a sequence with special tokens.
  
          Note:
              This encodes inputs and checks the number of added tokens, and is therefore not efficient. 
              Do not put this inside your training loop.
  
          Args:
              pair (bool, optional):
                  Whether the input is a sequence pair or a single sequence.
                  Defaults to `False` and the input is a single sequence.
  
          Returns:
              int: Number of tokens added to sequences
          """
          token_ids_0 = []
          token_ids_1 = []
          return len(
              self.build_inputs_with_special_tokens(
                  token_ids_0, token_ids_1 if pair else None))
  
      def build_inputs_with_special_tokens(self, token_ids_0, token_ids_1=None):
          r"""
          Build model inputs from a sequence or a pair of sequence for sequence classification tasks by concatenating and
          adding special tokens.
  
          A sequence has the following format:
  
          - single sequence:      ``[CLS] X [SEP]``
          - pair of sequences:        ``[CLS] A [SEP] B [SEP]``
  
          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.
                  Defaults to `None`.
  
          Returns:
              List[int]: List of input_id with the appropriate special tokens.
          """
          if token_ids_1 is None:
              return [self.cls_token_id] + token_ids_0 + [self.sep_token_id]
          _cls = [self.cls_token_id]
          _sep = [self.sep_token_id]
          return _cls + token_ids_0 + _sep + token_ids_1 + _sep
  
      def build_offset_mapping_with_special_tokens(self,
                                                   offset_mapping_0,
                                                   offset_mapping_1=None):
          r"""
          Build offset map from a pair of offset map by concatenating and adding offsets of special tokens. 
          
          An offset_mapping has the following format:
  
          - single sequence:      ``(0,0) X (0,0)``
          - pair of sequences:        ``(0,0) A (0,0) B (0,0)``
          
          Args:
              offset_mapping_ids_0 (List[tuple]):
                  List of char offsets to which the special tokens will be added.
              offset_mapping_ids_1 (List[tuple], optional):
                  Optional second list of wordpiece offsets for offset mapping pairs.
                  Defaults to `None`.
  
          Returns:
              List[tuple]: A list of wordpiece offsets with the appropriate offsets of special tokens.
          """
          if offset_mapping_1 is None:
              return [(0, 0)] + offset_mapping_0 + [(0, 0)]
  
          return [(0, 0)] + offset_mapping_0 + [(0, 0)
                                                ] + offset_mapping_1 + [(0, 0)]
  
      def create_token_type_ids_from_sequences(self,
                                               token_ids_0,
                                               token_ids_1=None):
          r"""
          Create a mask from the two sequences passed to be used in a sequence-pair classification task. 
  
          A 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]):
                  A list of `inputs_ids` for the first sequence.
              token_ids_1 (List[int], optional):
                  Optional second list of IDs for sequence pairs. 
                  Defaults to `None`.
  
          Returns:
              List[int]: List of token_type_id according to the given sequence(s).
          """
          _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]
  