






'''simple docstring'''




import json
import os
from functools import lru_cache
from typing import Dict, List, Optional, Tuple, Union

import regex as re

from ...tokenization_utils import AddedToken, PreTrainedTokenizer
from ...tokenization_utils_base import BatchEncoding, EncodedInput
from ...utils import PaddingStrategy, logging


lowerCamelCase_				   =   logging.get_logger(__name__)


lowerCamelCase_				   =   {'''vocab_file''': '''vocab.json''', '''merges_file''': '''merges.txt'''}

# See all LED models at https://huggingface.co/models?filter=LED
lowerCamelCase_				   =   {
    '''vocab_file''': {
        '''allenai/led-base-16384''': '''https://huggingface.co/allenai/led-base-16384/resolve/main/vocab.json''',
    },
    '''merges_file''': {
        '''allenai/led-base-16384''': '''https://huggingface.co/allenai/led-base-16384/resolve/main/merges.txt''',
    },
    '''tokenizer_file''': {
        '''allenai/led-base-16384''': '''https://huggingface.co/allenai/led-base-16384/resolve/main/tokenizer.json''',
    },
}

lowerCamelCase_				   =   {
    '''allenai/led-base-16384''': 1_63_84,
}

@lru_cache()
# Copied from transformers.models.bart.tokenization_bart.bytes_to_unicode
def    __lowercase		(     )			->		Optional[Any]:

      '''simple docstring'''


      _A     	=      (
          list(range(ord("!"			)  ,    ord("~"			) + 1			)			) + list(range(ord("¡"			)  ,    ord("¬"			) + 1			)			) + list(range(ord("®"			)  ,    ord("ÿ"			) + 1			)			)
      )
      _A     	=      bs[:]
      _A     	=      0
      for b in range(2**8			):
            if b not in bs:
                  bs.append(__snake_case			)
                  cs.append(2**8 + n			)
                  n += 1
      _A     	=      [chr(__snake_case			) for n in cs]
      return dict(zip(__snake_case  ,    __snake_case			)			)

def    __lowercase		(     __lowercase			)			->		str:

      '''simple docstring'''


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


