
'''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 		snake_case_       (						unittest.TestCase						):



   """simple docstring"""





   def     __UpperCAmelCase      ( self):
          lowerCamelCase__				   =      tempfile.mkdtemp()

          # fmt: off
          lowerCamelCase__				   =      ["[UNK]", "[CLS]", "[SEP]", "[PAD]", "[MASK]", "want", "##want", "##ed", "wa", "un", "runn", "##ing", ",", "low", "lowest"]
          # fmt: on
          lowerCamelCase__				   =      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]))

          lowerCamelCase__				   =      {
              "image_mean": FLAVA_IMAGE_MEAN,
              "image_std": FLAVA_IMAGE_STD,
              "do_normalize": True,
              "do_resize": True,
              "size": 2_24,
              "do_center_crop": True,
              "crop_size": 2_24,
              "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": 1_12,
              "codebook_do_center_crop": True,
              "codebook_crop_size": 1_12,
              "codebook_do_map_pixels": True,
              "codebook_do_normalize": True,
              "codebook_image_mean": FLAVA_CODEBOOK_MEAN,
              "codebook_image_std": FLAVA_CODEBOOK_STD,
          }

          lowerCamelCase__				   =      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 BertTokenizerFast.from_pretrained(self.tmpdirname			,   **UpperCamelCase)







   def     __UpperCAmelCase      ( self			,   **UpperCamelCase):
          return FlavaImageProcessor.from_pretrained(self.tmpdirname			,   **UpperCamelCase)







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







   def     __UpperCAmelCase      ( self):
          lowerCamelCase__				   =      [np.random.randint(2_55			,   size=(3, 30, 4_00)			,   dtype=np.uinta)]

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

          return image_inputs







   def     __UpperCAmelCase      ( self):
          lowerCamelCase__				   =      self.get_tokenizer()
          lowerCamelCase__				   =      self.get_rust_tokenizer()
          lowerCamelCase__				   =      self.get_image_processor()

          lowerCamelCase__				   =      FlavaProcessor(tokenizer=UpperCamelCase			,   image_processor=UpperCamelCase)
          processor_slow.save_pretrained(self.tmpdirname)
          lowerCamelCase__				   =      FlavaProcessor.from_pretrained(self.tmpdirname			,   use_fast=UpperCamelCase)

          lowerCamelCase__				   =      FlavaProcessor(tokenizer=UpperCamelCase			,   image_processor=UpperCamelCase)
          processor_fast.save_pretrained(self.tmpdirname)
          lowerCamelCase__				   =      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			,   UpperCamelCase)
          self.assertIsInstance(processor_fast.tokenizer			,   UpperCamelCase)

          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			,   UpperCamelCase)
          self.assertIsInstance(processor_fast.image_processor			,   UpperCamelCase)







   def     __UpperCAmelCase      ( self):
          lowerCamelCase__				   =      FlavaProcessor(tokenizer=self.get_tokenizer()			,   image_processor=self.get_image_processor())
          processor.save_pretrained(self.tmpdirname)

          lowerCamelCase__				   =      self.get_tokenizer(bos_token="(BOS)"			,   eos_token="(EOS)")
          lowerCamelCase__				   =      self.get_image_processor(do_normalize=UpperCamelCase			,   padding_value=1.0)

          lowerCamelCase__				   =      FlavaProcessor.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):
          lowerCamelCase__				   =      self.get_image_processor()
          lowerCamelCase__				   =      self.get_tokenizer()

          lowerCamelCase__				   =      FlavaProcessor(tokenizer=UpperCamelCase			,   image_processor=UpperCamelCase)

          lowerCamelCase__				   =      self.prepare_image_inputs()

          lowerCamelCase__				   =      image_processor(UpperCamelCase			,   return_tensors="np")
          lowerCamelCase__				   =      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)

          # With rest of the args
          random.seed(12_34)
          lowerCamelCase__				   =      image_processor(
              UpperCamelCase			,   return_image_mask=UpperCamelCase			,   return_codebook_pixels=UpperCamelCase			,   return_tensors="np")
          random.seed(12_34)
          lowerCamelCase__				   =      processor(
              images=UpperCamelCase			,   return_image_mask=UpperCamelCase			,   return_codebook_pixels=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):
          lowerCamelCase__				   =      self.get_image_processor()
          lowerCamelCase__				   =      self.get_tokenizer()

          lowerCamelCase__				   =      FlavaProcessor(tokenizer=UpperCamelCase			,   image_processor=UpperCamelCase)

          lowerCamelCase__				   =      "lower newer"

          lowerCamelCase__				   =      processor(text=UpperCamelCase)

          lowerCamelCase__				   =      tokenizer(UpperCamelCase)

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







   def     __UpperCAmelCase      ( self):
          lowerCamelCase__				   =      self.get_image_processor()
          lowerCamelCase__				   =      self.get_tokenizer()

          lowerCamelCase__				   =      FlavaProcessor(tokenizer=UpperCamelCase			,   image_processor=UpperCamelCase)

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

          lowerCamelCase__				   =      processor(text=UpperCamelCase			,   images=UpperCamelCase)

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

          # add extra args
          lowerCamelCase__				   =      processor(text=UpperCamelCase			,   images=UpperCamelCase			,   return_codebook_pixels=UpperCamelCase			,   return_image_mask=UpperCamelCase)

          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(UpperCamelCase):
                 processor()







   def     __UpperCAmelCase      ( self):
          lowerCamelCase__				   =      self.get_image_processor()
          lowerCamelCase__				   =      self.get_tokenizer()

          lowerCamelCase__				   =      FlavaProcessor(tokenizer=UpperCamelCase			,   image_processor=UpperCamelCase)

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

          lowerCamelCase__				   =      processor.batch_decode(UpperCamelCase)
          lowerCamelCase__				   =      tokenizer.batch_decode(UpperCamelCase)

          self.assertListEqual(UpperCamelCase			,   UpperCamelCase)







   def     __UpperCAmelCase      ( self):
          lowerCamelCase__				   =      self.get_image_processor()
          lowerCamelCase__				   =      self.get_tokenizer()

          lowerCamelCase__				   =      FlavaProcessor(tokenizer=UpperCamelCase			,   image_processor=UpperCamelCase)

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

          lowerCamelCase__				   =      processor(text=UpperCamelCase			,   images=UpperCamelCase)

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



'''simple docstring'''







from collections import defaultdict







def   lowerCAmelCase(  a__    :  int = 5      ):







       '''simple docstring'''






       lowerCamelCase__				   =      defaultdict(a__      )
       lowerCamelCase__				   =      0

       while True:
              lowerCamelCase__				   =      get_digits(a__      )
              freqs[digits].append(a__      )

              if len(freqs[digits]      ) == max_base:
                     lowerCamelCase__				   =      freqs[digits][0] ** 3
                     return base

              num += 1







def   lowerCAmelCase(  a__    :  int      ):







       '''simple docstring'''






       return "".join(sorted(str(num**3      )      )      )


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

