


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

     """simple docstring"""






     def lowerCAmelCase__     (      self		):


          '''simple docstring'''





          __A  :					Optional[int]						     =       tempfile.mkdtemp()

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

          __A  :					Tuple						     =       {
              "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,
          }

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


     def lowerCAmelCase__     (      self ,    **lowerCamelCase		):


          '''simple docstring'''





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


     def lowerCAmelCase__     (      self ,    **lowerCamelCase		):


          '''simple docstring'''





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


     def lowerCAmelCase__     (      self ,    **lowerCamelCase		):


          '''simple docstring'''





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


     def lowerCAmelCase__     (      self		):


          '''simple docstring'''





          shutil.rmtree(self.tmpdirname		)


     def lowerCAmelCase__     (      self		):


          '''simple docstring'''





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

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

          return image_inputs


     def lowerCAmelCase__     (      self		):


          '''simple docstring'''





          __A  :					int						     =       self.get_tokenizer()
          __A  :					Any						     =       self.get_rust_tokenizer()
          __A  :					List[Any]						     =       self.get_image_processor()

          __A  :					Tuple						     =       FlavaProcessor(tokenizer=lowerCamelCase__ ,    image_processor=lowerCamelCase__		)
          processor_slow.save_pretrained(self.tmpdirname		)
          __A  :					Dict						     =       FlavaProcessor.from_pretrained(self.tmpdirname ,    use_fast=lowerCamelCase__		)

          __A  :					Union[str, Any]						     =       FlavaProcessor(tokenizer=lowerCamelCase__ ,    image_processor=lowerCamelCase__		)
          processor_fast.save_pretrained(self.tmpdirname		)
          __A  :					int						     =       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 ,    lowerCamelCase__		)
          self.assertIsInstance(processor_fast.tokenizer ,    lowerCamelCase__		)

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


     def lowerCAmelCase__     (      self		):


          '''simple docstring'''





          __A  :					Any						     =       FlavaProcessor(tokenizer=self.get_tokenizer() ,    image_processor=self.get_image_processor()		)
          processor.save_pretrained(self.tmpdirname		)

          __A  :					Any						     =       self.get_tokenizer(bos_token="(BOS)" ,    eos_token="(EOS)"		)
          __A  :					str						     =       self.get_image_processor(do_normalize=lowerCamelCase__ ,    padding_value=1.0		)

          __A  :					str						     =       FlavaProcessor.from_pretrained(
              self.tmpdirname ,    bos_token="(BOS)" ,    eos_token="(EOS)" ,    do_normalize=lowerCamelCase__ ,    padding_value=1.0		)

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

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


     def lowerCAmelCase__     (      self		):


          '''simple docstring'''





          __A  :					int						     =       self.get_image_processor()
          __A  :					Optional[Any]						     =       self.get_tokenizer()

          __A  :					Optional[Any]						     =       FlavaProcessor(tokenizer=lowerCamelCase__ ,    image_processor=lowerCamelCase__		)

          __A  :					Optional[int]						     =       self.prepare_image_inputs()

          __A  :					Tuple						     =       image_processor(lowerCamelCase__ ,    return_tensors="np"		)
          __A  :					str						     =       processor(images=lowerCamelCase__ ,    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		)
          __A  :					Optional[int]						     =       image_processor(
              lowerCamelCase__ ,    return_image_mask=lowerCamelCase__ ,    return_codebook_pixels=lowerCamelCase__ ,    return_tensors="np"		)
          random.seed(1234		)
          __A  :					Tuple						     =       processor(
              images=lowerCamelCase__ ,    return_image_mask=lowerCamelCase__ ,    return_codebook_pixels=lowerCamelCase__ ,    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 lowerCAmelCase__     (      self		):


          '''simple docstring'''





          __A  :					Dict						     =       self.get_image_processor()
          __A  :					str						     =       self.get_tokenizer()

          __A  :					List[str]						     =       FlavaProcessor(tokenizer=lowerCamelCase__ ,    image_processor=lowerCamelCase__		)

          __A  :					Union[str, Any]						     =       "lower newer"

          __A  :					Optional[Any]						     =       processor(text=lowerCamelCase__		)

          __A  :					Optional[Any]						     =       tokenizer(lowerCamelCase__		)

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


     def lowerCAmelCase__     (      self		):


          '''simple docstring'''





          __A  :					List[Any]						     =       self.get_image_processor()
          __A  :					int						     =       self.get_tokenizer()

          __A  :					str						     =       FlavaProcessor(tokenizer=lowerCamelCase__ ,    image_processor=lowerCamelCase__		)

          __A  :					Any						     =       "lower newer"
          __A  :					Any						     =       self.prepare_image_inputs()

          __A  :					Optional[int]						     =       processor(text=lowerCamelCase__ ,    images=lowerCamelCase__		)

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

          # add extra args
          __A  :					str						     =       processor(text=lowerCamelCase__ ,    images=lowerCamelCase__ ,    return_codebook_pixels=lowerCamelCase__ ,    return_image_mask=lowerCamelCase__		)

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


     def lowerCAmelCase__     (      self		):


          '''simple docstring'''





          __A  :					Optional[Any]						     =       self.get_image_processor()
          __A  :					List[Any]						     =       self.get_tokenizer()

          __A  :					Any						     =       FlavaProcessor(tokenizer=lowerCamelCase__ ,    image_processor=lowerCamelCase__		)

          __A  :					List[Any]						     =       [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

          __A  :					str						     =       processor.batch_decode(lowerCamelCase__		)
          __A  :					Dict						     =       tokenizer.batch_decode(lowerCamelCase__		)

          self.assertListEqual(lowerCamelCase__ ,    lowerCamelCase__		)


     def lowerCAmelCase__     (      self		):


          '''simple docstring'''





          __A  :					List[str]						     =       self.get_image_processor()
          __A  :					Dict						     =       self.get_tokenizer()

          __A  :					Tuple						     =       FlavaProcessor(tokenizer=lowerCamelCase__ ,    image_processor=lowerCamelCase__		)

          __A  :					Optional[Any]						     =       "lower newer"
          __A  :					Dict						     =       self.prepare_image_inputs()

          __A  :					int						     =       processor(text=lowerCamelCase__ ,    images=lowerCamelCase__		)

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





'''simple docstring'''


from collections import defaultdict


def 		_lowercase   (SCREAMING_SNAKE_CASE = 5       ):




     '''simple docstring'''





     __A  :					int						     =       defaultdict(SCREAMING_SNAKE_CASE       )
     __A  :					Optional[Any]						     =       0

     while True:
          __A  :					List[str]						     =       get_digits(SCREAMING_SNAKE_CASE       )
          freqs[digits].append(SCREAMING_SNAKE_CASE       )

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

          num += 1


def 		_lowercase   (SCREAMING_SNAKE_CASE       ):




     '''simple docstring'''





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


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

