




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




class        snake_case__				(unittest.TestCase  ):
				"""simple docstring"""



				def __init__( self							:	List[Any]   , __lowerCamelCase							:	Any   , __lowerCamelCase							:	List[str]=7   , __lowerCamelCase							:	Optional[int]=3   , __lowerCamelCase							:	List[Any]=30   , __lowerCamelCase							:	int=4_00   , __lowerCamelCase							:	List[str]=True   , __lowerCamelCase							:	Tuple=None   , __lowerCamelCase							:	Optional[int]=True   , __lowerCamelCase							:	Tuple=None   , __lowerCamelCase							:	Dict=None   , __lowerCamelCase							:	str=True   , __lowerCamelCase							:	int=1 / 2_55   , __lowerCamelCase							:	str=True   , __lowerCamelCase							:	Any=FLAVA_IMAGE_MEAN   , __lowerCamelCase							:	Any=FLAVA_IMAGE_STD   , __lowerCamelCase							:	List[Any]=14   , __lowerCamelCase							:	Any=75   , __lowerCamelCase							:	Union[str, Any]=None   , __lowerCamelCase							:	Tuple=16   , __lowerCamelCase							:	Union[str, Any]=0.3   , __lowerCamelCase							:	List[Any]=None   , __lowerCamelCase							:	Dict=True   , __lowerCamelCase							:	Tuple=None   , __lowerCamelCase							:	List[Any]=None   , __lowerCamelCase							:	Dict=True   , __lowerCamelCase							:	List[str]=None   , __lowerCamelCase							:	Any=True   , __lowerCamelCase							:	List[str]=True   , __lowerCamelCase							:	str=FLAVA_CODEBOOK_MEAN   , __lowerCamelCase							:	int=FLAVA_CODEBOOK_STD   , )   ->	Tuple:
							a       =     size if size is not None else {"height": 2_24, "width": 2_24}
							a       =     crop_size if crop_size is not None else {"height": 2_24, "width": 2_24}
							a       =     codebook_size if codebook_size is not None else {"height": 1_12, "width": 1_12}
							a       =     codebook_crop_size if codebook_crop_size is not None else {"height": 1_12, "width": 1_12}

							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 				__UpperCAmelCase				( self							:	Union[str, Any]				)   ->	Any:
							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							:	int				)   ->	Tuple:
							return (self.size["height"], self.size["width"])





				def 				__UpperCAmelCase				( self							:	List[Any]				)   ->	Dict:
							return (
							    (self.input_size_patches, self.input_size_patches)
							    if not isinstance(self.input_size_patches   , __UpperCAmelCase				)
							    else self.input_size_patches
							)





				def 				__UpperCAmelCase				( self							:	Dict				)   ->	Any:
							return (self.codebook_size["height"], self.codebook_size["width"])




@require_torch
@require_vision
class        snake_case__				(_UpperCamelCase       ,			unittest.TestCase  ):
				"""simple docstring"""



				SCREAMING_SNAKE_CASE_			:				List[str]									=   FlavaImageProcessor if is_vision_available() else None
				SCREAMING_SNAKE_CASE_			:				Tuple									=   None





				def 				__UpperCAmelCase				( self							:	Optional[Any]				)   ->	Any:
							a       =     FlavaImageProcessingTester(self				)





				@property
				def 				__UpperCAmelCase				( self							:	List[str]				)   ->	List[str]:
							return self.image_processor_tester.prepare_image_processor_dict()





				def 				__UpperCAmelCase				( self							:	Union[str, Any]				)   ->	str:
							a       =     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 				__UpperCAmelCase				( self							:	Optional[Any]				)   ->	Optional[Any]:
							a       =     self.image_processing_class.from_dict(self.image_processor_dict				)
							self.assertEqual(image_processor.size   , {"height": 2_24, "width": 2_24}				)
							self.assertEqual(image_processor.crop_size   , {"height": 2_24, "width": 2_24}				)
							self.assertEqual(image_processor.codebook_size   , {"height": 1_12, "width": 1_12}				)
							self.assertEqual(image_processor.codebook_crop_size   , {"height": 1_12, "width": 1_12}				)

							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 				__UpperCAmelCase				( self							:	Optional[int]				)   ->	Union[str, Any]:
							pass





				def 				__UpperCAmelCase				( self							:	List[str]				)   ->	Optional[Any]:
							# Initialize image_processing
							a       =     self.image_processing_class(**self.image_processor_dict				)
							# create random PIL images
							a       =     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
							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(__UpperCAmelCase   , 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 				__UpperCAmelCase				( self							:	Tuple   , __lowerCamelCase							:	Optional[Any]   , __lowerCamelCase							:	Optional[int]				)   ->	List[Any]:
							# Initialize image_processing
							a       =     self.image_processing_class(**self.image_processor_dict				)
							# create random tensors
							a       =     prepare_image_inputs(self.image_processor_tester   , equal_resolution=__UpperCAmelCase   , **__UpperCAmelCase				)
							for image in image_inputs:
										self.assertIsInstance(__UpperCAmelCase   , __UpperCAmelCase				)

							# 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(__UpperCAmelCase   , return_image_mask=__UpperCAmelCase   , 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(__UpperCAmelCase   , 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(__UpperCAmelCase   , return_image_mask=__UpperCAmelCase   , 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 				__UpperCAmelCase				( self							:	Dict				)   ->	Optional[Any]:
							self._test_call_framework(np.ndarray   , prepare_kwargs={"numpify": True}				)





				def 				__UpperCAmelCase				( self							:	List[Any]				)   ->	str:
							self._test_call_framework(torch.Tensor   , prepare_kwargs={"torchify": True}				)





				def 				__UpperCAmelCase				( self							:	Any				)   ->	Union[str, Any]:
							# Initialize image_processing
							random.seed(12_34				)
							a       =     self.image_processing_class(**self.image_processor_dict				)
							a       =     prepare_image_inputs(self.image_processor_tester   , equal_resolution=__UpperCAmelCase   , torchify=__UpperCAmelCase				)

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





				def 				__UpperCAmelCase				( self							:	List[Any]				)   ->	Optional[int]:
							# Initialize image_processing
							a       =     self.image_processing_class(**self.image_processor_dict				)
							# create random PIL images
							a       =     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
							a       =     image_processing(image_inputs[0]   , return_codebook_pixels=__UpperCAmelCase   , 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(__UpperCAmelCase   , return_codebook_pixels=__UpperCAmelCase   , 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,
							    )   , )








"""simple docstring"""


from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


__A					=			{
    'configuration_donut_swin': ['DONUT_SWIN_PRETRAINED_CONFIG_ARCHIVE_MAP', 'DonutSwinConfig'],
    'processing_donut': ['DonutProcessor'],
}

try:
			if not is_torch_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			__A					=			[
			    'DONUT_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST',
			    'DonutSwinModel',
			    'DonutSwinPreTrainedModel',
			]

try:
			if not is_vision_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			__A					=			['DonutFeatureExtractor']
			__A					=			['DonutImageProcessor']


if TYPE_CHECKING:
			from .configuration_donut_swin import DONUT_SWIN_PRETRAINED_CONFIG_ARCHIVE_MAP, DonutSwinConfig
			from .processing_donut import DonutProcessor

			try:
						if not is_torch_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .modeling_donut_swin import (
						    DONUT_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST,
						    DonutSwinModel,
						    DonutSwinPreTrainedModel,
						)

			try:
						if not is_vision_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .feature_extraction_donut import DonutFeatureExtractor
						from .image_processing_donut import DonutImageProcessor

else:
			import sys

			__A					=			_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)



