



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

class        _A			(      unittest.TestCase       ):



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


           '''simple docstring'''

           __a					=							size if size is not None else {'''height''': 224, '''width''': 224}
           __a					=							crop_size if crop_size is not None else {'''height''': 224, '''width''': 224}
           __a					=							codebook_size if codebook_size is not None else {'''height''': 112, '''width''': 112}
           __a					=							codebook_crop_size if codebook_crop_size is not None else {'''height''': 112, '''width''': 112}

           __a					=							parent
           __a					=							batch_size
           __a					=							num_channels
           __a					=							do_resize
           __a					=							do_rescale
           __a					=							rescale_factor
           __a					=							min_resolution
           __a					=							max_resolution
           __a					=							size
           __a					=							resample if resample is not None else PILImageResampling.BICUBIC
           __a					=							do_normalize
           __a					=							image_mean
           __a					=							image_std
           __a					=							do_center_crop
           __a					=							crop_size

           __a					=							input_size_patches
           __a					=							total_mask_patches
           __a					=							mask_group_max_patches
           __a					=							mask_group_min_patches
           __a					=							mask_group_min_aspect_ratio
           __a					=							mask_group_max_aspect_ratio

           __a					=							codebook_do_resize
           __a					=							codebook_size
           __a					=							codebook_resample if codebook_resample is not None else PILImageResampling.LANCZOS
           __a					=							codebook_do_center_crop
           __a					=							codebook_crop_size
           __a					=							codebook_do_map_pixels
           __a					=							codebook_do_normalize
           __a					=							codebook_image_mean
           __a					=							codebook_image_std



       def 						_lowerCamelCase     (						self				:	Optional[int]):


           '''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 						_lowerCamelCase     (						self				:	str):


           '''simple docstring'''

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



       def 						_lowerCamelCase     (						self				:	List[Any]):


           '''simple docstring'''

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





       def 						_lowerCamelCase     (						self				:	Tuple):


           '''simple docstring'''

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


@require_torch
@require_vision
class        _A			(      __UpperCAmelCase ,unittest.TestCase       ):
       UpperCamelCase__    :       List[str]		   =		FlavaImageProcessor if is_vision_available() else None
       UpperCamelCase__    :       Tuple		   =		None



       def 						_lowerCamelCase     (						self				:	Optional[int]):


           '''simple docstring'''

           __a					=							FlavaImageProcessingTester(self)



       @property
       def 						_lowerCamelCase     (						self				:	Union[str, Any]):


           '''simple docstring'''

           return self.image_processor_tester.prepare_image_processor_dict()



       def 						_lowerCamelCase     (						self				:	int):


           '''simple docstring'''

           __a					=							self.image_processing_class(**self.image_processor_dict)
           self.assertTrue(hasattr(__SCREAMING_SNAKE_CASE	,						'''image_mean'''))
           self.assertTrue(hasattr(__SCREAMING_SNAKE_CASE	,						'''image_std'''))
           self.assertTrue(hasattr(__SCREAMING_SNAKE_CASE	,						'''do_normalize'''))
           self.assertTrue(hasattr(__SCREAMING_SNAKE_CASE	,						'''do_resize'''))
           self.assertTrue(hasattr(__SCREAMING_SNAKE_CASE	,						'''resample'''))
           self.assertTrue(hasattr(__SCREAMING_SNAKE_CASE	,						'''crop_size'''))
           self.assertTrue(hasattr(__SCREAMING_SNAKE_CASE	,						'''do_center_crop'''))
           self.assertTrue(hasattr(__SCREAMING_SNAKE_CASE	,						'''do_rescale'''))
           self.assertTrue(hasattr(__SCREAMING_SNAKE_CASE	,						'''rescale_factor'''))
           self.assertTrue(hasattr(__SCREAMING_SNAKE_CASE	,						'''masking_generator'''))
           self.assertTrue(hasattr(__SCREAMING_SNAKE_CASE	,						'''codebook_do_resize'''))
           self.assertTrue(hasattr(__SCREAMING_SNAKE_CASE	,						'''codebook_size'''))
           self.assertTrue(hasattr(__SCREAMING_SNAKE_CASE	,						'''codebook_resample'''))
           self.assertTrue(hasattr(__SCREAMING_SNAKE_CASE	,						'''codebook_do_center_crop'''))
           self.assertTrue(hasattr(__SCREAMING_SNAKE_CASE	,						'''codebook_crop_size'''))
           self.assertTrue(hasattr(__SCREAMING_SNAKE_CASE	,						'''codebook_do_map_pixels'''))
           self.assertTrue(hasattr(__SCREAMING_SNAKE_CASE	,						'''codebook_do_normalize'''))
           self.assertTrue(hasattr(__SCREAMING_SNAKE_CASE	,						'''codebook_image_mean'''))
           self.assertTrue(hasattr(__SCREAMING_SNAKE_CASE	,						'''codebook_image_std'''))



       def 						_lowerCamelCase     (						self				:	str):


           '''simple docstring'''

           __a					=							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					=							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 						_lowerCamelCase     (						self				:	Union[str, Any]):


           '''simple docstring'''

           pass



       def 						_lowerCamelCase     (						self				:	Dict):


           '''simple docstring'''

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

           # Test not batched input
           __a					=							image_processing(image_inputs[0]	,						return_tensors='''pt''')

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

           __a			,  __a					=							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					=							image_processing(__SCREAMING_SNAKE_CASE	,						return_tensors='''pt''')
           __a			,  __a					=							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 						_lowerCamelCase     (						self				:	Any	,						__SCREAMING_SNAKE_CASE				:	Any	,						__SCREAMING_SNAKE_CASE				:	Optional[Any]):


           '''simple docstring'''

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

           # Test not batched input
           __a					=							image_processing(image_inputs[0]	,						return_tensors='''pt''')

           __a			,  __a					=							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					=							image_processing(__SCREAMING_SNAKE_CASE	,						return_image_mask=__SCREAMING_SNAKE_CASE	,						return_tensors='''pt''')

           __a			,  __a					=							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					=							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					=							image_processing(__SCREAMING_SNAKE_CASE	,						return_tensors='''pt''').pixel_values

           __a			,  __a					=							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					=							image_processing(__SCREAMING_SNAKE_CASE	,						return_image_mask=__SCREAMING_SNAKE_CASE	,						return_tensors='''pt''')

           __a			,  __a					=							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					=							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 						_lowerCamelCase     (						self				:	Optional[int]):


           '''simple docstring'''

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



       def 						_lowerCamelCase     (						self				:	Any):


           '''simple docstring'''

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



       def 						_lowerCamelCase     (						self				:	Tuple):


           '''simple docstring'''

           random.seed(1_234)
           __a					=							self.image_processing_class(**self.image_processor_dict)
           __a					=							prepare_image_inputs(self.image_processor_tester	,						equal_resolution=__SCREAMING_SNAKE_CASE	,						torchify=__SCREAMING_SNAKE_CASE)

           # Test not batched input
           __a					=							image_processing(image_inputs[0]	,						return_image_mask=__SCREAMING_SNAKE_CASE	,						return_tensors='''pt''')
           self.assertEqual(encoded_images.bool_masked_pos.sum().item()	,						75)





       def 						_lowerCamelCase     (						self				:	Optional[int]):


           '''simple docstring'''

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

           # Test not batched input
           __a					=							image_processing(image_inputs[0]	,						return_codebook_pixels=__SCREAMING_SNAKE_CASE	,						return_tensors='''pt''')
           __a			,  __a					=							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					=							image_processing(__SCREAMING_SNAKE_CASE	,						return_codebook_pixels=__SCREAMING_SNAKE_CASE	,						return_tensors='''pt''')
           __a			,  __a					=							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,
               )	,						)










def 	__snake_case      (     _UpperCAmelCase  ,					_UpperCAmelCase  ,					_UpperCAmelCase							):
    __a					=							[1 / first_term]
    __a					=							1 / first_term
    for _ in range(number_of_terms - 1							):
        first_term += common_difference
        arithmetic_progression.append(_UpperCAmelCase							)
    __a					=							[1 / step for step in arithmetic_progression]
    return sum(_UpperCAmelCase							)


if __name__ == "__main__":
 import doctest

 doctest.testmod()
 print(sum_of_harmonic_progression(1 / 2, 2, 2))





