
'''simple docstring'''

def 		_UpperCAmelCase (     _lowerCamelCase  :				str     ,					_lowerCamelCase  :				Optional[Any]						)			->  bool:
  _lowerCAmelCase				:     List[str]       =    len(_lowerCAmelCase						)
  _lowerCAmelCase				:     Dict       =    [[False] * (required_sum + 1) for _ in range(arr_len + 1						)]

  # for each arr value, a sum of zero(0) can be formed by not taking any element
  # hence True/1
  for i in range(arr_len + 1						):
    _lowerCAmelCase				:     List[str]       =    True

  # sum is not zero and set is empty then false
  for i in range(1     ,					required_sum + 1						):
    _lowerCAmelCase				:     int       =    False

  for i in range(1     ,					arr_len + 1						):
    for j in range(1     ,					required_sum + 1						):
      if arr[i - 1] > j:
        _lowerCAmelCase				:     Optional[int]       =    subset[i - 1][j]
      if arr[i - 1] <= j:
        _lowerCAmelCase				:     Optional[int]       =    subset[i - 1][j] or subset[i - 1][j - arr[i - 1]]

  return subset[arr_len][required_sum]


if __name__ == "__main__":
     import doctest

     doctest.testmod()







import os
from shutil import copyfile
from typing import Any, Dict, List, Optional, Tuple

import sentencepiece as spm

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


SCREAMING_SNAKE_CASE_:List[Any]             =						"""▁"""

SCREAMING_SNAKE_CASE_:int             =						{"""vocab_file""": """spiece.model"""}

SCREAMING_SNAKE_CASE_:Any             =						{
    """vocab_file""": {"""google/pegasus-xsum""": """https://huggingface.co/google/pegasus-xsum/resolve/main/spiece.model"""}
}

SCREAMING_SNAKE_CASE_:Optional[Any]             =						{
    """google/pegasus-xsum""": 512,
}


SCREAMING_SNAKE_CASE_:Tuple             =						logging.get_logger(__name__)






