


'''simple docstring'''

import json
import os
import random
import shutil
import tempfile
import unittest

import numpy as np
import pytest

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


if is_vision_available():
       from PIL import Image

       from transformers import FlavaImageProcessor, FlavaProcessor
       from transformers.models.flava.image_processing_flava import (
           FLAVA_CODEBOOK_MEAN,
           FLAVA_CODEBOOK_STD,
           FLAVA_IMAGE_MEAN,
           FLAVA_IMAGE_STD,
       )







@require_vision
class 			UpperCAmelCase			(							unittest.TestCase):

 def 		lowercase_    (			self			:						List[str]       ):





    """simple docstring"""



    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 fp:
       fp.write("".join([x + "\n" for x in vocab_tokens]       )       )

    UpperCamelCase__			    =    {
        "image_mean": FLAVA_IMAGE_MEAN,
        "image_std": FLAVA_IMAGE_STD,
        "do_normalize": True,
        "do_resize": True,
        "size": 224,
        "do_center_crop": True,
        "crop_size": 224,
        "input_size_patches": 14,
        "total_mask_patches": 75,
        "mask_group_max_patches": None,
        "mask_group_min_patches": 16,
        "mask_group_min_aspect_ratio": 0.3,
        "mask_group_max_aspect_ratio": None,
        "codebook_do_resize": True,
        "codebook_size": 112,
        "codebook_do_center_crop": True,
        "codebook_crop_size": 112,
        "codebook_do_map_pixels": True,
        "codebook_do_normalize": True,
        "codebook_image_mean": FLAVA_CODEBOOK_MEAN,
        "codebook_image_std": FLAVA_CODEBOOK_STD,
    }

    UpperCamelCase__			    =    os.path.join(self.tmpdirname,       a_       )
    with open(self.image_processor_file,       "w",       encoding="utf-8"       ) as fp:
       json.dump(a_,       a_       )

 def 		lowercase_    (			self			:						List[str],       **a_			:						int       ):





    """simple docstring"""



    return BertTokenizer.from_pretrained(self.tmpdirname,       **a_       )

 def 		lowercase_    (			self			:						str,       **a_			:						Any       ):





    """simple docstring"""



    return BertTokenizerFast.from_pretrained(self.tmpdirname,       **a_       )

 def 		lowercase_    (			self			:						Dict,       **a_			:						Tuple       ):





    """simple docstring"""



    return FlavaImageProcessor.from_pretrained(self.tmpdirname,       **a_       )

 def 		lowercase_    (			self			:						List[str]       ):





    """simple docstring"""



    shutil.rmtree(self.tmpdirname       )

 def 		lowercase_    (			self			:						Tuple       ):





    """simple docstring"""



    UpperCamelCase__			    =    [np.random.randint(255,       size=(3, 30, 400),       dtype=np.uinta       )]

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

    return image_inputs

 def 		lowercase_    (			self			:						Any       ):





    """simple docstring"""



    UpperCamelCase__			    =    self.get_tokenizer()
    UpperCamelCase__			    =    self.get_rust_tokenizer()
    UpperCamelCase__			    =    self.get_image_processor()

    UpperCamelCase__			    =    FlavaProcessor(tokenizer=a_,       image_processor=a_       )
    processor_slow.save_pretrained(self.tmpdirname       )
    UpperCamelCase__			    =    FlavaProcessor.from_pretrained(self.tmpdirname,       use_fast=a_       )

    UpperCamelCase__			    =    FlavaProcessor(tokenizer=a_,       image_processor=a_       )
    processor_fast.save_pretrained(self.tmpdirname       )
    UpperCamelCase__			    =    FlavaProcessor.from_pretrained(self.tmpdirname       )

    self.assertEqual(processor_slow.tokenizer.get_vocab(),       tokenizer_slow.get_vocab()       )
    self.assertEqual(processor_fast.tokenizer.get_vocab(),       tokenizer_fast.get_vocab()       )
    self.assertEqual(tokenizer_slow.get_vocab(),       tokenizer_fast.get_vocab()       )
    self.assertIsInstance(processor_slow.tokenizer,       a_       )
    self.assertIsInstance(processor_fast.tokenizer,       a_       )

    self.assertEqual(processor_slow.image_processor.to_json_string(),       image_processor.to_json_string()       )
    self.assertEqual(processor_fast.image_processor.to_json_string(),       image_processor.to_json_string()       )
    self.assertIsInstance(processor_slow.image_processor,       a_       )
    self.assertIsInstance(processor_fast.image_processor,       a_       )

 def 		lowercase_    (			self			:						int       ):





    """simple docstring"""



    UpperCamelCase__			    =    FlavaProcessor(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=a_,       padding_value=1.0       )

    UpperCamelCase__			    =    FlavaProcessor.from_pretrained(
        self.tmpdirname,       bos_token="(BOS)",       eos_token="(EOS)",       do_normalize=a_,       padding_value=1.0       )

    self.assertEqual(processor.tokenizer.get_vocab(),       tokenizer_add_kwargs.get_vocab()       )
    self.assertIsInstance(processor.tokenizer,       a_       )

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

 def 		lowercase_    (			self			:						int       ):





    """simple docstring"""



    UpperCamelCase__			    =    self.get_image_processor()
    UpperCamelCase__			    =    self.get_tokenizer()

    UpperCamelCase__			    =    FlavaProcessor(tokenizer=a_,       image_processor=a_       )

    UpperCamelCase__			    =    self.prepare_image_inputs()

    UpperCamelCase__			    =    image_processor(a_,       return_tensors="np"       )
    UpperCamelCase__			    =    processor(images=a_,       return_tensors="np"       )

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

    # With rest of the args
    random.seed(1234       )
    UpperCamelCase__			    =    image_processor(
        a_,       return_image_mask=a_,       return_codebook_pixels=a_,       return_tensors="np"       )
    random.seed(1234       )
    UpperCamelCase__			    =    processor(
        images=a_,       return_image_mask=a_,       return_codebook_pixels=a_,       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 		lowercase_    (			self			:						Any       ):





    """simple docstring"""



    UpperCamelCase__			    =    self.get_image_processor()
    UpperCamelCase__			    =    self.get_tokenizer()

    UpperCamelCase__			    =    FlavaProcessor(tokenizer=a_,       image_processor=a_       )

    UpperCamelCase__			    =    "lower newer"

    UpperCamelCase__			    =    processor(text=a_       )

    UpperCamelCase__			    =    tokenizer(a_       )

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

 def 		lowercase_    (			self			:						Optional[int]       ):





    """simple docstring"""



    UpperCamelCase__			    =    self.get_image_processor()
    UpperCamelCase__			    =    self.get_tokenizer()

    UpperCamelCase__			    =    FlavaProcessor(tokenizer=a_,       image_processor=a_       )

    UpperCamelCase__			    =    "lower newer"
    UpperCamelCase__			    =    self.prepare_image_inputs()

    UpperCamelCase__			    =    processor(text=a_,       images=a_       )

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

    # add extra args
    UpperCamelCase__			    =    processor(text=a_,       images=a_,       return_codebook_pixels=a_,       return_image_mask=a_       )

    self.assertListEqual(
        list(inputs.keys()       ),       [
            "input_ids",
            "token_type_ids",
            "attention_mask",
            "pixel_values",
            "codebook_pixel_values",
            "bool_masked_pos",
        ],       )

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

 def 		lowercase_    (			self			:						Tuple       ):





    """simple docstring"""



    UpperCamelCase__			    =    self.get_image_processor()
    UpperCamelCase__			    =    self.get_tokenizer()

    UpperCamelCase__			    =    FlavaProcessor(tokenizer=a_,       image_processor=a_       )

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

    UpperCamelCase__			    =    processor.batch_decode(a_       )
    UpperCamelCase__			    =    tokenizer.batch_decode(a_       )

    self.assertListEqual(a_,       a_       )

 def 		lowercase_    (			self			:						Optional[int]       ):





    """simple docstring"""



    UpperCamelCase__			    =    self.get_image_processor()
    UpperCamelCase__			    =    self.get_tokenizer()

    UpperCamelCase__			    =    FlavaProcessor(tokenizer=a_,       image_processor=a_       )

    UpperCamelCase__			    =    "lower newer"
    UpperCamelCase__			    =    self.prepare_image_inputs()

    UpperCamelCase__			    =    processor(text=a_,       images=a_       )

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




import math





def 				A      (	_UpperCAmelCase							:  int       )							->					int:







			'''simple docstring'''
			return sum(int(_UpperCAmelCase       ) for digit in str(_UpperCAmelCase       )       )





def 				A      (	_UpperCAmelCase							:  int = 30       )							->					int:







			'''simple docstring'''
			_UpperCAmelCase									=  []
			for digit in range(2				,  100       ):
						for power in range(2				,  100       ):
									_UpperCAmelCase									=  int(math.pow(_UpperCAmelCase				,  _UpperCAmelCase       )       )
									if digit == digit_sum(_UpperCAmelCase       ):
												digit_to_powers.append(_UpperCAmelCase       )

			digit_to_powers.sort()
			return digit_to_powers[n - 1]


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