class   _UpperCAmelCase     (	a__		):




   """simple docstring"""

   snake_case       							=		VOCAB_FILES_NAMES
   snake_case       							=		PRETRAINED_VOCAB_FILES_MAP
   snake_case       							=		PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
   snake_case       							=		['''input_ids''', '''attention_mask''']

   def __init__(						self					:      Optional[int] , __UpperCAmelCase					:      Optional[int] , __UpperCAmelCase					:      Optional[int] , __UpperCAmelCase					:      List[Any]="replace" , __UpperCAmelCase					:      Tuple="<s>" , __UpperCAmelCase					:      Optional[Any]="</s>" , __UpperCAmelCase					:      Dict="</s>" , __UpperCAmelCase					:      str="<s>" , __UpperCAmelCase					:      Any="<unk>" , __UpperCAmelCase					:      Optional[Any]="<pad>" , __UpperCAmelCase					:      Dict="<mask>" , __UpperCAmelCase					:      int=False , **__UpperCAmelCase					:      Union[str, Any] , ):





         '''simple docstring'''





         _A     	=      AddedToken(_UpperCAmelCase , lstrip=_UpperCAmelCase , rstrip=_UpperCAmelCase						) if isinstance(_UpperCAmelCase , _UpperCAmelCase						) else bos_token
         _A     	=      AddedToken(_UpperCAmelCase , lstrip=_UpperCAmelCase , rstrip=_UpperCAmelCase						) if isinstance(_UpperCAmelCase , _UpperCAmelCase						) else eos_token
         _A     	=      AddedToken(_UpperCAmelCase , lstrip=_UpperCAmelCase , rstrip=_UpperCAmelCase						) if isinstance(_UpperCAmelCase , _UpperCAmelCase						) else sep_token
         _A     	=      AddedToken(_UpperCAmelCase , lstrip=_UpperCAmelCase , rstrip=_UpperCAmelCase						) if isinstance(_UpperCAmelCase , _UpperCAmelCase						) else cls_token
         _A     	=      AddedToken(_UpperCAmelCase , lstrip=_UpperCAmelCase , rstrip=_UpperCAmelCase						) if isinstance(_UpperCAmelCase , _UpperCAmelCase						) else unk_token
         _A     	=      AddedToken(_UpperCAmelCase , lstrip=_UpperCAmelCase , rstrip=_UpperCAmelCase						) if isinstance(_UpperCAmelCase , _UpperCAmelCase						) else pad_token

         # Mask token behave like a normal word, i.e. include the space before it
         _A     	=      AddedToken(_UpperCAmelCase , lstrip=_UpperCAmelCase , rstrip=_UpperCAmelCase						) if isinstance(_UpperCAmelCase , _UpperCAmelCase						) else mask_token

         super().__init__(
             errors=_UpperCAmelCase , bos_token=_UpperCAmelCase , eos_token=_UpperCAmelCase , unk_token=_UpperCAmelCase , sep_token=_UpperCAmelCase , cls_token=_UpperCAmelCase , pad_token=_UpperCAmelCase , mask_token=_UpperCAmelCase , add_prefix_space=_UpperCAmelCase , **_UpperCAmelCase , )

         with open(_UpperCAmelCase , encoding="utf-8"						) as vocab_handle:
               _A     	=      json.load(_UpperCAmelCase						)
         _A     	=      {v: k for k, v in self.encoder.items()}
         _A     	=      errors  # how to handle errors in decoding
         _A     	=      bytes_to_unicode()
         _A     	=      {v: k for k, v in self.byte_encoder.items()}
         with open(_UpperCAmelCase , encoding="utf-8"						) as merges_handle:
               _A     	=      merges_handle.read().split("\n"						)[1:-1]
         _A     	=      [tuple(merge.split()						) for merge in bpe_merges]
         _A     	=      dict(zip(_UpperCAmelCase , range(len(_UpperCAmelCase						)						)						)						)
         _A     	=      {}
         _A     	=      add_prefix_space

         # Should have added re.IGNORECASE so BPE merges can happen for capitalized versions of contractions
         _A     	=      re.compile(R"\'s|\'t|\'re|\'ve|\'m|\'ll|\'d| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+"						)

   @property
   # Copied from transformers.models.bart.tokenization_bart.BartTokenizer.vocab_size
   def 		lowerCAmelCase					(						self					:      List[Any]						):





         '''simple docstring'''





         return len(self.encoder						)

   def 		lowerCAmelCase					(						self					:      List[Any]						):





         '''simple docstring'''





         return dict(self.encoder , **self.added_tokens_encoder						)

   def 		lowerCAmelCase					(						self					:      Union[str, Any] , __UpperCAmelCase					:      Optional[Any]						):





         '''simple docstring'''





         if token in self.cache:
               return self.cache[token]
         _A     	=      tuple(_UpperCAmelCase						)
         _A     	=      get_pairs(_UpperCAmelCase						)

         if not pairs:
               return token

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

                     if word[i] == first and i < len(_UpperCAmelCase						) - 1 and word[i + 1] == second:
                           new_word.append(first + second						)
                           i += 2
                     else:
                           new_word.append(word[i]						)
                           i += 1
               _A     	=      tuple(_UpperCAmelCase						)
               _A     	=      new_word
               if len(_UpperCAmelCase						) == 1:
                     break
               else:
                     _A     	=      get_pairs(_UpperCAmelCase						)
         _A     	=      ' '.join(_UpperCAmelCase						)
         _A     	=      word
         return word

   def 		lowerCAmelCase					(						self					:      Optional[int] , __UpperCAmelCase					:      Any						):





         '''simple docstring'''





         _A     	=      []
         for token in re.findall(self.pat , _UpperCAmelCase						):
               _A     	=      ''.join(
                   self.byte_encoder[b] for b in token.encode("utf-8"						)						)  # Maps all our bytes to unicode strings, avoiding control tokens of the BPE (spaces in our case)
               bpe_tokens.extend(bpe_token for bpe_token in self.bpe(_UpperCAmelCase						).split(" "						)						)
         return bpe_tokens

   def 		lowerCAmelCase					(						self					:      Dict , __UpperCAmelCase					:      Dict						):





         '''simple docstring'''





         return self.encoder.get(_UpperCAmelCase , self.encoder.get(self.unk_token						)						)

   def 		lowerCAmelCase					(						self					:      Tuple , __UpperCAmelCase					:      str						):





         '''simple docstring'''





         return self.decoder.get(_UpperCAmelCase						)

   def 		lowerCAmelCase					(						self					:      int , __UpperCAmelCase					:      Any						):





         '''simple docstring'''





         _A     	=      ''.join(_UpperCAmelCase						)
         _A     	=      bytearray([self.byte_decoder[c] for c in text]						).decode("utf-8" , errors=self.errors						)
         return text

   def 		lowerCAmelCase					(						self					:      Tuple , __UpperCAmelCase					:      Optional[Any] , __UpperCAmelCase					:      Union[str, Any] = None						):





         '''simple docstring'''





         if not os.path.isdir(_UpperCAmelCase						):
               logger.error(f'''Vocabulary path ({save_directory}) should be a directory'''						)
               return
         _A     	=      os.path.join(
             _UpperCAmelCase , (filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"]						)
         _A     	=      os.path.join(
             _UpperCAmelCase , (filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["merges_file"]						)

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

         _A     	=      0
         with open(_UpperCAmelCase , "w" , encoding="utf-8"						) as writer:
               writer.write("#version: 0.2\n"						)
               for bpe_tokens, token_index in sorted(self.bpe_ranks.items() , key=lambda __UpperCAmelCase						: 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!"						)
                           _A     	=      token_index
                     writer.write(" ".join(_UpperCAmelCase						) + "\n"						)
                     index += 1

         return vocab_file, merge_file

   def 		lowerCAmelCase					(						self					:      Optional[Any] , __UpperCAmelCase					:      Optional[Any] , __UpperCAmelCase					:      List[Any] = None						):





         '''simple docstring'''





         if token_ids_a is None:
               return [self.cls_token_id] + token_ids_a + [self.sep_token_id]
         _A     	=      [self.cls_token_id]
         _A     	=      [self.sep_token_id]
         return cls + token_ids_a + sep + sep + token_ids_a + sep

   def 		lowerCAmelCase					(						self					:      int , __UpperCAmelCase					:      Tuple , __UpperCAmelCase					:      int = None , __UpperCAmelCase					:      Union[str, Any] = False						):





         '''simple docstring'''





         if already_has_special_tokens:
               return super().get_special_tokens_mask(
                   token_ids_a=_UpperCAmelCase , token_ids_a=_UpperCAmelCase , already_has_special_tokens=_UpperCAmelCase						)

         if token_ids_a is None:
               return [1] + ([0] * len(_UpperCAmelCase						)) + [1]
         return [1] + ([0] * len(_UpperCAmelCase						)) + [1, 1] + ([0] * len(_UpperCAmelCase						)) + [1]

   def 		lowerCAmelCase					(						self					:      List[Any] , __UpperCAmelCase					:      int , __UpperCAmelCase					:      Union[str, Any] = None						):





         '''simple docstring'''





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

   def 		lowerCAmelCase					(						self					:      List[str] , __UpperCAmelCase					:      Optional[Any] , __UpperCAmelCase					:      Union[str, Any]=False , **__UpperCAmelCase					:      Dict						):





         '''simple docstring'''





         _A     	=      kwargs.pop("add_prefix_space" , self.add_prefix_space						)
         if (is_split_into_words or add_prefix_space) and (len(_UpperCAmelCase						) > 0 and not text[0].isspace()):
               _A     	=      ' ' + text
         return (text, kwargs)

   def 		lowerCAmelCase					(						self					:      Union[str, Any] , __UpperCAmelCase					:      Dict , __UpperCAmelCase					:      List[str] = None , __UpperCAmelCase					:      List[Any] = PaddingStrategy.DO_NOT_PAD , __UpperCAmelCase					:      Optional[int] = None , __UpperCAmelCase					:      Union[str, Any] = None , ):





         '''simple docstring'''





         _A     	=      super()._pad(
             encoded_inputs=_UpperCAmelCase , max_length=_UpperCAmelCase , padding_strategy=_UpperCAmelCase , pad_to_multiple_of=_UpperCAmelCase , return_attention_mask=_UpperCAmelCase , )

         # Load from model defaults
         if return_attention_mask is None:
               _A     	=      'attention_mask' in self.model_input_names

         if return_attention_mask and "global_attention_mask" in encoded_inputs:
               _A     	=      encoded_inputs[self.model_input_names[0]]
               # `global_attention_mask` need to have the same length as other (sequential) inputs.
               _A     	=      len(encoded_inputs["global_attention_mask"]						) != len(_UpperCAmelCase						)

               if needs_to_be_padded:
                     _A     	=      len(_UpperCAmelCase						) - len(encoded_inputs["global_attention_mask"]						)

                     if self.padding_side == "right":
                           # Use `-1` since `0` in `global_attention_mask` means `local attention` instead of `not to attend`
                           _A     	=      (
                               encoded_inputs['global_attention_mask'] + [-1] * difference
                           )
                     elif self.padding_side == "left":
                           _A     	=      [-1] * difference + encoded_inputs[
                               'global_attention_mask'
                           ]
                     else:
                           raise ValueError("Invalid padding strategy:" + str(self.padding_side						)						)

         return encoded_inputs












'''simple docstring'''




def 			_lowerCAmelCase     (    __snake_case    :					int     )	->	bool:
     return sum(i for i in range(1					,				number // 2 + 1     ) if number % i == 0     ) == number


if __name__ == "__main__":
  print('''Program to check whether a number is a Perfect number or not...''')
  lowercase__       : int         =       int(input('''Enter number: ''').strip())
  print(f"""{number} is {"" if perfect(number) else "not "}a Perfect Number.""")