class SCREAMING_SNAKE_CASE__     (		SCREAMING_SNAKE_CASE__    ):




    '''simple docstring'''






    __lowerCamelCase			: Union[str, Any]					=      VOCAB_FILES_NAMES

    __lowerCamelCase			: List[Any]					=      VOCAB_FILES_NAMES
    __lowerCamelCase			: Optional[Any]					=      PRETRAINED_VOCAB_FILES_MAP
    __lowerCamelCase			: str					=      PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
    __lowerCamelCase			: str					=      ["input_ids", "attention_mask"]






    def __init__(       self,		lowerCamelCase__,		lowerCamelCase__="<pad>",		lowerCamelCase__="</s>",		lowerCamelCase__="<unk>",		lowerCamelCase__="<mask_2>",		lowerCamelCase__="<mask_1>",		lowerCamelCase__=None,		lowerCamelCase__=103,		lowerCamelCase__ = None,		**lowerCamelCase__,		):
        A :       int          =   offset
        if additional_special_tokens is not None:
            if not isinstance(lowerCamelCase__,		lowerCamelCase__		):
                raise TypeError(
                    f'''additional_special_tokens should be of type {type(lowerCamelCase__		)}, but is'''
                    f''' {type(lowerCamelCase__		)}'''		)

            A :       Dict          =   (
                ([mask_token_sent] + additional_special_tokens)
                if mask_token_sent not in additional_special_tokens and mask_token_sent is not None
                else additional_special_tokens
            )
            # fill additional tokens with ..., <unk_token_102> in case not all additional tokens are already taken
            additional_special_tokens_extended += [
                f'''<unk_{i}>''' for i in range(len(lowerCamelCase__		),		self.offset - 1		)
            ]

            if len(set(lowerCamelCase__		)		) != len(lowerCamelCase__		):
                raise ValueError(
                    """Please make sure that the provided additional_special_tokens do not contain an incorrectly"""
                    f''' shifted list of <unk_x> tokens. Found {additional_special_tokens_extended}.'''		)
            A :       int          =   additional_special_tokens_extended
        else:
            A :       Optional[int]          =   [mask_token_sent] if mask_token_sent is not None else []
            additional_special_tokens += [f'''<unk_{i}>''' for i in range(2,		self.offset		)]

        A :       Any          =   {} if sp_model_kwargs is None else sp_model_kwargs

        super().__init__(
            eos_token=lowerCamelCase__,		unk_token=lowerCamelCase__,		mask_token=lowerCamelCase__,		pad_token=lowerCamelCase__,		mask_token_sent=lowerCamelCase__,		offset=lowerCamelCase__,		additional_special_tokens=lowerCamelCase__,		sp_model_kwargs=self.sp_model_kwargs,		**lowerCamelCase__,		)
        A :       Union[str, Any]          =   mask_token_sent
        A :       Optional[Any]          =   vocab_file
        A :       Optional[int]          =   spm.SentencePieceProcessor(**self.sp_model_kwargs		)
        self.sp_model.Load(lowerCamelCase__		)

        # add special tokens to encoder dict
        A :       Dict[int, str]          =   {
            0: self.pad_token,
            1: self.eos_token,
        }

        if self.mask_token_sent is not None:
            self.encoder.update(
                {
                    2: self.mask_token_sent,
                    3: self.mask_token,
                }		)

        if self.offset > 0:
            # entries 2-104 are only used for pretraining and called <mask_1>, <mask_2>, unk_2, ...unk_102
            # mask_token_sent is already added to list -> so start at 1
            self.encoder.update({i + 3: additional_special_tokens[i] for i in range(1,		self.offset - 1		)}		)

        A :       Dict[str, int]          =   {v: k for k, v in self.encoder.items()}






    @property
    def 			_lowerCAmelCase					(       self		):
        return len(self.sp_model		) + self.offset






    def 			_lowerCAmelCase					(       self		):
        A :       Optional[int]          =   {self.convert_ids_to_tokens(lowerCamelCase__		): i for i in range(self.vocab_size		)}
        vocab.update(self.added_tokens_encoder		)
        return vocab






    def __getstate__(       self		):
        A :       List[Any]          =   self.__dict__.copy()
        A :       Union[str, Any]          =   None
        return state






    def __setstate__(       self,		lowerCamelCase__		):
        A :       List[Any]          =   d

        # for backward compatibility
        if not hasattr(self,		"""sp_model_kwargs"""		):
            A :       int          =   {}

        A :       Tuple          =   spm.SentencePieceProcessor(**self.sp_model_kwargs		)
        self.sp_model.Load(self.vocab_file		)






    def 			_lowerCAmelCase					(       self,		lowerCamelCase__		):
        return self.sp_model.encode(lowerCamelCase__,		out_type=lowerCamelCase__		)






    def 			_lowerCAmelCase					(       self,		lowerCamelCase__		):
        if token in self.decoder:
            return self.decoder[token]
        elif token in self.added_tokens_decoder:
            return self.added_tokens_decoder[token]
        A :       List[str]          =   self.sp_model.piece_to_id(lowerCamelCase__		)
        return sp_id + self.offset






    def 			_lowerCAmelCase					(       self,		lowerCamelCase__		):
        if index in self.encoder:
            return self.encoder[index]
        elif index in self.added_tokens_encoder:
            return self.added_tokens_encoder[index]
        else:
            A :       Dict          =   self.sp_model.IdToPiece(index - self.offset		)
        return token






    def 			_lowerCAmelCase					(       self,		lowerCamelCase__		):
        A :       Optional[int]          =   []
        A :       Optional[Any]          =   """"""
        for token in tokens:
            # make sure that special tokens are not decoded using sentencepiece model
            if token in self.all_special_tokens:
                out_string += self.sp_model.decode(lowerCamelCase__		) + token
                A :       int          =   []
            else:
                current_sub_tokens.append(lowerCamelCase__		)
        out_string += self.sp_model.decode(lowerCamelCase__		)
        return out_string.strip()






    def 			_lowerCAmelCase					(       self,		lowerCamelCase__=False		):
        return 1






    def 			_lowerCAmelCase					(       self,		lowerCamelCase__		):
        A :       Optional[int]          =   set(self.all_special_ids		)  # call it once instead of inside list comp
        all_special_ids.remove(self.unk_token_id		)  # <unk> is only sometimes special

        return [1 if x in all_special_ids else 0 for x in seq]






    def 			_lowerCAmelCase					(       self,		lowerCamelCase__,		lowerCamelCase__ = None,		lowerCamelCase__ = False		):
        if already_has_special_tokens:
            return self._special_token_mask(lowerCamelCase__		)
        elif token_ids_a is None:
            return self._special_token_mask(lowerCamelCase__		) + [1]
        else:
            return self._special_token_mask(token_ids_a + token_ids_a		) + [1]






    def 			_lowerCAmelCase					(       self,		lowerCamelCase__,		lowerCamelCase__=None		):
        if token_ids_a is None:
            return token_ids_a + [self.eos_token_id]
        # We don't expect to process pairs, but leave the pair logic for API consistency
        return token_ids_a + token_ids_a + [self.eos_token_id]






    def 			_lowerCAmelCase					(       self,		lowerCamelCase__,		lowerCamelCase__ = None		):
        if not os.path.isdir(lowerCamelCase__		):
            logger.error(f'''Vocabulary path ({save_directory}) should be a directory'''		)
            return
        A :       Any          =   os.path.join(
            lowerCamelCase__,		(filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab_file"""]		)

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

        return (out_vocab_file,)


