






"""simple docstring"""



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:
						A_     =				A_     =				A_     =				A_     =				None






class 				__SCREAMING_SNAKE_CASE    (					unittest.TestCase		):


							def __init__(      self   :    List[str]      ,     snake_case   :    Union[str, Any]      ,     snake_case   :    Optional[int]=7      ,     snake_case   :    Dict=3      ,     snake_case   :    str=30      ,     snake_case   :    Optional[Any]=400      ,     snake_case   :    str=True      ,     snake_case   :    Dict=None      ,     snake_case   :    Optional[Any]=True      ,     snake_case   :    Dict=None      ,     snake_case   :    str=None      ,     snake_case   :    Optional[Any]=True      ,     snake_case   :    List[Any]=1 / 255      ,     snake_case   :    str=True      ,     snake_case   :    Tuple=FLAVA_IMAGE_MEAN      ,     snake_case   :    Any=FLAVA_IMAGE_STD      ,     snake_case   :    List[str]=14      ,     snake_case   :    str=75      ,     snake_case   :    str=None      ,     snake_case   :    Union[str, Any]=16      ,     snake_case   :    Optional[Any]=0.3      ,     snake_case   :    Dict=None      ,     snake_case   :    List[str]=True      ,     snake_case   :    Dict=None      ,     snake_case   :    int=None      ,     snake_case   :    List[str]=True      ,     snake_case   :    str=None      ,     snake_case   :    Optional[Any]=True      ,     snake_case   :    Tuple=True      ,     snake_case   :    Optional[int]=FLAVA_CODEBOOK_MEAN      ,     snake_case   :    str=FLAVA_CODEBOOK_STD      ,     ):
													'''simple docstring'''





													A__    :	Any			=	size if size is not None else {"""height""": 224, """width""": 224}
													A__    :	str			=	crop_size if crop_size is not None else {"""height""": 224, """width""": 224}
													A__    :	Optional[Any]			=	codebook_size if codebook_size is not None else {"""height""": 112, """width""": 112}
													A__    :	Tuple			=	codebook_crop_size if codebook_crop_size is not None else {"""height""": 112, """width""": 112}

													A__    :	Optional[Any]			=	parent
													A__    :	Tuple			=	batch_size
													A__    :	List[Any]			=	num_channels
													A__    :	int			=	do_resize
													A__    :	List[Any]			=	do_rescale
													A__    :	List[Any]			=	rescale_factor
													A__    :	List[str]			=	min_resolution
													A__    :	List[str]			=	max_resolution
													A__    :	List[Any]			=	size
													A__    :	List[str]			=	resample if resample is not None else PILImageResampling.BICUBIC
													A__    :	List[Any]			=	do_normalize
													A__    :	Dict			=	image_mean
													A__    :	str			=	image_std
													A__    :	Any			=	do_center_crop
													A__    :	List[Any]			=	crop_size

													A__    :	str			=	input_size_patches
													A__    :	Optional[int]			=	total_mask_patches
													A__    :	Optional[Any]			=	mask_group_max_patches
													A__    :	Union[str, Any]			=	mask_group_min_patches
													A__    :	int			=	mask_group_min_aspect_ratio
													A__    :	int			=	mask_group_max_aspect_ratio

													A__    :	Any			=	codebook_do_resize
													A__    :	Optional[int]			=	codebook_size
													A__    :	Optional[int]			=	codebook_resample if codebook_resample is not None else PILImageResampling.LANCZOS
													A__    :	Union[str, Any]			=	codebook_do_center_crop
													A__    :	str			=	codebook_crop_size
													A__    :	List[Any]			=	codebook_do_map_pixels
													A__    :	List[str]			=	codebook_do_normalize
													A__    :	List[str]			=	codebook_image_mean
													A__    :	Union[str, Any]			=	codebook_image_std


							def     _UpperCamelCase							(      self   :    List[str]				):
													'''simple docstring'''





													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     _UpperCamelCase							(      self   :    List[Any]				):
													'''simple docstring'''





													return (self.size["height"], self.size["width"])


							def     _UpperCamelCase							(      self   :    Optional[Any]				):
													'''simple docstring'''





													return (
													    (self.input_size_patches, self.input_size_patches)
													    if not isinstance(self.input_size_patches      ,     snake_case				)
													    else self.input_size_patches
													)


							def     _UpperCamelCase							(      self   :    Dict				):
													'''simple docstring'''





													return (self.codebook_size["height"], self.codebook_size["width"])






