code: 
  
  
  
  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 ):
  
        '''simple docstring'''
  
  
  
  
        def  _A			(					self	):
  
  
  
  
  
  
  
               '''simple docstring'''
  
               __SCREAMING_SNAKE_CASE								=      tempfile.mkdtemp()
  
               # fmt: off
               __SCREAMING_SNAKE_CASE								=      ["[UNK]", "[CLS]", "[SEP]", "[PAD]", "[MASK]", "want", "##want", "##ed", "wa", "un", "runn", "##ing", ",", "low", "lowest"]
               # fmt: on
               __SCREAMING_SNAKE_CASE								=      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]	)	)
  
               __SCREAMING_SNAKE_CASE								=      {
                   "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,
               }
  
               __SCREAMING_SNAKE_CASE								=      os.path.join(self.tmpdirname   ,							lowerCamelCase__	)
               with open(self.image_processor_file   ,							'w'   ,							encoding='utf-8'	) as fp:
                      json.dump(lowerCamelCase__   ,							lowerCamelCase__	)
  
  
  
  
  
  
        def  _A			(					self   ,							**_A	):
  
  
  
  
  
  
  
               '''simple docstring'''
  
               return BertTokenizer.from_pretrained(self.tmpdirname   ,							**lowerCamelCase__	)
  
  
  
  
  
  
        def  _A			(					self   ,							**_A	):
  
  
  
  
  
  
  
               '''simple docstring'''
  
               return BertTokenizerFast.from_pretrained(self.tmpdirname   ,							**lowerCamelCase__	)
  
  
  
  
  
  
        def  _A			(					self   ,							**_A	):
  
  
  
  
  
  
  
               '''simple docstring'''
  
               return FlavaImageProcessor.from_pretrained(self.tmpdirname   ,							**lowerCamelCase__	)
  
  
  
  
  
  
        def  _A			(					self	):
  
  
  
  
  
  
  
               '''simple docstring'''
  
               shutil.rmtree(self.tmpdirname	)
  
  
  
  
  
  
        def  _A			(					self	):
  
  
  
  
  
  
  
               '''simple docstring'''
  
               __SCREAMING_SNAKE_CASE								=      [np.random.randint(255   ,							size=(3, 30, 400)   ,							dtype=np.uinta	)]
  
               __SCREAMING_SNAKE_CASE								=      [Image.fromarray(np.moveaxis(lowerCamelCase__   ,							0   ,							-1	)	) for x in image_inputs]
  
               return image_inputs
  
  
  
  
  
  
        def  _A			(					self	):
  
  
  
  
  
  
  
               '''simple docstring'''
  
               __SCREAMING_SNAKE_CASE								=      self.get_tokenizer()
               __SCREAMING_SNAKE_CASE								=      self.get_rust_tokenizer()
               __SCREAMING_SNAKE_CASE								=      self.get_image_processor()
  
               __SCREAMING_SNAKE_CASE								=      FlavaProcessor(tokenizer=lowerCamelCase__   ,							image_processor=lowerCamelCase__	)
               processor_slow.save_pretrained(self.tmpdirname	)
               __SCREAMING_SNAKE_CASE								=      FlavaProcessor.from_pretrained(self.tmpdirname   ,							use_fast=lowerCamelCase__	)
  
               __SCREAMING_SNAKE_CASE								=      FlavaProcessor(tokenizer=lowerCamelCase__   ,							image_processor=lowerCamelCase__	)
               processor_fast.save_pretrained(self.tmpdirname	)
               __SCREAMING_SNAKE_CASE								=      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  _A			(					self	):
  
  
  
  
  
  
  
               '''simple docstring'''
  
               __SCREAMING_SNAKE_CASE								=      FlavaProcessor(tokenizer=self.get_tokenizer()   ,							image_processor=self.get_image_processor()	)
               processor.save_pretrained(self.tmpdirname	)
  
               __SCREAMING_SNAKE_CASE								=      self.get_tokenizer(bos_token='(BOS)'   ,							eos_token='(EOS)'	)
               __SCREAMING_SNAKE_CASE								=      self.get_image_processor(do_normalize=lowerCamelCase__   ,							padding_value=1.0	)
  
               __SCREAMING_SNAKE_CASE								=      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  _A			(					self	):
  
  
  
  
  
  
  
               '''simple docstring'''
  
               __SCREAMING_SNAKE_CASE								=      self.get_image_processor()
               __SCREAMING_SNAKE_CASE								=      self.get_tokenizer()
  
               __SCREAMING_SNAKE_CASE								=      FlavaProcessor(tokenizer=lowerCamelCase__   ,							image_processor=lowerCamelCase__	)
  
               __SCREAMING_SNAKE_CASE								=      self.prepare_image_inputs()
  
               __SCREAMING_SNAKE_CASE								=      image_processor(lowerCamelCase__   ,							return_tensors='np'	)
               __SCREAMING_SNAKE_CASE								=      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(1_234	)
               __SCREAMING_SNAKE_CASE								=      image_processor(
                   lowerCamelCase__   ,							return_image_mask=lowerCamelCase__   ,							return_codebook_pixels=lowerCamelCase__   ,							return_tensors='np'	)
               random.seed(1_234	)
               __SCREAMING_SNAKE_CASE								=      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  _A			(					self	):
  
  
  
  
  
  
  
               '''simple docstring'''
  
               __SCREAMING_SNAKE_CASE								=      self.get_image_processor()
               __SCREAMING_SNAKE_CASE								=      self.get_tokenizer()
  
               __SCREAMING_SNAKE_CASE								=      FlavaProcessor(tokenizer=lowerCamelCase__   ,							image_processor=lowerCamelCase__	)
  
               __SCREAMING_SNAKE_CASE								=      "lower newer"
  
               __SCREAMING_SNAKE_CASE								=      processor(text=lowerCamelCase__	)
  
               __SCREAMING_SNAKE_CASE								=      tokenizer(lowerCamelCase__	)
  
               for key in encoded_tok.keys():
                      self.assertListEqual(encoded_tok[key]   ,							encoded_processor[key]	)
  
  
  
  
  
  
        def  _A			(					self	):
  
  
  
  
  
  
  
               '''simple docstring'''
  
               __SCREAMING_SNAKE_CASE								=      self.get_image_processor()
               __SCREAMING_SNAKE_CASE								=      self.get_tokenizer()
  
               __SCREAMING_SNAKE_CASE								=      FlavaProcessor(tokenizer=lowerCamelCase__   ,							image_processor=lowerCamelCase__	)
  
               __SCREAMING_SNAKE_CASE								=      "lower newer"
               __SCREAMING_SNAKE_CASE								=      self.prepare_image_inputs()
  
               __SCREAMING_SNAKE_CASE								=      processor(text=lowerCamelCase__   ,							images=lowerCamelCase__	)
  
               self.assertListEqual(list(inputs.keys()	)   ,							['input_ids', 'token_type_ids', 'attention_mask', 'pixel_values']	)
  
               # add extra args
               __SCREAMING_SNAKE_CASE								=      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  _A			(					self	):
  
  
  
  
  
  
  
               '''simple docstring'''
  
               __SCREAMING_SNAKE_CASE								=      self.get_image_processor()
               __SCREAMING_SNAKE_CASE								=      self.get_tokenizer()
  
               __SCREAMING_SNAKE_CASE								=      FlavaProcessor(tokenizer=lowerCamelCase__   ,							image_processor=lowerCamelCase__	)
  
               __SCREAMING_SNAKE_CASE								=      [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]
  
               __SCREAMING_SNAKE_CASE								=      processor.batch_decode(lowerCamelCase__	)
               __SCREAMING_SNAKE_CASE								=      tokenizer.batch_decode(lowerCamelCase__	)
  
               self.assertListEqual(lowerCamelCase__   ,							lowerCamelCase__	)
  
  
  
  
  
  
        def  _A			(					self	):
  
  
  
  
  
  
  
               '''simple docstring'''
  
               __SCREAMING_SNAKE_CASE								=      self.get_image_processor()
               __SCREAMING_SNAKE_CASE								=      self.get_tokenizer()
  
               __SCREAMING_SNAKE_CASE								=      FlavaProcessor(tokenizer=lowerCamelCase__   ,							image_processor=lowerCamelCase__	)
  
               __SCREAMING_SNAKE_CASE								=      "lower newer"
               __SCREAMING_SNAKE_CASE								=      self.prepare_image_inputs()
  
               __SCREAMING_SNAKE_CASE								=      processor(text=lowerCamelCase__   ,							images=lowerCamelCase__	)
  
               self.assertListEqual(list(inputs.keys()	)   ,							processor.model_input_names	)
  
  
  
  
  
  
  
