






'''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:
  UpperCamelCase_					=				UpperCamelCase_					=				UpperCamelCase_					=				UpperCamelCase_					=				None




class 					__UpperCAmelCase (		unittest.TestCase	):

      '''simple docstring'''





      def __init__(					self  ,		_UpperCAmelCase  ,		_UpperCAmelCase=7  ,		_UpperCAmelCase=3  ,		_UpperCAmelCase=30  ,		_UpperCAmelCase=400  ,		_UpperCAmelCase=True  ,		_UpperCAmelCase=None  ,		_UpperCAmelCase=True  ,		_UpperCAmelCase=None  ,		_UpperCAmelCase=None  ,		_UpperCAmelCase=True  ,		_UpperCAmelCase=1 / 255  ,		_UpperCAmelCase=True  ,		_UpperCAmelCase=FLAVA_IMAGE_MEAN  ,		_UpperCAmelCase=FLAVA_IMAGE_STD  ,		_UpperCAmelCase=14  ,		_UpperCAmelCase=75  ,		_UpperCAmelCase=None  ,		_UpperCAmelCase=16  ,		_UpperCAmelCase=0.3  ,		_UpperCAmelCase=None  ,		_UpperCAmelCase=True  ,		_UpperCAmelCase=None  ,		_UpperCAmelCase=None  ,		_UpperCAmelCase=True  ,		_UpperCAmelCase=None  ,		_UpperCAmelCase=True  ,		_UpperCAmelCase=True  ,		_UpperCAmelCase=FLAVA_CODEBOOK_MEAN  ,		_UpperCAmelCase=FLAVA_CODEBOOK_STD  ,		):
             UpperCAmelCase__	:   Dict												=	size if size is not None else {'''height''': 224, '''width''': 224}
             UpperCAmelCase__	:   Dict												=	crop_size if crop_size is not None else {'''height''': 224, '''width''': 224}
             UpperCAmelCase__	:   List[str]												=	codebook_size if codebook_size is not None else {'''height''': 112, '''width''': 112}
             UpperCAmelCase__	:   Optional[int]												=	codebook_crop_size if codebook_crop_size is not None else {'''height''': 112, '''width''': 112}

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

             UpperCAmelCase__	:   Optional[Any]												=	input_size_patches
             UpperCAmelCase__	:   Any												=	total_mask_patches
             UpperCAmelCase__	:   Union[str, Any]												=	mask_group_max_patches
             UpperCAmelCase__	:   Any												=	mask_group_min_patches
             UpperCAmelCase__	:   Any												=	mask_group_min_aspect_ratio
             UpperCAmelCase__	:   List[Any]												=	mask_group_max_aspect_ratio

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




      def 							lowerCamelCase     (					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 							lowerCamelCase     (					self						):
             return (self.size["height"], self.size["width"])




      def 							lowerCamelCase     (					self						):
             return (
                 (self.input_size_patches, self.input_size_patches)
                 if not isinstance(self.input_size_patches  ,		_UpperCAmelCase						)
                 else self.input_size_patches
             )




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




@require_torch
@require_vision
class 					__UpperCAmelCase (		UpperCamelCase__      ,				unittest.TestCase	):

      '''simple docstring'''





      SCREAMING_SNAKE_CASE				:    List[Any]				       =					FlavaImageProcessor if is_vision_available() else None
      SCREAMING_SNAKE_CASE				:    int				       =					None




      def 							lowerCamelCase     (					self						):
             UpperCAmelCase__	:   Tuple												=	FlavaImageProcessingTester(self						)




      @property
      def 							lowerCamelCase     (					self						):
             return self.image_processor_tester.prepare_image_processor_dict()




      def 							lowerCamelCase     (					self						):
             UpperCAmelCase__	:   Dict												=	self.image_processing_class(**self.image_processor_dict						)
             self.assertTrue(hasattr(_UpperCAmelCase  ,		'''image_mean'''						)						)
             self.assertTrue(hasattr(_UpperCAmelCase  ,		'''image_std'''						)						)
             self.assertTrue(hasattr(_UpperCAmelCase  ,		'''do_normalize'''						)						)
             self.assertTrue(hasattr(_UpperCAmelCase  ,		'''do_resize'''						)						)
             self.assertTrue(hasattr(_UpperCAmelCase  ,		'''resample'''						)						)
             self.assertTrue(hasattr(_UpperCAmelCase  ,		'''crop_size'''						)						)
             self.assertTrue(hasattr(_UpperCAmelCase  ,		'''do_center_crop'''						)						)
             self.assertTrue(hasattr(_UpperCAmelCase  ,		'''do_rescale'''						)						)
             self.assertTrue(hasattr(_UpperCAmelCase  ,		'''rescale_factor'''						)						)
             self.assertTrue(hasattr(_UpperCAmelCase  ,		'''masking_generator'''						)						)
             self.assertTrue(hasattr(_UpperCAmelCase  ,		'''codebook_do_resize'''						)						)
             self.assertTrue(hasattr(_UpperCAmelCase  ,		'''codebook_size'''						)						)
             self.assertTrue(hasattr(_UpperCAmelCase  ,		'''codebook_resample'''						)						)
             self.assertTrue(hasattr(_UpperCAmelCase  ,		'''codebook_do_center_crop'''						)						)
             self.assertTrue(hasattr(_UpperCAmelCase  ,		'''codebook_crop_size'''						)						)
             self.assertTrue(hasattr(_UpperCAmelCase  ,		'''codebook_do_map_pixels'''						)						)
             self.assertTrue(hasattr(_UpperCAmelCase  ,		'''codebook_do_normalize'''						)						)
             self.assertTrue(hasattr(_UpperCAmelCase  ,		'''codebook_image_mean'''						)						)
             self.assertTrue(hasattr(_UpperCAmelCase  ,		'''codebook_image_std'''						)						)




      def 							lowerCamelCase     (					self						):
             UpperCAmelCase__	:   Any												=	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}						)

             UpperCAmelCase__	:   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 							lowerCamelCase     (					self						):
             pass




      def 							lowerCamelCase     (					self						):
             # Initialize image_processing
             UpperCAmelCase__	:   Optional[int]												=	self.image_processing_class(**self.image_processor_dict						)
             # create random PIL images
             UpperCAmelCase__	:   List[Any]												=	prepare_image_inputs(self.image_processor_tester  ,		equal_resolution=_UpperCAmelCase						)
             for image in image_inputs:
                    self.assertIsInstance(_UpperCAmelCase  ,		PIL.Image.Image						)

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

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

             UpperCAmelCase__							,							UpperCAmelCase__	:   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)  ,		)

             # Test batched
             UpperCAmelCase__	:   Optional[int]												=	image_processing(_UpperCAmelCase  ,		return_tensors='''pt'''						)
             UpperCAmelCase__							,							UpperCAmelCase__	:   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 							lowerCamelCase     (					self  ,		_UpperCAmelCase  ,		_UpperCAmelCase						):
             # Initialize image_processing
             UpperCAmelCase__	:   List[Any]												=	self.image_processing_class(**self.image_processor_dict						)
             # create random tensors
             UpperCAmelCase__	:   Any												=	prepare_image_inputs(self.image_processor_tester  ,		equal_resolution=_UpperCAmelCase  ,		**_UpperCAmelCase						)
             for image in image_inputs:
                    self.assertIsInstance(_UpperCAmelCase  ,		_UpperCAmelCase						)

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

             UpperCAmelCase__							,							UpperCAmelCase__	:   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)  ,		)

             UpperCAmelCase__	:   Optional[Any]												=	image_processing(_UpperCAmelCase  ,		return_image_mask=_UpperCAmelCase  ,		return_tensors='''pt'''						)

             UpperCAmelCase__							,							UpperCAmelCase__	:   Union[str, 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,
                 )  ,		)

             UpperCAmelCase__							,							UpperCAmelCase__	:   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
             UpperCAmelCase__	:   Union[str, Any]												=	image_processing(_UpperCAmelCase  ,		return_tensors='''pt'''						).pixel_values

             UpperCAmelCase__							,							UpperCAmelCase__	:   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
             UpperCAmelCase__	:   Dict												=	image_processing(_UpperCAmelCase  ,		return_image_mask=_UpperCAmelCase  ,		return_tensors='''pt'''						)

             UpperCAmelCase__							,							UpperCAmelCase__	:   Union[str, 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,
                 )  ,		)

             UpperCAmelCase__							,							UpperCAmelCase__	:   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 							lowerCamelCase     (					self						):
             self._test_call_framework(np.ndarray  ,		prepare_kwargs={'''numpify''': True}						)




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




      def 							lowerCamelCase     (					self						):
             # Initialize image_processing
             random.seed(1234						)
             UpperCAmelCase__	:   Dict												=	self.image_processing_class(**self.image_processor_dict						)
             UpperCAmelCase__	:   Any												=	prepare_image_inputs(self.image_processor_tester  ,		equal_resolution=_UpperCAmelCase  ,		torchify=_UpperCAmelCase						)

             # Test not batched input
             UpperCAmelCase__	:   Optional[Any]												=	image_processing(image_inputs[0]  ,		return_image_mask=_UpperCAmelCase  ,		return_tensors='''pt'''						)
             self.assertEqual(encoded_images.bool_masked_pos.sum().item()  ,		75						)




      def 							lowerCamelCase     (					self						):
             # Initialize image_processing
             UpperCAmelCase__	:   Union[str, Any]												=	self.image_processing_class(**self.image_processor_dict						)
             # create random PIL images
             UpperCAmelCase__	:   Optional[Any]												=	prepare_image_inputs(self.image_processor_tester  ,		equal_resolution=_UpperCAmelCase						)
             for image in image_inputs:
                    self.assertIsInstance(_UpperCAmelCase  ,		PIL.Image.Image						)

             # Test not batched input
             UpperCAmelCase__	:   Tuple												=	image_processing(image_inputs[0]  ,		return_codebook_pixels=_UpperCAmelCase  ,		return_tensors='''pt'''						)
             UpperCAmelCase__							,							UpperCAmelCase__	:   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
             UpperCAmelCase__	:   Tuple												=	image_processing(_UpperCAmelCase  ,		return_codebook_pixels=_UpperCAmelCase  ,		return_tensors='''pt'''						)
             UpperCAmelCase__							,							UpperCAmelCase__	:   Optional[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,
                 )  ,		)







'''simple docstring'''







import re






def  lowerCAmelCase__		(					a_  :     Optional[int]			)   -> Optional[Any]:
       def docstring_decorator(a_  :     Dict			):
              UpperCAmelCase__	:   Optional[int]												=	fn.__doc__
              UpperCAmelCase__	:   Dict												=	func_doc.split('''\n'''			)
              UpperCAmelCase__	:   Any												=	0
              while i < len(a_			) and re.search(r'''^\s*Examples?:\s*$'''			,						lines[i]			) is None:
                     i += 1
              if i < len(a_			):
                     UpperCAmelCase__	:   List[Any]												=	example_docstring
                     UpperCAmelCase__	:   int												=	'''\n'''.join(a_			)
              else:
                     raise ValueError(
                         f"""The function {fn} should have an empty 'Examples:' in its docstring as placeholder, """
                         f"""current docstring is:\n{func_doc}"""			)
              UpperCAmelCase__	:   Any												=	func_doc
              return fn

       return docstring_decorator