@require_torch
@require_vision
class 				__SCREAMING_SNAKE_CASE    (					UpperCamelCase							,		unittest.TestCase		):
							snake_case_  =				FlavaImageProcessor if is_vision_available() else None
							snake_case_  =				None


							def     _UpperCamelCase							(      self   :    Tuple				):
													'''simple docstring'''





													A__    :	str			=	FlavaImageProcessingTester(self				)


							@property
							def     _UpperCamelCase							(      self   :    Tuple				):
													'''simple docstring'''





													return self.image_processor_tester.prepare_image_processor_dict()


							def     _UpperCamelCase							(      self   :    Optional[Any]				):
													'''simple docstring'''





													A__    :	List[str]			=	self.image_processing_class(**self.image_processor_dict				)
													self.assertTrue(hasattr(snake_case      ,     """image_mean"""				)				)
													self.assertTrue(hasattr(snake_case      ,     """image_std"""				)				)
													self.assertTrue(hasattr(snake_case      ,     """do_normalize"""				)				)
													self.assertTrue(hasattr(snake_case      ,     """do_resize"""				)				)
													self.assertTrue(hasattr(snake_case      ,     """resample"""				)				)
													self.assertTrue(hasattr(snake_case      ,     """crop_size"""				)				)
													self.assertTrue(hasattr(snake_case      ,     """do_center_crop"""				)				)
													self.assertTrue(hasattr(snake_case      ,     """do_rescale"""				)				)
													self.assertTrue(hasattr(snake_case      ,     """rescale_factor"""				)				)
													self.assertTrue(hasattr(snake_case      ,     """masking_generator"""				)				)
													self.assertTrue(hasattr(snake_case      ,     """codebook_do_resize"""				)				)
													self.assertTrue(hasattr(snake_case      ,     """codebook_size"""				)				)
													self.assertTrue(hasattr(snake_case      ,     """codebook_resample"""				)				)
													self.assertTrue(hasattr(snake_case      ,     """codebook_do_center_crop"""				)				)
													self.assertTrue(hasattr(snake_case      ,     """codebook_crop_size"""				)				)
													self.assertTrue(hasattr(snake_case      ,     """codebook_do_map_pixels"""				)				)
													self.assertTrue(hasattr(snake_case      ,     """codebook_do_normalize"""				)				)
													self.assertTrue(hasattr(snake_case      ,     """codebook_image_mean"""				)				)
													self.assertTrue(hasattr(snake_case      ,     """codebook_image_std"""				)				)


							def     _UpperCamelCase							(      self   :    Tuple				):
													'''simple docstring'''





													A__    :	List[str]			=	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}				)

													A__    :	Tuple			=	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     _UpperCamelCase							(      self   :    List[Any]				):
													'''simple docstring'''





													pass


							def     _UpperCamelCase							(      self   :    Optional[int]				):
													'''simple docstring'''





													A__    :	int			=	self.image_processing_class(**self.image_processor_dict				)
													# create random PIL images
													A__    :	Union[str, Any]			=	prepare_image_inputs(self.image_processor_tester      ,     equal_resolution=snake_case				)
													for image in image_inputs:
																			self.assertIsInstance(snake_case      ,     PIL.Image.Image				)

													# Test not batched input
													A__    :	str			=	image_processing(image_inputs[0]      ,     return_tensors="""pt"""				)

													# Test no bool masked pos
													self.assertFalse("""bool_masked_pos""" in encoded_images				)

													A__	,	A__    :	Union[str, Any]			=	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
													A__    :	List[str]			=	image_processing(snake_case      ,     return_tensors="""pt"""				)
													A__	,	A__    :	int			=	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     _UpperCamelCase							(      self   :    List[Any]      ,     snake_case   :    str      ,     snake_case   :    str				):
													'''simple docstring'''





													A__    :	str			=	self.image_processing_class(**self.image_processor_dict				)
													# create random tensors
													A__    :	str			=	prepare_image_inputs(self.image_processor_tester      ,     equal_resolution=snake_case      ,     **snake_case				)
													for image in image_inputs:
																			self.assertIsInstance(snake_case      ,     snake_case				)

													# Test not batched input
													A__    :	List[Any]			=	image_processing(image_inputs[0]      ,     return_tensors="""pt"""				)

													A__	,	A__    :	Union[str, Any]			=	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)      ,     )

													A__    :	str			=	image_processing(snake_case      ,     return_image_mask=snake_case      ,     return_tensors="""pt"""				)

													A__	,	A__    :	List[Any]			=	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,
													    )      ,     )

													A__	,	A__    :	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
													A__    :	List[Any]			=	image_processing(snake_case      ,     return_tensors="""pt"""				).pixel_values

													A__	,	A__    :	List[str]			=	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
													A__    :	Tuple			=	image_processing(snake_case      ,     return_image_mask=snake_case      ,     return_tensors="""pt"""				)

													A__	,	A__    :	Dict			=	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,
													    )      ,     )

													A__	,	A__    :	Tuple			=	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     _UpperCamelCase							(      self   :    List[Any]				):
													'''simple docstring'''





													self._test_call_framework(np.ndarray      ,     prepare_kwargs={"""numpify""": True}				)


							def     _UpperCamelCase							(      self   :    Optional[int]				):
													'''simple docstring'''





													self._test_call_framework(torch.Tensor      ,     prepare_kwargs={"""torchify""": True}				)


							def     _UpperCamelCase							(      self   :    Any				):
													'''simple docstring'''





													random.seed(1234				)
													A__    :	Optional[Any]			=	self.image_processing_class(**self.image_processor_dict				)
													A__    :	Dict			=	prepare_image_inputs(self.image_processor_tester      ,     equal_resolution=snake_case      ,     torchify=snake_case				)

													# Test not batched input
													A__    :	List[str]			=	image_processing(image_inputs[0]      ,     return_image_mask=snake_case      ,     return_tensors="""pt"""				)
													self.assertEqual(encoded_images.bool_masked_pos.sum().item()      ,     75				)


							def     _UpperCamelCase							(      self   :    Union[str, Any]				):
													'''simple docstring'''





													A__    :	Any			=	self.image_processing_class(**self.image_processor_dict				)
													# create random PIL images
													A__    :	Dict			=	prepare_image_inputs(self.image_processor_tester      ,     equal_resolution=snake_case				)
													for image in image_inputs:
																			self.assertIsInstance(snake_case      ,     PIL.Image.Image				)

													# Test not batched input
													A__    :	Optional[Any]			=	image_processing(image_inputs[0]      ,     return_codebook_pixels=snake_case      ,     return_tensors="""pt"""				)
													A__	,	A__    :	str			=	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
													A__    :	Dict			=	image_processing(snake_case      ,     return_codebook_pixels=snake_case      ,     return_tensors="""pt"""				)
													A__	,	A__    :	Optional[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,
													    )      ,     )














"""simple docstring"""



def   _lowerCAmelCase		(				UpperCAmelCase__							:       int = 4_0_0_0_0_0_0   )		->int:
						A__    :	int			=	1
						A__    :	List[str]			=	2
						A__    :	Union[str, Any]			=	0
						while j <= n:
												if j % 2 == 0:
																		total += j
												A__	,	A__    :	str			=	j, i + j

						return total


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






