





import json
import os
import shutil
import tempfile
import unittest

import numpy as np

from transformers import BertTokenizerFast
from transformers.models.bert.tokenization_bert import VOCAB_FILES_NAMES, BertTokenizer
from transformers.testing_utils import require_tokenizers, require_vision
from transformers.utils import IMAGE_PROCESSOR_NAME, is_vision_available


if is_vision_available():
   from PIL import Image

   from transformers import VisionTextDualEncoderProcessor, ViTImageProcessor




@require_tokenizers
@require_vision
class 			__UpperCamelCase    (							unittest.TestCase    ):





     def 		UpperCamelCase(     self					):
        _UpperCAmelCase           =   tempfile.mkdtemp()

        # fmt: off
        _UpperCAmelCase           =   ['''[UNK]''', '''[CLS]''', '''[SEP]''', '''[PAD]''', '''[MASK]''', '''want''', '''##want''', '''##ed''', '''wa''', '''un''', '''runn''', '''##ing''', ''',''', '''low''', '''lowest''']
        # fmt: on
        _UpperCAmelCase           =   os.path.join(self.tmpdirname				,							VOCAB_FILES_NAMES['''vocab_file''']					)
        with open(self.vocab_file				,							'''w'''				,							encoding='''utf-8'''					) as vocab_writer:
           vocab_writer.write(''''''.join([x + '''\n''' for x in vocab_tokens]					)					)

        _UpperCAmelCase           =   {
            '''do_resize''': True,
            '''size''': {'''height''': 18, '''width''': 18},
            '''do_normalize''': True,
            '''image_mean''': [0.5, 0.5, 0.5],
            '''image_std''': [0.5, 0.5, 0.5],
        }
        _UpperCAmelCase           =   os.path.join(self.tmpdirname				,							_UpperCamelCase					)
        with open(self.image_processor_file				,							'''w'''				,							encoding='''utf-8'''					) as fp:
           json.dump(_UpperCamelCase				,							_UpperCamelCase					)





     def 		UpperCamelCase(     self				,							**_UpperCamelCase					):
        return BertTokenizer.from_pretrained(self.tmpdirname				,							**_UpperCamelCase					)





     def 		UpperCamelCase(     self				,							**_UpperCamelCase					):
        return ViTImageProcessor.from_pretrained(self.tmpdirname				,							**_UpperCamelCase					)





     def 		UpperCamelCase(     self					):
        shutil.rmtree(self.tmpdirname					)





     def 		UpperCamelCase(     self					):
        _UpperCAmelCase           =   [np.random.randint(255				,							size=(3, 30, 400)				,							dtype=np.uinta					)]

        _UpperCAmelCase           =   [Image.fromarray(np.moveaxis(_UpperCamelCase				,							0				,							-1					)					) for x in image_inputs]

        return image_inputs





     def 		UpperCamelCase(     self					):
        _UpperCAmelCase           =   self.get_tokenizer()
        _UpperCAmelCase           =   self.get_image_processor()

        _UpperCAmelCase           =   VisionTextDualEncoderProcessor(tokenizer=_UpperCamelCase				,							image_processor=_UpperCamelCase					)

        processor.save_pretrained(self.tmpdirname					)
        _UpperCAmelCase           =   VisionTextDualEncoderProcessor.from_pretrained(self.tmpdirname					)

        self.assertEqual(processor.tokenizer.get_vocab()				,							tokenizer.get_vocab()					)
        self.assertIsInstance(processor.tokenizer				,							(BertTokenizer, BertTokenizerFast)					)

        self.assertEqual(processor.image_processor.to_json_string()				,							image_processor.to_json_string()					)
        self.assertIsInstance(processor.image_processor				,							_UpperCamelCase					)





     def 		UpperCamelCase(     self					):
        _UpperCAmelCase           =   VisionTextDualEncoderProcessor(
            tokenizer=self.get_tokenizer()				,							image_processor=self.get_image_processor()					)
        processor.save_pretrained(self.tmpdirname					)

        _UpperCAmelCase           =   self.get_tokenizer(bos_token='''(BOS)'''				,							eos_token='''(EOS)'''					)
        _UpperCAmelCase           =   self.get_image_processor(do_normalize=_UpperCamelCase				,							padding_value=1.0					)

        _UpperCAmelCase           =   VisionTextDualEncoderProcessor.from_pretrained(
            self.tmpdirname				,							bos_token='''(BOS)'''				,							eos_token='''(EOS)'''				,							do_normalize=_UpperCamelCase				,							padding_value=1.0					)

        self.assertEqual(processor.tokenizer.get_vocab()				,							tokenizer_add_kwargs.get_vocab()					)
        self.assertIsInstance(processor.tokenizer				,							(BertTokenizer, BertTokenizerFast)					)

        self.assertEqual(processor.image_processor.to_json_string()				,							image_processor_add_kwargs.to_json_string()					)
        self.assertIsInstance(processor.image_processor				,							_UpperCamelCase					)





     def 		UpperCamelCase(     self					):
        _UpperCAmelCase           =   self.get_image_processor()
        _UpperCAmelCase           =   self.get_tokenizer()

        _UpperCAmelCase           =   VisionTextDualEncoderProcessor(tokenizer=_UpperCamelCase				,							image_processor=_UpperCamelCase					)

        _UpperCAmelCase           =   self.prepare_image_inputs()

        _UpperCAmelCase           =   image_processor(_UpperCamelCase				,							return_tensors='''np'''					)
        _UpperCAmelCase           =   processor(images=_UpperCamelCase				,							return_tensors='''np'''					)

        for key in input_feat_extract.keys():
           self.assertAlmostEqual(input_feat_extract[key].sum()				,							input_processor[key].sum()				,							delta=1e-2					)





     def 		UpperCamelCase(     self					):
        _UpperCAmelCase           =   self.get_image_processor()
        _UpperCAmelCase           =   self.get_tokenizer()

        _UpperCAmelCase           =   VisionTextDualEncoderProcessor(tokenizer=_UpperCamelCase				,							image_processor=_UpperCamelCase					)

        _UpperCAmelCase           =   '''lower newer'''

        _UpperCAmelCase           =   processor(text=_UpperCamelCase					)

        _UpperCAmelCase           =   tokenizer(_UpperCamelCase					)

        for key in encoded_tok.keys():
           self.assertListEqual(encoded_tok[key]				,							encoded_processor[key]					)





     def 		UpperCamelCase(     self					):
        _UpperCAmelCase           =   self.get_image_processor()
        _UpperCAmelCase           =   self.get_tokenizer()

        _UpperCAmelCase           =   VisionTextDualEncoderProcessor(tokenizer=_UpperCamelCase				,							image_processor=_UpperCamelCase					)

        _UpperCAmelCase           =   '''lower newer'''
        _UpperCAmelCase           =   self.prepare_image_inputs()

        _UpperCAmelCase           =   processor(text=_UpperCamelCase				,							images=_UpperCamelCase					)

        self.assertListEqual(list(inputs.keys()					)				,							['''input_ids''', '''token_type_ids''', '''attention_mask''', '''pixel_values''']					)

        # test if it raises when no input is passed
        with self.assertRaises(_UpperCamelCase					):
           processor()





     def 		UpperCamelCase(     self					):
        _UpperCAmelCase           =   self.get_image_processor()
        _UpperCAmelCase           =   self.get_tokenizer()

        _UpperCAmelCase           =   VisionTextDualEncoderProcessor(tokenizer=_UpperCamelCase				,							image_processor=_UpperCamelCase					)

        _UpperCAmelCase           =   [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

        _UpperCAmelCase           =   processor.batch_decode(_UpperCamelCase					)
        _UpperCAmelCase           =   tokenizer.batch_decode(_UpperCamelCase					)

        self.assertListEqual(_UpperCamelCase				,							_UpperCamelCase					)





     def 		UpperCamelCase(     self					):
        _UpperCAmelCase           =   self.get_image_processor()
        _UpperCAmelCase           =   self.get_tokenizer()

        _UpperCAmelCase           =   VisionTextDualEncoderProcessor(tokenizer=_UpperCamelCase				,							image_processor=_UpperCamelCase					)

        _UpperCAmelCase           =   '''lower newer'''
        _UpperCAmelCase           =   self.prepare_image_inputs()

        _UpperCAmelCase           =   processor(text=_UpperCamelCase				,							images=_UpperCamelCase					)

        self.assertListEqual(list(inputs.keys()					)				,							processor.model_input_names					)

"""simple docstring"""


import os

# Precomputes a list of the 100 first triangular numbers
_lowercase				 =					[int(0.5 * n * (n + 1)) for n in range(1, 1_01)]






def    _snake_case					(		):
	A     = os.path.dirname(os.path.realpath(snake_case__  )  )
	A     = os.path.join(snake_case__						,   'words.txt'  )

	A     = ''
	with open(snake_case__  ) as f:
		A     = f.readline()

	A     = [word.strip('"'  ) for word in words.strip('\r\n'  ).split(','  )]
	A     = [
	    word
	    for word in [sum(ord(snake_case__  ) - 64 for x in word  ) for word in words]
	    if word in TRIANGULAR_NUMBERS
	]
	return len(snake_case__  )


if __name__ == "__main__":
		print(solution())