code: 
  
  import random
  import unittest
  
  import numpy as np
  
  from transformers.testing_utils import require_torch, require_vision
  from transformers.utils import is_torch_available, is_vision_available
  
  from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs
  
  
  if is_torch_available():
         import torch
  
  if is_vision_available():
         import PIL
  
         from transformers import FlavaImageProcessor
         from transformers.image_utils import PILImageResampling
         from transformers.models.flava.image_processing_flava import (
             FLAVA_CODEBOOK_MEAN,
             FLAVA_CODEBOOK_STD,
             FLAVA_IMAGE_MEAN,
             FLAVA_IMAGE_STD,
         )
  else:
         snake_case_    						=				snake_case_    						=				snake_case_    						=				snake_case_    						=				None
  
  
  class    SCREAMING_SNAKE_CASE__      (unittest.TestCase  ):
  
      '''simple docstring'''
  
  
  
  
  
      def __init__(   self		,     a		,     a=7		,     a=3		,     a=30		,     a=400		,     a=True		,     a=None		,     a=True		,     a=None		,     a=None		,     a=True		,     a=1 / 255		,     a=True		,     a=FLAVA_IMAGE_MEAN		,     a=FLAVA_IMAGE_STD		,     a=14		,     a=75		,     a=None		,     a=16		,     a=0.3		,     a=None		,     a=True		,     a=None		,     a=None		,     a=True		,     a=None		,     a=True		,     a=True		,     a=FLAVA_CODEBOOK_MEAN		,     a=FLAVA_CODEBOOK_STD		,     ):
           lowercase__					:     List[str]   = size if size is not None else {'height': 224, 'width': 224}
           lowercase__					:     Any   = crop_size if crop_size is not None else {'height': 224, 'width': 224}
           lowercase__					:     Any   = codebook_size if codebook_size is not None else {'height': 112, 'width': 112}
           lowercase__					:     Optional[Any]   = codebook_crop_size if codebook_crop_size is not None else {'height': 112, 'width': 112}
  
           lowercase__					:     List[str]   = parent
           lowercase__					:     List[str]   = batch_size
           lowercase__					:     int   = num_channels
           lowercase__					:     Optional[Any]   = do_resize
           lowercase__					:     Tuple   = do_rescale
           lowercase__					:     Any   = rescale_factor
           lowercase__					:     int   = min_resolution
           lowercase__					:     str   = max_resolution
           lowercase__					:     List[Any]   = size
           lowercase__					:     str   = resample if resample is not None else PILImageResampling.BICUBIC
           lowercase__					:     List[Any]   = do_normalize
           lowercase__					:     List[Any]   = image_mean
           lowercase__					:     List[Any]   = image_std
           lowercase__					:     List[Any]   = do_center_crop
           lowercase__					:     Union[str, Any]   = crop_size
  
           lowercase__					:     Optional[int]   = input_size_patches
           lowercase__					:     Optional[Any]   = total_mask_patches
           lowercase__					:     List[str]   = mask_group_max_patches
           lowercase__					:     int   = mask_group_min_patches
           lowercase__					:     int   = mask_group_min_aspect_ratio
           lowercase__					:     Any   = mask_group_max_aspect_ratio
  
           lowercase__					:     List[Any]   = codebook_do_resize
           lowercase__					:     Any   = codebook_size
           lowercase__					:     List[str]   = codebook_resample if codebook_resample is not None else PILImageResampling.LANCZOS
           lowercase__					:     List[Any]   = codebook_do_center_crop
           lowercase__					:     List[str]   = codebook_crop_size
           lowercase__					:     Optional[Any]   = codebook_do_map_pixels
           lowercase__					:     Union[str, Any]   = codebook_do_normalize
           lowercase__					:     Dict   = codebook_image_mean
           lowercase__					:     Union[str, Any]   = codebook_image_std
  
  
  
  
  
      def    snake_case_       (   self):
           return {
               "image_mean": self.image_mean,
               "image_std": self.image_std,
               "do_normalize": self.do_normalize,
               "do_resize": self.do_resize,
               "size": self.size,
               "resample": self.resample,
               "do_rescale": self.do_rescale,
               "rescale_factor": self.rescale_factor,
               "do_center_crop": self.do_center_crop,
               "crop_size": self.crop_size,
               "input_size_patches": self.input_size_patches,
               "total_mask_patches": self.total_mask_patches,
               "mask_group_max_patches": self.mask_group_max_patches,
               "mask_group_min_patches": self.mask_group_min_patches,
               "mask_group_min_aspect_ratio": self.mask_group_min_aspect_ratio,
               "mask_group_max_aspect_ratio": self.mask_group_min_aspect_ratio,
               "codebook_do_resize": self.codebook_do_resize,
               "codebook_size": self.codebook_size,
               "codebook_resample": self.codebook_resample,
               "codebook_do_center_crop": self.codebook_do_center_crop,
               "codebook_crop_size": self.codebook_crop_size,
               "codebook_do_map_pixels": self.codebook_do_map_pixels,
               "codebook_do_normalize": self.codebook_do_normalize,
               "codebook_image_mean": self.codebook_image_mean,
               "codebook_image_std": self.codebook_image_std,
           }
  
  
  
  
  
      def    snake_case_       (   self):
           return (self.size["height"], self.size["width"])
  
  
  
  
  
      def    snake_case_       (   self):
           return (
               (self.input_size_patches, self.input_size_patches)
               if not isinstance(self.input_size_patches		,     a)
               else self.input_size_patches
           )
  
  
  
  
  
      def    snake_case_       (   self):
           return (self.codebook_size["height"], self.codebook_size["width"])
  
  
  
  @require_torch
  @require_vision
  class    SCREAMING_SNAKE_CASE__      (__snake_case	, unittest.TestCase  ):
  
      '''simple docstring'''
  
  
  
  
  
      __lowerCamelCase		: Optional[Any]														=  FlavaImageProcessor if is_vision_available() else None
      __lowerCamelCase		: str														=  None
  
  
  
  
  
      def    snake_case_       (   self):
           lowercase__					:     Optional[int]   = FlavaImageProcessingTester(self)
  
  
  
  
  
      @property
      def    snake_case_       (   self):
           return self.image_processor_tester.prepare_image_processor_dict()
  
  
  
  
  
      def    snake_case_       (   self):
           lowercase__					:     str   = self.image_processing_class(**self.image_processor_dict)
           self.assertTrue(hasattr(a		,     'image_mean'))
           self.assertTrue(hasattr(a		,     'image_std'))
           self.assertTrue(hasattr(a		,     'do_normalize'))
           self.assertTrue(hasattr(a		,     'do_resize'))
           self.assertTrue(hasattr(a		,     'resample'))
           self.assertTrue(hasattr(a		,     'crop_size'))
           self.assertTrue(hasattr(a		,     'do_center_crop'))
           self.assertTrue(hasattr(a		,     'do_rescale'))
           self.assertTrue(hasattr(a		,     'rescale_factor'))
           self.assertTrue(hasattr(a		,     'masking_generator'))
           self.assertTrue(hasattr(a		,     'codebook_do_resize'))
           self.assertTrue(hasattr(a		,     'codebook_size'))
           self.assertTrue(hasattr(a		,     'codebook_resample'))
           self.assertTrue(hasattr(a		,     'codebook_do_center_crop'))
           self.assertTrue(hasattr(a		,     'codebook_crop_size'))
           self.assertTrue(hasattr(a		,     'codebook_do_map_pixels'))
           self.assertTrue(hasattr(a		,     'codebook_do_normalize'))
           self.assertTrue(hasattr(a		,     'codebook_image_mean'))
           self.assertTrue(hasattr(a		,     'codebook_image_std'))
  
  
  
  
  
      def    snake_case_       (   self):
           lowercase__					:     Dict   = self.image_processing_class.from_dict(self.image_processor_dict)
           self.assertEqual(image_processor.size		,     {'height': 224, 'width': 224})
           self.assertEqual(image_processor.crop_size		,     {'height': 224, 'width': 224})
           self.assertEqual(image_processor.codebook_size		,     {'height': 112, 'width': 112})
           self.assertEqual(image_processor.codebook_crop_size		,     {'height': 112, 'width': 112})
  
           lowercase__					:     Optional[int]   = self.image_processing_class.from_dict(
               self.image_processor_dict		,     size=42		,     crop_size=84		,     codebook_size=33		,     codebook_crop_size=66)
           self.assertEqual(image_processor.size		,     {'height': 42, 'width': 42})
           self.assertEqual(image_processor.crop_size		,     {'height': 84, 'width': 84})
           self.assertEqual(image_processor.codebook_size		,     {'height': 33, 'width': 33})
           self.assertEqual(image_processor.codebook_crop_size		,     {'height': 66, 'width': 66})
  
  
  
  
  
      def    snake_case_       (   self):
           pass
  
  
  
  
  
      def    snake_case_       (   self):
           # Initialize image_processing
           lowercase__					:     Optional[int]   = self.image_processing_class(**self.image_processor_dict)
           # create random PIL images
           lowercase__					:     Optional[Any]   = prepare_image_inputs(self.image_processor_tester		,     equal_resolution=a)
           for image in image_inputs:
                self.assertIsInstance(a		,     PIL.Image.Image)
  
           # Test not batched input
           lowercase__					:     Optional[Any]   = image_processing(image_inputs[0]		,     return_tensors='pt')
  
           # Test no bool masked pos
           self.assertFalse('bool_masked_pos' in encoded_images)
  
           lowercase__					:     List[str]   = self.image_processor_tester.get_expected_image_size()
  
           self.assertEqual(
               encoded_images.pixel_values.shape		,     (1, self.image_processor_tester.num_channels, expected_height, expected_width)		,     )
  
           # Test batched
           lowercase__					:     Optional[Any]   = image_processing(a		,     return_tensors='pt')
           lowercase__					:     List[Any]   = self.image_processor_tester.get_expected_image_size()
  
           # Test no bool masked pos
           self.assertFalse('bool_masked_pos' in encoded_images)
  
           self.assertEqual(
               encoded_images.pixel_values.shape		,     (
                   self.image_processor_tester.batch_size,
                   self.image_processor_tester.num_channels,
                   expected_height,
                   expected_width,
               )		,     )
  
  
  
  
  
      def    snake_case_       (   self		,     a		,     a):
           # Initialize image_processing
           lowercase__					:     Union[str, Any]   = self.image_processing_class(**self.image_processor_dict)
           # create random tensors
           lowercase__					:     Union[str, Any]   = prepare_image_inputs(self.image_processor_tester		,     equal_resolution=a		,     **a)
           for image in image_inputs:
                self.assertIsInstance(a		,     a)
  
           # Test not batched input
           lowercase__					:     List[str]   = image_processing(image_inputs[0]		,     return_tensors='pt')
  
           lowercase__					:     Optional[int]   = self.image_processor_tester.get_expected_image_size()
           self.assertEqual(
               encoded_images.pixel_values.shape		,     (1, self.image_processor_tester.num_channels, expected_height, expected_width)		,     )
  
           lowercase__					:     Tuple   = image_processing(a		,     return_image_mask=a		,     return_tensors='pt')
  
           lowercase__					:     Optional[int]   = self.image_processor_tester.get_expected_image_size()
           self.assertEqual(
               encoded_images.pixel_values.shape		,     (
                   self.image_processor_tester.batch_size,
                   self.image_processor_tester.num_channels,
                   expected_height,
                   expected_width,
               )		,     )
  
           lowercase__					:     Optional[Any]   = self.image_processor_tester.get_expected_mask_size()
           self.assertEqual(
               encoded_images.bool_masked_pos.shape		,     (
                   self.image_processor_tester.batch_size,
                   expected_height,
                   expected_width,
               )		,     )
  
           # Test batched
           lowercase__					:     str   = image_processing(a		,     return_tensors='pt').pixel_values
  
           lowercase__					:     List[Any]   = self.image_processor_tester.get_expected_image_size()
           self.assertEqual(
               encoded_images.shape		,     (
                   self.image_processor_tester.batch_size,
                   self.image_processor_tester.num_channels,
                   expected_height,
                   expected_width,
               )		,     )
  
           # Test masking
           lowercase__					:     str   = image_processing(a		,     return_image_mask=a		,     return_tensors='pt')
  
           lowercase__					:     str   = self.image_processor_tester.get_expected_image_size()
           self.assertEqual(
               encoded_images.pixel_values.shape		,     (
                   self.image_processor_tester.batch_size,
                   self.image_processor_tester.num_channels,
                   expected_height,
                   expected_width,
               )		,     )
  
           lowercase__					:     str   = self.image_processor_tester.get_expected_mask_size()
           self.assertEqual(
               encoded_images.bool_masked_pos.shape		,     (
                   self.image_processor_tester.batch_size,
                   expected_height,
                   expected_width,
               )		,     )
  
  
  
  
  
      def    snake_case_       (   self):
           self._test_call_framework(np.ndarray		,     prepare_kwargs={'numpify': True})
  
  
  
  
  
      def    snake_case_       (   self):
           self._test_call_framework(torch.Tensor		,     prepare_kwargs={'torchify': True})
  
  
  
  
  
      def    snake_case_       (   self):
           # Initialize image_processing
           random.seed(1234)
           lowercase__					:     Union[str, Any]   = self.image_processing_class(**self.image_processor_dict)
           lowercase__					:     str   = prepare_image_inputs(self.image_processor_tester		,     equal_resolution=a		,     torchify=a)
  
           # Test not batched input
           lowercase__					:     int   = image_processing(image_inputs[0]		,     return_image_mask=a		,     return_tensors='pt')
           self.assertEqual(encoded_images.bool_masked_pos.sum().item()		,     75)
  
  
  
  
  
      def    snake_case_       (   self):
           # Initialize image_processing
           lowercase__					:     List[str]   = self.image_processing_class(**self.image_processor_dict)
           # create random PIL images
           lowercase__					:     str   = prepare_image_inputs(self.image_processor_tester		,     equal_resolution=a)
           for image in image_inputs:
                self.assertIsInstance(a		,     PIL.Image.Image)
  
           # Test not batched input
           lowercase__					:     Union[str, Any]   = image_processing(image_inputs[0]		,     return_codebook_pixels=a		,     return_tensors='pt')
           lowercase__					:     Tuple   = self.image_processor_tester.get_expected_codebook_image_size()
           self.assertEqual(
               encoded_images.codebook_pixel_values.shape		,     (1, self.image_processor_tester.num_channels, expected_height, expected_width)		,     )
  
           # Test batched
           lowercase__					:     int   = image_processing(a		,     return_codebook_pixels=a		,     return_tensors='pt')
           lowercase__					:     int   = self.image_processor_tester.get_expected_codebook_image_size()
           self.assertEqual(
               encoded_images.codebook_pixel_values.shape		,     (
                   self.image_processor_tester.batch_size,
                   self.image_processor_tester.num_channels,
                   expected_height,
                   expected_width,
               )		,     )
  
  
