





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:
 _lowerCAmelCase							:      Any						=	None


class 					__magic_name__  (							unittest.TestCase							):





     """simple docstring"""



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





        '''simple docstring'''




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

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

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

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



     def 						SCREAMING_SNAKE_CASE		(							self       :Union[str, Any]  ):





        '''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 						SCREAMING_SNAKE_CASE		(							self       :Union[str, Any]  ):





        '''simple docstring'''




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



     def 						SCREAMING_SNAKE_CASE		(							self       :int  ):





        '''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 						SCREAMING_SNAKE_CASE		(							self       :int  ):





        '''simple docstring'''




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




@require_torch
@require_vision
class 					__magic_name__  (							lowerCamelCase__    ,				unittest.TestCase							):





     """simple docstring"""



     __UpperCamelCase					    =     FlavaImageProcessor if is_vision_available() else None
     __UpperCamelCase					    =     None



     def 						SCREAMING_SNAKE_CASE		(							self       :Dict  ):





        '''simple docstring'''




        A_					:				Dict          =			FlavaImageProcessingTester(self  )



     @property
     def 						SCREAMING_SNAKE_CASE		(							self       :Optional[Any]  ):





        '''simple docstring'''




        return self.image_processor_tester.prepare_image_processor_dict()



     def 						SCREAMING_SNAKE_CASE		(							self       :Union[str, Any]  ):





        '''simple docstring'''




        A_					:				int          =			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 						SCREAMING_SNAKE_CASE		(							self       :List[Any]  ):





        '''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 						SCREAMING_SNAKE_CASE		(							self       :Dict  ):





        '''simple docstring'''




        pass



     def 						SCREAMING_SNAKE_CASE		(							self       :List[str]  ):





        '''simple docstring'''




        A_					:				Union[str, 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_					:				int          =			image_processing(image_inputs[0]			,      return_tensors="pt"  )

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

        A_      ,						A_					:				Optional[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_					:				str          =			image_processing(snake_case			,      return_tensors="pt"  )
        A_      ,						A_					:				str          =			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 						SCREAMING_SNAKE_CASE		(							self       :Optional[int]			,      snake_case       :int			,      snake_case       :List[Any]  ):





        '''simple docstring'''




        A_					:				Union[str, Any]          =			self.image_processing_class(**self.image_processor_dict  )
        # create random tensors
        A_					:				Tuple          =			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_					:				Any          =			image_processing(image_inputs[0]			,      return_tensors="pt"  )

        A_      ,						A_					:				Dict          =			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_					:				Optional[Any]          =			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,
            )			,      )

        # Test batched
        A_					:				Union[str, Any]          =			image_processing(snake_case			,      return_tensors="pt"  ).pixel_values

        A_      ,						A_					:				Optional[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
        A_					:				int          =			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_					:				Dict          =			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 						SCREAMING_SNAKE_CASE		(							self       :Any  ):





        '''simple docstring'''




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



     def 						SCREAMING_SNAKE_CASE		(							self       :Any  ):





        '''simple docstring'''




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



     def 						SCREAMING_SNAKE_CASE		(							self       :Tuple  ):





        '''simple docstring'''




        random.seed(1_234  )
        A_					:				Any          =			self.image_processing_class(**self.image_processor_dict  )
        A_					:				Any          =			prepare_image_inputs(self.image_processor_tester			,      equal_resolution=snake_case			,      torchify=snake_case  )

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





     def 						SCREAMING_SNAKE_CASE		(							self       :Tuple  ):





        '''simple docstring'''




        A_					:				str          =			self.image_processing_class(**self.image_processor_dict  )
        # create random PIL images
        A_					:				int          =			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_					:				int          =			image_processing(image_inputs[0]			,      return_codebook_pixels=snake_case			,      return_tensors="pt"  )
        A_      ,						A_					:				Union[str, Any]          =			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_					:				int          =			image_processing(snake_case			,      return_codebook_pixels=snake_case			,      return_tensors="pt"  )
        A_      ,						A_					:				Any          =			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,
            )			,      )







import warnings
from collections.abc import Callable
from typing import Any

import numpy
from matplotlib import pyplot

_lowerCAmelCase							:      Union[str, Any]						=	0.25 + 0.0j
_lowerCAmelCase							:      str						=	-0.4 + 0.6j
_lowerCAmelCase							:      Optional[int]						=	-0.1 + 0.6_5_1j
_lowerCAmelCase							:      Union[str, Any]						=	-2.0
_lowerCAmelCase							:      str						=	56
_lowerCAmelCase							:      Optional[Any]						=	2.0
_lowerCAmelCase							:      Dict						=	666

def      __snake_case						(					_lowerCAmelCase : complex				,				_lowerCAmelCase : numpy.ndarray	) ->						numpy.ndarray:
   return numpy.exp(_lowerCAmelCase	) + c_parameter

def      __snake_case						(					_lowerCAmelCase : complex				,				_lowerCAmelCase : numpy.ndarray	) ->						numpy.ndarray:
   return z_values * z_values + c_parameter

def      __snake_case						(					_lowerCAmelCase : float				,				_lowerCAmelCase : int	) ->						numpy.ndarray:
   A_					:				Tuple          =			numpy.linspace(-window_size				,				_lowerCAmelCase				,				_lowerCAmelCase	)
   A_					:				Optional[int]          =			x.reshape((nb_pixels, 1)	)
   A_					:				str          =			numpy.linspace(-window_size				,				_lowerCAmelCase				,				_lowerCAmelCase	)
   A_					:				Tuple          =			y.reshape((1, nb_pixels)	)
   return x + 1.0j * y

def      __snake_case						(					_lowerCAmelCase : Callable[[Any, numpy.ndarray], numpy.ndarray]				,				_lowerCAmelCase : Any				,				_lowerCAmelCase : int				,				_lowerCAmelCase : numpy.ndarray				,				_lowerCAmelCase : float | None = None				,				) ->						numpy.ndarray:
   A_					:				List[Any]          =			z_a.astype("complex64"	)
   for _ in range(_lowerCAmelCase	):
      A_					:				List[Any]          =			eval_function(_lowerCAmelCase				,				_lowerCAmelCase	)
      if infinity is not None:
         numpy.nan_to_num(_lowerCAmelCase				,				copy=_lowerCAmelCase				,				nan=_lowerCAmelCase	)
         A_					:				List[Any]          =			infinity
   return z_n

def      __snake_case						(					_lowerCAmelCase : str				,				_lowerCAmelCase : Any				,				_lowerCAmelCase : float				,				_lowerCAmelCase : numpy.ndarray				,				) ->						None:
   A_					:				Optional[int]          =			(abs(_lowerCAmelCase	)).transpose()
   A_					:				Optional[int]          =			abs_z_final[::-1, :]
   pyplot.matshow(abs_z_final < escape_radius	)
   pyplot.title(f"Julia set of ${function_label}$, $c={function_params}$"	)
   pyplot.show()

def      __snake_case						(					) ->						None:
   warnings.filterwarnings(
       "ignore"				,				category=_lowerCAmelCase				,				message="overflow encountered in multiply"	)
   warnings.filterwarnings(
       "ignore"				,				category=_lowerCAmelCase				,				message="invalid value encountered in multiply"				,				)
   warnings.filterwarnings(
       "ignore"				,				category=_lowerCAmelCase				,				message="overflow encountered in absolute"	)
   warnings.filterwarnings(
       "ignore"				,				category=_lowerCAmelCase				,				message="overflow encountered in exp"	)


if __name__ == "__main__":
 _lowerCAmelCase							:      List[str]						=	prepare_grid(window_size, nb_pixels)

 ignore_overflow_warnings()  # See file header for explanations

 _lowerCAmelCase							:      str						=	24
 _lowerCAmelCase							:      str						=	2 * abs(c_cauliflower) + 1
 _lowerCAmelCase							:      Optional[Any]						=	iterate_function(
     eval_quadratic_polynomial,
     c_cauliflower,
     nb_iterations,
     z_a,
     infinity=1.1 * escape_radius,
 )
 show_results('''z^2+c''', c_cauliflower, escape_radius, z_final)

 _lowerCAmelCase							:      Optional[int]						=	64
 _lowerCAmelCase							:      List[Any]						=	2 * abs(c_polynomial_a) + 1
 _lowerCAmelCase							:      List[str]						=	iterate_function(
     eval_quadratic_polynomial,
     c_polynomial_a,
     nb_iterations,
     z_a,
     infinity=1.1 * escape_radius,
 )
 show_results('''z^2+c''', c_polynomial_a, escape_radius, z_final)

 _lowerCAmelCase							:      Tuple						=	161
 _lowerCAmelCase							:      int						=	2 * abs(c_polynomial_a) + 1
 _lowerCAmelCase							:      List[Any]						=	iterate_function(
     eval_quadratic_polynomial,
     c_polynomial_a,
     nb_iterations,
     z_a,
     infinity=1.1 * escape_radius,
 )
 show_results('''z^2+c''', c_polynomial_a, escape_radius, z_final)

 _lowerCAmelCase							:      List[str]						=	12
 _lowerCAmelCase							:      str						=	1_0000.0
 _lowerCAmelCase							:      Tuple						=	iterate_function(
     eval_exponential,
     c_exponential,
     nb_iterations,
     z_a + 2,
     infinity=1.0e10,
 )
 show_results('''e^z+c''', c_exponential, escape_radius, z_final)