style_context: 
  
  
  
  from __future__ import annotations
  
  from collections.abc import Iterable
  from dataclasses import dataclass
  from typing import Any
  
  class      UpperCAmelCase_						:
  
  						'''simple docstring'''
  
  
  
  
  						UpperCamelCase__    :				List[str]       						=						('''_front''', '''_back''', '''_len''')
  
  						@dataclass
  						class      UpperCAmelCase_						:
  
  												'''simple docstring'''
  
  
  
  
  												UpperCamelCase__    :				Any       						=						None
  												UpperCamelCase__    :				Deque._Node | None       						=						None
  												UpperCamelCase__    :				Deque._Node | None       						=						None
  
  
  
  
  
  
  
  						class      UpperCAmelCase_						:
  
  												'''simple docstring'''
  
  
  
  
  												UpperCamelCase__    :				Optional[int]       						=						('''_cur''',)
  
  
  
  
  
  
  												def __init__(					self   ,							_A	):
  
  
  
  
  
  
  
  																			'''simple docstring'''
  
  																			__SCREAMING_SNAKE_CASE								=      cur
  
  
  
  
  
  
  												def __iter__(					self	):
  
  
  
  
  
  
  
  																			'''simple docstring'''
  
  																			return self
  
  
  
  
  
  
  												def  _A			(					self	):
  
  
  
  
  
  
  
  																			'''simple docstring'''
  
  																			if self._cur is None:
  																										# finished iterating
  																										raise StopIteration
  																			__SCREAMING_SNAKE_CASE								=      self._cur.val
  																			__SCREAMING_SNAKE_CASE								=      self._cur.next_node
  
  																			return val
  
  
  
  
  
  
  
  						def __init__(					self   ,							_A = None	):
  
  
  
  
  
  
  
  													'''simple docstring'''
  
  													__SCREAMING_SNAKE_CASE								=      None
  													__SCREAMING_SNAKE_CASE								=      None
  													__SCREAMING_SNAKE_CASE								=      0
  
  													if iterable is not None:
  																				# append every value to the deque
  																				for val in iterable:
  																											self.append(_A	)
  
  
  
  
  
  
  						def  _A			(					self   ,							_A	):
  
  
  
  
  
  
  
  													'''simple docstring'''
  
  													__SCREAMING_SNAKE_CASE								=      self._Node(_A   ,							_A   ,							_A	)
  													if self.is_empty():
  																				# front = back
  																				__SCREAMING_SNAKE_CASE								=      __SCREAMING_SNAKE_CASE								=      node
  																				__SCREAMING_SNAKE_CASE								=      1
  													else:
  																				# connect nodes
  																				__SCREAMING_SNAKE_CASE								=      node
  																				__SCREAMING_SNAKE_CASE								=      self._back
  																				__SCREAMING_SNAKE_CASE								=      node  # assign new back to the new node
  
  																				self._len += 1
  
  																				# make sure there were no errors
  																				assert not self.is_empty(), "Error on appending value."
  
  
  
  
  
  
  						def  _A			(					self   ,							_A	):
  
  
  
  
  
  
  
  													'''simple docstring'''
  
  													__SCREAMING_SNAKE_CASE								=      self._Node(_A   ,							_A   ,							_A	)
  													if self.is_empty():
  																				# front = back
  																				__SCREAMING_SNAKE_CASE								=      __SCREAMING_SNAKE_CASE								=      node
  																				__SCREAMING_SNAKE_CASE								=      1
  													else:
  																				# connect nodes
  																				__SCREAMING_SNAKE_CASE								=      self._front
  																				__SCREAMING_SNAKE_CASE								=      node
  																				__SCREAMING_SNAKE_CASE								=      node  # assign new front to the new node
  
  																				self._len += 1
  
  																				# make sure there were no errors
  																				assert not self.is_empty(), "Error on appending value."
  
  
  
  
  
  
  						def  _A			(					self   ,							_A	):
  
  
  
  
  
  
  
  													'''simple docstring'''
  
  													for val in iterable:
  																				self.append(_A	)
  
  
  
  
  
  
  						def  _A			(					self   ,							_A	):
  
  
  
  
  
  
  
  													'''simple docstring'''
  
  													for val in iterable:
  																				self.appendleft(_A	)
  
  
  
  
  
  
  						def  _A			(					self	):
  
  
  
  
  
  
  
  													'''simple docstring'''
  
  													assert not self.is_empty(), "Deque is empty."
  
  													__SCREAMING_SNAKE_CASE								=      self._back
  													__SCREAMING_SNAKE_CASE								=      self._back.prev_node  # set new back
  													# drop the last node - python will deallocate memory automatically
  													__SCREAMING_SNAKE_CASE								=      None
  
  													self._len -= 1
  
  													return topop.val
  
  
  
  
  
  
  						def  _A			(					self	):
  
  
  
  
  
  
  
  													'''simple docstring'''
  
  													assert not self.is_empty(), "Deque is empty."
  
  													__SCREAMING_SNAKE_CASE								=      self._front
  													__SCREAMING_SNAKE_CASE								=      self._front.next_node  # set new front and drop the first node
  													__SCREAMING_SNAKE_CASE								=      None
  
  													self._len -= 1
  
  													return topop.val
  
  
  
  
  
  
  						def  _A			(					self	):
  
  
  
  
  
  
  
  													'''simple docstring'''
  
  													return self._front is None
  
  
  
  
  
  
  						def __len__(					self	):
  
  
  
  
  
  
  
  													'''simple docstring'''
  
  													return self._len
  
  
  
  
  
  
  						def __eq__(					self   ,							_A	):
  
  
  
  
  
  
  
  													'''simple docstring'''
  
  													if not isinstance(_A   ,							_A	):
  																				return NotImplemented
  
  													__SCREAMING_SNAKE_CASE								=      self._front
  													__SCREAMING_SNAKE_CASE								=      other._front
  
  													# if the length of the dequeues are not the same, they are not equal
  													if len(self	) != len(_A	):
  																				return False
  
  													while me is not None and oth is not None:
  																				# compare every value
  																				if me.val != oth.val:
  																											return False
  																				__SCREAMING_SNAKE_CASE								=      me.next_node
  																				__SCREAMING_SNAKE_CASE								=      oth.next_node
  
  													return True
  
  
  
  
  
  
  						def __iter__(					self	):
  
  
  
  
  
  
  
  													'''simple docstring'''
  
  													return Deque._Iterator(self._front	)
  
  
  
  
  
  
  						def __repr__(					self	):
  
  
  
  
  
  
  
  													'''simple docstring'''
  
  													__SCREAMING_SNAKE_CASE								=      []
  													__SCREAMING_SNAKE_CASE								=      self._front
  													while aux is not None:
  																				# append the values in a list to display
  																				values_list.append(aux.val	)
  																				__SCREAMING_SNAKE_CASE								=      aux.next_node
  
  													return f"""[{", ".join(repr(_A	) for val in values_list	)}]"""
  
  
  if __name__ == "__main__":
  			import doctest
  
  			doctest.testmod()
  
  
  
  
  
  
  