


"""simple docstring"""






import shutil
import tempfile
import unittest

import numpy as np
import pytest

from transformers.testing_utils import require_vision
from transformers.utils import is_vision_available


if is_vision_available():
   from PIL import Image

   from transformers import AutoProcessor, BlipaProcessor, BlipImageProcessor, GPTaTokenizer, PreTrainedTokenizerFast


@require_vision
class     __lowerCamelCase  (					unittest.TestCase				):

     '''simple docstring'''


     def 							_UpperCAmelCase      (      self							)       ->							Optional[int]:
          _a    	=				tempfile.mkdtemp()

          _a    	=				BlipImageProcessor()
          _a    	=				GPTaTokenizer.from_pretrained('''hf-internal-testing/tiny-random-GPT2Model'''							)

          _a    	=				BlipaProcessor(__UpperCAmelCase    ,				__UpperCAmelCase							)

          processor.save_pretrained(self.tmpdirname							)


     def 							_UpperCAmelCase      (      self    ,				**__UpperCAmelCase							)       ->							Dict:
          return AutoProcessor.from_pretrained(self.tmpdirname    ,				**__UpperCAmelCase							).tokenizer


     def 							_UpperCAmelCase      (      self    ,				**__UpperCAmelCase							)       ->							Optional[Any]:
          return AutoProcessor.from_pretrained(self.tmpdirname    ,				**__UpperCAmelCase							).image_processor


     def 							_UpperCAmelCase      (      self							)       ->							str:
          shutil.rmtree(self.tmpdirname							)


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

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

          return image_inputs


     def 							_UpperCAmelCase      (      self							)       ->							str:
          _a    	=				BlipaProcessor(tokenizer=self.get_tokenizer()    ,				image_processor=self.get_image_processor()							)
          processor.save_pretrained(self.tmpdirname							)

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

          _a    	=				BlipaProcessor.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    ,				__UpperCAmelCase							)

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


     def 							_UpperCAmelCase      (      self							)       ->							Optional[int]:
          _a    	=				self.get_image_processor()
          _a    	=				self.get_tokenizer()

          _a    	=				BlipaProcessor(tokenizer=__UpperCAmelCase    ,				image_processor=__UpperCAmelCase							)

          _a    	=				self.prepare_image_inputs()

          _a    	=				image_processor(__UpperCAmelCase    ,				return_tensors='''np'''							)
          _a    	=				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							)       ->							List[str]:
          _a    	=				self.get_image_processor()
          _a    	=				self.get_tokenizer()

          _a    	=				BlipaProcessor(tokenizer=__UpperCAmelCase    ,				image_processor=__UpperCAmelCase							)

          _a    	=				'''lower newer'''

          _a    	=				processor(text=__UpperCAmelCase							)

          _a    	=				tokenizer(__UpperCAmelCase    ,				return_token_type_ids=__UpperCAmelCase							)

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


     def 							_UpperCAmelCase      (      self							)       ->							Tuple:
          _a    	=				self.get_image_processor()
          _a    	=				self.get_tokenizer()

          _a    	=				BlipaProcessor(tokenizer=__UpperCAmelCase    ,				image_processor=__UpperCAmelCase							)

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

          _a    	=				processor(text=__UpperCAmelCase    ,				images=__UpperCAmelCase							)

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

          # test if it raises when no input is passed
          with pytest.raises(__UpperCAmelCase							):
               processor()


     def 							_UpperCAmelCase      (      self							)       ->							List[Any]:
          _a    	=				self.get_image_processor()
          _a    	=				self.get_tokenizer()

          _a    	=				BlipaProcessor(tokenizer=__UpperCAmelCase    ,				image_processor=__UpperCAmelCase							)

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

          _a    	=				processor.batch_decode(__UpperCAmelCase							)
          _a    	=				tokenizer.batch_decode(__UpperCAmelCase							)

          self.assertListEqual(__UpperCAmelCase    ,				__UpperCAmelCase							)





     def 							_UpperCAmelCase      (      self							)       ->							List[Any]:
          _a    	=				self.get_image_processor()
          _a    	=				self.get_tokenizer()

          _a    	=				BlipaProcessor(tokenizer=__UpperCAmelCase    ,				image_processor=__UpperCAmelCase							)

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

          _a    	=				processor(text=__UpperCAmelCase    ,				images=__UpperCAmelCase							)

          # For now the processor supports only ['pixel_values', 'input_ids', 'attention_mask']
          self.assertListEqual(list(inputs.keys()							)    ,				['''pixel_values''', '''input_ids''', '''attention_mask''']							)



"""simple docstring"""






def       A_   (   _lowerCAmelCase     :					Dict=2_81_23       ):






     """simple docstring"""

     _a    	=				[1] * (limit + 1)

     for i in range(2,     int(limit**0.5       ) + 1       ):
          sum_divs[i * i] += i
          for k in range(i + 1,     limit // i + 1       ):
               sum_divs[k * i] += k + i

     _a    	=				set()
     _a    	=				0

     for n in range(1,     limit + 1       ):
          if sum_divs[n] > n:
               abundants.add(_lowerCAmelCase       )

          if not any((n - a in abundants) for a in abundants       ):
               res += n

     return res


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