style_context: 
  
  from cva import destroyAllWindows, imread, imshow, waitKey
  
  def 			snake_case__    (					SCREAMING_SNAKE_CASE_	:					int			,  SCREAMING_SNAKE_CASE_	:					int    ):
  
  
  
       '''simple docstring'''
  
  
  
  
  
       lowercase__   ,				lowercase__					:     Optional[int]   = img.shape[0], img.shape[1]
  
       def to_grayscale(SCREAMING_SNAKE_CASE_	:					Union[str, Any]			,  SCREAMING_SNAKE_CASE_	:					List[Any]			,  SCREAMING_SNAKE_CASE_	:					Union[str, Any]    ):
            return 0.2126 * red + 0.587 * green + 0.114 * blue
  
       def normalize(SCREAMING_SNAKE_CASE_	:					int    ):
            return min(SCREAMING_SNAKE_CASE_			,  255    )
  
       for i in range(SCREAMING_SNAKE_CASE_    ):
            for j in range(SCREAMING_SNAKE_CASE_    ):
                 lowercase__					:     str   = int(to_grayscale(*img[i][j]    )    )
                 lowercase__					:     Dict   = [
                     normalize(SCREAMING_SNAKE_CASE_    ),
                     normalize(greyscale + factor    ),
                     normalize(greyscale + 2 * factor    ),
                 ]
  
       return img
  
  
  if __name__ == "__main__":
         # read original image
         snake_case_    						=				{
             percentage: imread('''image_data/lena.jpg''', 1) for percentage in (10, 20, 30, 40)
         }
  
         for percentage, img in images.items():
                make_sepia(img, percentage)
  
         for percentage, img in images.items():
                imshow(F'''Original image with sepia (factor: {percentage})''', img)
  
         waitKey(0)
         destroyAllWindows()
  
  