


'''simple docstring'''



def     UpperCAmelCase__      (			UpperCAmelCase_					:       int = 10_00							)  ->	int:
					__lowerCamelCase     :			int              =	0
					__lowerCamelCase     :			List[str]              =	(n - 1) // 3
					total += ((terms) * (6 + (terms - 1) * 3)) // 2  # total of an A.P.
					__lowerCamelCase     :			Dict              =	(n - 1) // 5
					total += ((terms) * (10 + (terms - 1) * 5)) // 2
					__lowerCamelCase     :			Optional[int]              =	(n - 1) // 15
					total -= ((terms) * (30 + (terms - 1) * 15)) // 2
					return total


if __name__ == "__main__":
						print(f'''{solution() = }''')










'''simple docstring'''



import json
import os
import unittest

from transformers import BartTokenizer, BartTokenizerFast, BatchEncoding
from transformers.models.roberta.tokenization_roberta import VOCAB_FILES_NAMES
from transformers.testing_utils import require_tokenizers, require_torch
from transformers.utils import cached_property

from ...test_tokenization_common import TokenizerTesterMixin, filter_roberta_detectors





@require_tokenizers
class      UpperCAmelCase_						(_UpperCAmelCase      ,	unittest.TestCase						):





    """simple docstring"""






    lowerCamelCase						:      Any							  =    BartTokenizer
    lowerCamelCase						:      Optional[Any]							  =    BartTokenizerFast
    lowerCamelCase						:      Tuple							  =    True
    lowerCamelCase						:      Optional[Any]							  =    filter_roberta_detectors







    def    lowercase_       (							self			)       ->  Optional[int]:
         super().setUp()
         __lowerCamelCase     :			List[Any]              =	[
             'l',
             'o',
             'w',
             'e',
             'r',
             's',
             't',
             'i',
             'd',
             'n',
             '\u0120',
             '\u0120l',
             '\u0120n',
             '\u0120lo',
             '\u0120low',
             'er',
             '\u0120lowest',
             '\u0120newer',
             '\u0120wider',
             '<unk>',
         ]
         __lowerCamelCase     :			Optional[Any]              =	dict(zip(SCREAMING_SNAKE_CASE_    ,  range(len(SCREAMING_SNAKE_CASE_			)			)			)			)
         __lowerCamelCase     :			Union[str, Any]              =	['#version: 0.2', '\u0120 l', '\u0120l o', '\u0120lo w', 'e r', '']
         __lowerCamelCase     :			int              =	{'unk_token': '<unk>'}

         __lowerCamelCase     :			int              =	os.path.join(self.tmpdirname    ,  VOCAB_FILES_NAMES['vocab_file']			)
         __lowerCamelCase     :			str              =	os.path.join(self.tmpdirname    ,  VOCAB_FILES_NAMES['merges_file']			)
         with open(self.vocab_file    ,  'w'    ,  encoding='utf-8'			) as fp:
              fp.write(json.dumps(SCREAMING_SNAKE_CASE_			) + '\n'			)
         with open(self.merges_file    ,  'w'    ,  encoding='utf-8'			) as fp:
              fp.write('\n'.join(SCREAMING_SNAKE_CASE_			)			)







    def    lowercase_       (							self    ,  **SCREAMING_SNAKE_CASE_			)       ->  Optional[Any]:
         kwargs.update(self.special_tokens_map			)
         return self.tokenizer_class.from_pretrained(self.tmpdirname    ,  **SCREAMING_SNAKE_CASE_			)







    def    lowercase_       (							self    ,  **SCREAMING_SNAKE_CASE_			)       ->  int:
         kwargs.update(self.special_tokens_map			)
         return self.rust_tokenizer_class.from_pretrained(self.tmpdirname    ,  **SCREAMING_SNAKE_CASE_			)







    def    lowercase_       (							self    ,  SCREAMING_SNAKE_CASE_			)       ->  Tuple:
         return "lower newer", "lower newer"







    @cached_property
    def    lowercase_       (							self			)       ->  str:
         return BartTokenizer.from_pretrained('facebook/bart-large'			)







    @cached_property
    def    lowercase_       (							self			)       ->  Any:
         return BartTokenizerFast.from_pretrained('facebook/bart-large'			)







    @require_torch
    def    lowercase_       (							self			)       ->  List[str]:
         __lowerCamelCase     :			str              =	['A long paragraph for summarization.', 'Another paragraph for summarization.']
         __lowerCamelCase     :			Union[str, Any]              =	[0, 2_50, 2_51, 1_78_18, 13, 3_91_86, 19_38, 4, 2]

         for tokenizer in [self.default_tokenizer, self.default_tokenizer_fast]:
              __lowerCamelCase     :			int              =	tokenizer(SCREAMING_SNAKE_CASE_    ,  max_length=len(SCREAMING_SNAKE_CASE_			)    ,  padding=SCREAMING_SNAKE_CASE_    ,  return_tensors='pt'			)
              self.assertIsInstance(SCREAMING_SNAKE_CASE_    ,  SCREAMING_SNAKE_CASE_			)

              self.assertEqual((2, 9)    ,  batch.input_ids.shape			)
              self.assertEqual((2, 9)    ,  batch.attention_mask.shape			)
              __lowerCamelCase     :			str              =	batch.input_ids.tolist()[0]
              self.assertListEqual(SCREAMING_SNAKE_CASE_    ,  SCREAMING_SNAKE_CASE_			)
              # Test that special tokens are reset







    @require_torch
    def    lowercase_       (							self			)       ->  Dict:
         __lowerCamelCase     :			Optional[int]              =	['A long paragraph for summarization.', 'Another paragraph for summarization.']
         for tokenizer in [self.default_tokenizer, self.default_tokenizer_fast]:
              __lowerCamelCase     :			Tuple              =	tokenizer(SCREAMING_SNAKE_CASE_    ,  padding=SCREAMING_SNAKE_CASE_    ,  return_tensors='pt'			)
              # check if input_ids are returned and no labels
              self.assertIn('input_ids'    ,  SCREAMING_SNAKE_CASE_			)
              self.assertIn('attention_mask'    ,  SCREAMING_SNAKE_CASE_			)
              self.assertNotIn('labels'    ,  SCREAMING_SNAKE_CASE_			)
              self.assertNotIn('decoder_attention_mask'    ,  SCREAMING_SNAKE_CASE_			)







    @require_torch
    def    lowercase_       (							self			)       ->  Dict:
         __lowerCamelCase     :			Any              =	[
             'Summary of the text.',
             'Another summary.',
         ]
         for tokenizer in [self.default_tokenizer, self.default_tokenizer_fast]:
              __lowerCamelCase     :			Union[str, Any]              =	tokenizer(text_target=SCREAMING_SNAKE_CASE_    ,  max_length=32    ,  padding='max_length'    ,  return_tensors='pt'			)
              self.assertEqual(32    ,  targets['input_ids'].shape[1]			)







    @require_torch
    def    lowercase_       (							self			)       ->  Tuple:
         for tokenizer in [self.default_tokenizer, self.default_tokenizer_fast]:
              __lowerCamelCase     :			Optional[Any]              =	tokenizer(
                  ['I am a small frog' * 10_24, 'I am a small frog']    ,  padding=SCREAMING_SNAKE_CASE_    ,  truncation=SCREAMING_SNAKE_CASE_    ,  return_tensors='pt'			)
              self.assertIsInstance(SCREAMING_SNAKE_CASE_    ,  SCREAMING_SNAKE_CASE_			)
              self.assertEqual(batch.input_ids.shape    ,  (2, 10_24)			)







    @require_torch
    def    lowercase_       (							self			)       ->  Optional[Any]:
         __lowerCamelCase     :			Dict              =	['A long paragraph for summarization.']
         __lowerCamelCase     :			str              =	[
             'Summary of the text.',
         ]
         for tokenizer in [self.default_tokenizer, self.default_tokenizer_fast]:
              __lowerCamelCase     :			int              =	tokenizer(SCREAMING_SNAKE_CASE_    ,  return_tensors='pt'			)
              __lowerCamelCase     :			Union[str, Any]              =	tokenizer(text_target=SCREAMING_SNAKE_CASE_    ,  return_tensors='pt'			)
              __lowerCamelCase     :			Optional[Any]              =	inputs['input_ids']
              __lowerCamelCase     :			Dict              =	targets['input_ids']
              self.assertTrue((input_ids[:, 0] == tokenizer.bos_token_id).all().item()			)
              self.assertTrue((labels[:, 0] == tokenizer.bos_token_id).all().item()			)
              self.assertTrue((input_ids[:, -1] == tokenizer.eos_token_id).all().item()			)
              self.assertTrue((labels[:, -1] == tokenizer.eos_token_id).all().item()			)







    def    lowercase_       (							self			)       ->  List[Any]:
         pass







    def    lowercase_       (							self			)       ->  int:
         for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
              with self.subTest(f'{tokenizer.__class__.__name__} ({pretrained_name})'			):
                   __lowerCamelCase     :			List[str]              =	self.rust_tokenizer_class.from_pretrained(SCREAMING_SNAKE_CASE_    ,  **SCREAMING_SNAKE_CASE_			)
                   __lowerCamelCase     :			Optional[int]              =	self.tokenizer_class.from_pretrained(SCREAMING_SNAKE_CASE_    ,  **SCREAMING_SNAKE_CASE_			)
                   __lowerCamelCase     :			Any              =	'A, <mask> AllenNLP sentence.'
                   __lowerCamelCase     :			Tuple              =	tokenizer_r.encode_plus(SCREAMING_SNAKE_CASE_    ,  add_special_tokens=SCREAMING_SNAKE_CASE_    ,  return_token_type_ids=SCREAMING_SNAKE_CASE_			)
                   __lowerCamelCase     :			Union[str, Any]              =	tokenizer_p.encode_plus(SCREAMING_SNAKE_CASE_    ,  add_special_tokens=SCREAMING_SNAKE_CASE_    ,  return_token_type_ids=SCREAMING_SNAKE_CASE_			)

                   # token_type_ids should put 0 everywhere
                   self.assertEqual(sum(tokens_r['token_type_ids']			)    ,  sum(tokens_p['token_type_ids']			)			)

                   # attention_mask should put 1 everywhere, so sum over length should be 1
                   self.assertEqual(
                       sum(tokens_r['attention_mask']			) / len(tokens_r['attention_mask']			)    ,  sum(tokens_p['attention_mask']			) / len(tokens_p['attention_mask']			)    ,  )

                   __lowerCamelCase     :			int              =	tokenizer_r.convert_ids_to_tokens(tokens_r['input_ids']			)
                   __lowerCamelCase     :			Optional[Any]              =	tokenizer_p.convert_ids_to_tokens(tokens_p['input_ids']			)

                   # Rust correctly handles the space before the mask while python doesnt
                   self.assertSequenceEqual(tokens_p['input_ids']    ,  [0, 2_50, 6, 5_02_64, 38_23, 4_87, 2_19_92, 36_45, 4, 2]			)
                   self.assertSequenceEqual(tokens_r['input_ids']    ,  [0, 2_50, 6, 5_02_64, 38_23, 4_87, 2_19_92, 36_45, 4, 2]			)

                   self.assertSequenceEqual(
                       SCREAMING_SNAKE_CASE_    ,  ['<s>', 'A', ',', '<mask>', 'ĠAllen', 'N', 'LP', 'Ġsentence', '.', '</s>']			)
                   self.assertSequenceEqual(
                       SCREAMING_SNAKE_CASE_    ,  ['<s>', 'A', ',', '<mask>', 'ĠAllen', 'N', 'LP', 'Ġsentence', '.', '</s>']			)






