



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       __lowerCAmelCase				(  unittest.TestCase ):




				def __init__(							self		,       _snake_case		,       _snake_case=7		,       _snake_case=3		,       _snake_case=30		,       _snake_case=400		,       _snake_case=True		,       _snake_case=None		,       _snake_case=True		,       _snake_case=None		,       _snake_case=None		,       _snake_case=True		,       _snake_case=1 / 255		,       _snake_case=True		,       _snake_case=FLAVA_IMAGE_MEAN		,       _snake_case=FLAVA_IMAGE_STD		,       _snake_case=14		,       _snake_case=75		,       _snake_case=None		,       _snake_case=16		,       _snake_case=0.3		,       _snake_case=None		,       _snake_case=True		,       _snake_case=None		,       _snake_case=None		,       _snake_case=True		,       _snake_case=None		,       _snake_case=True		,       _snake_case=True		,       _snake_case=FLAVA_CODEBOOK_MEAN		,       _snake_case=FLAVA_CODEBOOK_STD		,       ):



									"""simple docstring"""





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

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

									_lowerCAmelCase      			=					input_size_patches
									_lowerCAmelCase      			=					total_mask_patches
									_lowerCAmelCase      			=					mask_group_max_patches
									_lowerCAmelCase      			=					mask_group_min_patches
									_lowerCAmelCase      			=					mask_group_min_aspect_ratio
									_lowerCAmelCase      			=					mask_group_max_aspect_ratio

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




				def 							snake_case     (							self	):



									"""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 							snake_case     (							self	):



									"""simple docstring"""





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




				def 							snake_case     (							self	):



									"""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 							snake_case     (							self	):



									"""simple docstring"""





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





@require_torch
@require_vision
class       __lowerCAmelCase				(  lowerCamelCase__ ,		unittest.TestCase ):
				__lowerCamelCase				=       FlavaImageProcessor if is_vision_available() else None
				__lowerCamelCase				=       None




				def 							snake_case     (							self	):



									"""simple docstring"""





									_lowerCAmelCase      			=					FlavaImageProcessingTester(self	)




				@property
				def 							snake_case     (							self	):



									"""simple docstring"""





									return self.image_processor_tester.prepare_image_processor_dict()




				def 							snake_case     (							self	):



									"""simple docstring"""





									_lowerCAmelCase      			=					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 							snake_case     (							self	):



									"""simple docstring"""





									_lowerCAmelCase      			=					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}	)

									_lowerCAmelCase      			=					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	):



									"""simple docstring"""





									pass




				def 							snake_case     (							self	):



									"""simple docstring"""





									_lowerCAmelCase      			=					self.image_processing_class(**self.image_processor_dict	)
									# create random PIL images
									_lowerCAmelCase      			=					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
									_lowerCAmelCase      			=					image_processing(image_inputs[0]		,       return_tensors="""pt"""	)

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

									_lowerCAmelCase			,			_lowerCAmelCase      			=					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
									_lowerCAmelCase      			=					image_processing(_snake_case		,       return_tensors="""pt"""	)
									_lowerCAmelCase			,			_lowerCAmelCase      			=					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		,       _snake_case		,       _snake_case	):



									"""simple docstring"""





									_lowerCAmelCase      			=					self.image_processing_class(**self.image_processor_dict	)
									# create random tensors
									_lowerCAmelCase      			=					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
									_lowerCAmelCase      			=					image_processing(image_inputs[0]		,       return_tensors="""pt"""	)

									_lowerCAmelCase			,			_lowerCAmelCase      			=					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)		,       )

									_lowerCAmelCase      			=					image_processing(_snake_case		,       return_image_mask=_snake_case		,       return_tensors="""pt"""	)

									_lowerCAmelCase			,			_lowerCAmelCase      			=					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,
									    )		,       )

									_lowerCAmelCase			,			_lowerCAmelCase      			=					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
									_lowerCAmelCase      			=					image_processing(_snake_case		,       return_tensors="""pt"""	).pixel_values

									_lowerCAmelCase			,			_lowerCAmelCase      			=					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
									_lowerCAmelCase      			=					image_processing(_snake_case		,       return_image_mask=_snake_case		,       return_tensors="""pt"""	)

									_lowerCAmelCase			,			_lowerCAmelCase      			=					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,
									    )		,       )

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



									"""simple docstring"""





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




				def 							snake_case     (							self	):



									"""simple docstring"""





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




				def 							snake_case     (							self	):



									"""simple docstring"""





									random.seed(1234	)
									_lowerCAmelCase      			=					self.image_processing_class(**self.image_processor_dict	)
									_lowerCAmelCase      			=					prepare_image_inputs(self.image_processor_tester		,       equal_resolution=_snake_case		,       torchify=_snake_case	)

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




				def 							snake_case     (							self	):



									"""simple docstring"""





									_lowerCAmelCase      			=					self.image_processing_class(**self.image_processor_dict	)
									# create random PIL images
									_lowerCAmelCase      			=					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
									_lowerCAmelCase      			=					image_processing(image_inputs[0]		,       return_codebook_pixels=_snake_case		,       return_tensors="""pt"""	)
									_lowerCAmelCase			,			_lowerCAmelCase      			=					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
									_lowerCAmelCase      			=					image_processing(_snake_case		,       return_codebook_pixels=_snake_case		,       return_tensors="""pt"""	)
									_lowerCAmelCase			,			_lowerCAmelCase      			=					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,
									    )		,       )








# tests directory-specific settings - this file is run automatically
# by pytest before any tests are run

import sys
import warnings
from os.path import abspath, dirname, join


# allow having multiple repository checkouts and not needing to remember to rerun
# 'pip install -e .[dev]' when switching between checkouts and running tests.
A__			   = abspath(join(dirname(dirname(dirname(__file__))), """src"""))
sys.path.insert(1, git_repo_path)


# silence FutureWarning warnings in tests since often we can't act on them until
# they become normal warnings - i.e. the tests still need to test the current functionality
warnings.simplefilter(action="""ignore""", category=FutureWarning)


def 	_UpperCAmelCase       (   snake_case    ):





					"""simple docstring"""

					from transformers.testing_utils import pytest_addoption_shared

					pytest_addoption_shared(snake_case    )


def 	_UpperCAmelCase       (   snake_case    ):





					"""simple docstring"""

					from transformers.testing_utils import pytest_terminal_summary_main

					_lowerCAmelCase      			=					terminalreporter.config.getoption("""--make-reports"""    )
					if make_reports:
										pytest_terminal_summary_main(snake_case			,		id=snake_case    )



