
"""simple docstring"""



import gc
import unittest

import torch
from parameterized import parameterized

from diffusers import AutoencoderKL
from diffusers.utils import floats_tensor, load_hf_numpy, require_torch_gpu, slow, torch_all_close, torch_device
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import enable_full_determinism

from .test_modeling_common import ModelTesterMixin, UNetTesterMixin


enable_full_determinism()
class        _SCREAMING_SNAKE_CASE  (  lowercase__      ,				lowercase__      ,				unittest.TestCase							):






				'''simple docstring'''



				SCREAMING_SNAKE_CASE_:							Any							=					AutoencoderKL
				SCREAMING_SNAKE_CASE_:							Optional[int]							=					"sample"
				SCREAMING_SNAKE_CASE_:							Dict							=					1e-2


				@property
				def 				__lowerCamelCase	(					self	:			Union[str, Any]  )		->  Any:







											"""simple docstring"""




											_lowerCAmelCase							=			4
											_lowerCAmelCase							=			3
											_lowerCAmelCase							=			(32, 32)

											_lowerCAmelCase							=			floats_tensor((batch_size, num_channels) + sizes  ).to(UpperCAmelCase_  )

											return {"sample": image}


				@property
				def 				__lowerCamelCase	(					self	:			Any  )		->  Optional[Any]:







											"""simple docstring"""




											return (3, 32, 32)


				@property
				def 				__lowerCamelCase	(					self	:			Any  )		->  List[str]:







											"""simple docstring"""




											return (3, 32, 32)


				def 				__lowerCamelCase	(					self	:			str  )		->  Optional[Any]:







											"""simple docstring"""




											_lowerCAmelCase							=			{
											    "block_out_channels": [32, 64],
											    "in_channels": 3,
											    "out_channels": 3,
											    "down_block_types": ["DownEncoderBlock2D", "DownEncoderBlock2D"],
											    "up_block_types": ["UpDecoderBlock2D", "UpDecoderBlock2D"],
											    "latent_channels": 4,
											}
											_lowerCAmelCase							=			self.dummy_input
											return init_dict, inputs_dict


				def 				__lowerCamelCase	(					self	:			Optional[int]  )		->  List[str]:







											"""simple docstring"""




											pass


				def 				__lowerCamelCase	(					self	:			List[Any]  )		->  List[str]:







											"""simple docstring"""




											pass


				@unittest.skipIf(torch_device == 'mps'				,     'Gradient checkpointing skipped on MPS'  )
				def 				__lowerCamelCase	(					self	:			Dict  )		->  int:







											"""simple docstring"""




											_lowerCAmelCase							=			self.prepare_init_args_and_inputs_for_common()
											_lowerCAmelCase							=			self.model_class(**UpperCAmelCase_  )
											model.to(UpperCAmelCase_  )

											assert not model.is_gradient_checkpointing and model.training

											_lowerCAmelCase							=			model(**UpperCAmelCase_  ).sample
											# run the backwards pass on the model. For backwards pass, for simplicity purpose,
											# we won't calculate the loss and rather backprop on out.sum()
											model.zero_grad()

											_lowerCAmelCase							=			torch.randn_like(UpperCAmelCase_  )
											_lowerCAmelCase							=			(out - labels).mean()
											loss.backward()

											# re-instantiate the model now enabling gradient checkpointing
											_lowerCAmelCase							=			self.model_class(**UpperCAmelCase_  )
											# clone model
											model_a.load_state_dict(model.state_dict()  )
											model_a.to(UpperCAmelCase_  )
											model_a.enable_gradient_checkpointing()

											assert model_a.is_gradient_checkpointing and model_a.training

											_lowerCAmelCase							=			model_a(**UpperCAmelCase_  ).sample
											# run the backwards pass on the model. For backwards pass, for simplicity purpose,
											# we won't calculate the loss and rather backprop on out.sum()
											model_a.zero_grad()
											_lowerCAmelCase							=			(out_a - labels).mean()
											loss_a.backward()

											# compare the output and parameters gradients
											self.assertTrue((loss - loss_a).abs() < 1E-5  )
											_lowerCAmelCase							=			dict(model.named_parameters()  )
											_lowerCAmelCase							=			dict(model_a.named_parameters()  )
											for name, param in named_params.items():
																		self.assertTrue(torch_all_close(param.grad.data				,     named_params_a[name].grad.data				,     atol=5E-5  )  )


				def 				__lowerCamelCase	(					self	:			Dict  )		->  List[Any]:







											"""simple docstring"""




											_lowerCAmelCase							=			AutoencoderKL.from_pretrained('fusing/autoencoder-kl-dummy'				,     output_loading_info=UpperCAmelCase_  )
											self.assertIsNotNone(UpperCAmelCase_  )
											self.assertEqual(len(loading_info['missing_keys']  )				,     0  )

											model.to(UpperCAmelCase_  )
											_lowerCAmelCase							=			model(**self.dummy_input  )

											assert image is not None, "Make sure output is not None"







				def 				__lowerCamelCase	(					self	:			List[str]  )		->  Optional[Any]:







											"""simple docstring"""




											_lowerCAmelCase							=			AutoencoderKL.from_pretrained('fusing/autoencoder-kl-dummy'  )
											_lowerCAmelCase							=			model.to(UpperCAmelCase_  )
											model.eval()

											if torch_device == "mps":
																		_lowerCAmelCase							=			torch.manual_seed(0  )
											else:
																		_lowerCAmelCase							=			torch.Generator(device=UpperCAmelCase_  ).manual_seed(0  )

											_lowerCAmelCase							=			torch.randn(
											    1				,     model.config.in_channels				,     model.config.sample_size				,     model.config.sample_size				,     generator=torch.manual_seed(0  )				,     )
											_lowerCAmelCase							=			image.to(UpperCAmelCase_  )
											with torch.no_grad():
																		_lowerCAmelCase							=			model(UpperCAmelCase_				,     sample_posterior=UpperCAmelCase_				,     generator=UpperCAmelCase_  ).sample

											_lowerCAmelCase							=			output[0, -1, -3:, -3:].flatten().cpu()

											# Since the VAE Gaussian prior's generator is seeded on the appropriate device,
											# the expected output slices are not the same for CPU and GPU.
											if torch_device == "mps":
																		_lowerCAmelCase							=			torch.tensor(
																		    [
																		        -4.0_0_7_8E-0_1,
																		        -3.8_3_2_3E-0_4,
																		        -1.2_6_8_1E-0_1,
																		        -1.1_4_6_2E-0_1,
																		        2.0_0_9_5E-0_1,
																		        1.0_8_9_3E-0_1,
																		        -8.8_2_4_7E-0_2,
																		        -3.0_3_6_1E-0_1,
																		        -9.8_6_4_4E-0_3,
																		    ]  )
											elif torch_device == "cpu":
																		_lowerCAmelCase							=			torch.tensor(
																		    [-0.1352, 0.0878, 0.0419, -0.0818, -0.1069, 0.0688, -0.1458, -0.4446, -0.0026]  )
											else:
																		_lowerCAmelCase							=			torch.tensor(
																		    [-0.2421, 0.4642, 0.2507, -0.0438, 0.0682, 0.3160, -0.2018, -0.0727, 0.2485]  )

											self.assertTrue(torch_all_close(UpperCAmelCase_				,     UpperCAmelCase_				,     rtol=1E-2  )  )






@slow
class        _SCREAMING_SNAKE_CASE  (  unittest.TestCase							):






				'''simple docstring'''



				def 				__lowerCamelCase	(					self	:			Tuple				,     UpperCAmelCase_	:			Union[str, Any]				,     UpperCAmelCase_	:			Optional[int]  )		->  int:







											"""simple docstring"""




											return F"""gaussian_noise_s={seed}_shape={'_'.join([str(UpperCAmelCase_  ) for s in shape]  )}.npy"""


				def 				__lowerCamelCase	(					self	:			Union[str, Any]  )		->  int:







											"""simple docstring"""




											super().tearDown()
											gc.collect()
											torch.cuda.empty_cache()


				def 				__lowerCamelCase	(					self	:			Dict				,     UpperCAmelCase_	:			Any=0				,     UpperCAmelCase_	:			int=(4, 3, 512, 512)				,     UpperCAmelCase_	:			Tuple=False  )		->  Dict:







											"""simple docstring"""




											_lowerCAmelCase							=			torch.floataa if fpaa else torch.floataa
											_lowerCAmelCase							=			torch.from_numpy(load_hf_numpy(self.get_file_format(UpperCAmelCase_				,     UpperCAmelCase_  )  )  ).to(UpperCAmelCase_  ).to(UpperCAmelCase_  )
											return image


				def 				__lowerCamelCase	(					self	:			Optional[int]				,     UpperCAmelCase_	:			Optional[Any]="CompVis/stable-diffusion-v1-4"				,     UpperCAmelCase_	:			str=False  )		->  Any:







											"""simple docstring"""




											_lowerCAmelCase							=			"fp16" if fpaa else None
											_lowerCAmelCase							=			torch.floataa if fpaa else torch.floataa

											_lowerCAmelCase							=			AutoencoderKL.from_pretrained(
											    UpperCAmelCase_				,     subfolder='vae'				,     torch_dtype=UpperCAmelCase_				,     revision=UpperCAmelCase_				,     )
											model.to(UpperCAmelCase_  ).eval()

											return model


				def 				__lowerCamelCase	(					self	:			Optional[int]				,     UpperCAmelCase_	:			Optional[int]=0  )		->  List[Any]:







											"""simple docstring"""




											if torch_device == "mps":
																		return torch.manual_seed(UpperCAmelCase_  )
											return torch.Generator(device=UpperCAmelCase_  ).manual_seed(UpperCAmelCase_  )


				@parameterized.expand(
				    [
				        # fmt: off
				        [33, [-0.1603, 0.9878, -0.0495, -0.0790, -0.2709, 0.8375, -0.2060, -0.0824], [-0.2395, 0.0098, 0.0102, -0.0709, -0.2840, -0.0274, -0.0718, -0.1824]],
				        [47, [-0.2376, 0.1168, 0.1332, -0.4840, -0.2508, -0.0791, -0.0493, -0.4089], [0.0350, 0.0847, 0.0467, 0.0344, -0.0842, -0.0547, -0.0633, -0.1131]],
				        # fmt: on
				    ]  )
				def 				__lowerCamelCase	(					self	:			Optional[int]				,     UpperCAmelCase_	:			str				,     UpperCAmelCase_	:			Optional[Any]				,     UpperCAmelCase_	:			Optional[int]  )		->  Optional[int]:







											"""simple docstring"""




											_lowerCAmelCase							=			self.get_sd_vae_model()
											_lowerCAmelCase							=			self.get_sd_image(UpperCAmelCase_  )
											_lowerCAmelCase							=			self.get_generator(UpperCAmelCase_  )

											with torch.no_grad():
																		_lowerCAmelCase							=			model(UpperCAmelCase_				,     generator=UpperCAmelCase_				,     sample_posterior=UpperCAmelCase_  ).sample

											assert sample.shape == image.shape

											_lowerCAmelCase							=			sample[-1, -2:, -2:, :2].flatten().float().cpu()
											_lowerCAmelCase							=			torch.tensor(expected_slice_mps if torch_device == 'mps' else expected_slice  )

											assert torch_all_close(UpperCAmelCase_				,     UpperCAmelCase_				,     atol=3E-3  )


				@parameterized.expand(
				    [
				        # fmt: off
				        [33, [-0.0513, 0.0289, 1.3799, 0.2166, -0.2573, -0.0871, 0.5103, -0.0999]],
				        [47, [-0.4128, -0.1320, -0.3704, 0.1965, -0.4116, -0.2332, -0.3340, 0.2247]],
				        # fmt: on
				    ]  )
				@require_torch_gpu
				def 				__lowerCamelCase	(					self	:			List[str]				,     UpperCAmelCase_	:			List[str]				,     UpperCAmelCase_	:			Any  )		->  Any:







											"""simple docstring"""




											_lowerCAmelCase							=			self.get_sd_vae_model(fpaa=UpperCAmelCase_  )
											_lowerCAmelCase							=			self.get_sd_image(UpperCAmelCase_				,     fpaa=UpperCAmelCase_  )
											_lowerCAmelCase							=			self.get_generator(UpperCAmelCase_  )

											with torch.no_grad():
																		_lowerCAmelCase							=			model(UpperCAmelCase_				,     generator=UpperCAmelCase_				,     sample_posterior=UpperCAmelCase_  ).sample

											assert sample.shape == image.shape

											_lowerCAmelCase							=			sample[-1, -2:, :2, -2:].flatten().float().cpu()
											_lowerCAmelCase							=			torch.tensor(UpperCAmelCase_  )

											assert torch_all_close(UpperCAmelCase_				,     UpperCAmelCase_				,     atol=1E-2  )


				@parameterized.expand(
				    [
				        # fmt: off
				        [33, [-0.1609, 0.9866, -0.0487, -0.0777, -0.2716, 0.8368, -0.2055, -0.0814], [-0.2395, 0.0098, 0.0102, -0.0709, -0.2840, -0.0274, -0.0718, -0.1824]],
				        [47, [-0.2377, 0.1147, 0.1333, -0.4841, -0.2506, -0.0805, -0.0491, -0.4085], [0.0350, 0.0847, 0.0467, 0.0344, -0.0842, -0.0547, -0.0633, -0.1131]],
				        # fmt: on
				    ]  )
				def 				__lowerCamelCase	(					self	:			List[Any]				,     UpperCAmelCase_	:			Tuple				,     UpperCAmelCase_	:			Optional[int]				,     UpperCAmelCase_	:			Union[str, Any]  )		->  Union[str, Any]:







											"""simple docstring"""




											_lowerCAmelCase							=			self.get_sd_vae_model()
											_lowerCAmelCase							=			self.get_sd_image(UpperCAmelCase_  )

											with torch.no_grad():
																		_lowerCAmelCase							=			model(UpperCAmelCase_  ).sample

											assert sample.shape == image.shape

											_lowerCAmelCase							=			sample[-1, -2:, -2:, :2].flatten().float().cpu()
											_lowerCAmelCase							=			torch.tensor(expected_slice_mps if torch_device == 'mps' else expected_slice  )

											assert torch_all_close(UpperCAmelCase_				,     UpperCAmelCase_				,     atol=3E-3  )


				@parameterized.expand(
				    [
				        # fmt: off
				        [13, [-0.2051, -0.1803, -0.2311, -0.2114, -0.3292, -0.3574, -0.2953, -0.3323]],
				        [37, [-0.2632, -0.2625, -0.2199, -0.2741, -0.4539, -0.4990, -0.3720, -0.4925]],
				        # fmt: on
				    ]  )
				@require_torch_gpu
				def 				__lowerCamelCase	(					self	:			str				,     UpperCAmelCase_	:			int				,     UpperCAmelCase_	:			int  )		->  str:







											"""simple docstring"""




											_lowerCAmelCase							=			self.get_sd_vae_model()
											_lowerCAmelCase							=			self.get_sd_image(UpperCAmelCase_				,     shape=(3, 4, 64, 64)  )

											with torch.no_grad():
																		_lowerCAmelCase							=			model.decode(UpperCAmelCase_  ).sample

											assert list(sample.shape  ) == [3, 3, 512, 512]

											_lowerCAmelCase							=			sample[-1, -2:, :2, -2:].flatten().cpu()
											_lowerCAmelCase							=			torch.tensor(UpperCAmelCase_  )

											assert torch_all_close(UpperCAmelCase_				,     UpperCAmelCase_				,     atol=1E-3  )


				@parameterized.expand(
				    [
				        # fmt: off
				        [27, [-0.0369, 0.0207, -0.0776, -0.0682, -0.1747, -0.1930, -0.1465, -0.2039]],
				        [16, [-0.1628, -0.2134, -0.2747, -0.2642, -0.3774, -0.4404, -0.3687, -0.4277]],
				        # fmt: on
				    ]  )
				@require_torch_gpu
				def 				__lowerCamelCase	(					self	:			Any				,     UpperCAmelCase_	:			Tuple				,     UpperCAmelCase_	:			Any  )		->  str:







											"""simple docstring"""




											_lowerCAmelCase							=			self.get_sd_vae_model(fpaa=UpperCAmelCase_  )
											_lowerCAmelCase							=			self.get_sd_image(UpperCAmelCase_				,     shape=(3, 4, 64, 64)				,     fpaa=UpperCAmelCase_  )

											with torch.no_grad():
																		_lowerCAmelCase							=			model.decode(UpperCAmelCase_  ).sample

											assert list(sample.shape  ) == [3, 3, 512, 512]

											_lowerCAmelCase							=			sample[-1, -2:, :2, -2:].flatten().float().cpu()
											_lowerCAmelCase							=			torch.tensor(UpperCAmelCase_  )

											assert torch_all_close(UpperCAmelCase_				,     UpperCAmelCase_				,     atol=5E-3  )


				@parameterized.expand([(13,), (16,), (27,)]  )
				@require_torch_gpu
				@unittest.skipIf(not is_xformers_available()				,     reason='xformers is not required when using PyTorch 2.0.'  )
				def 				__lowerCamelCase	(					self	:			Tuple				,     UpperCAmelCase_	:			Optional[int]  )		->  Optional[int]:







											"""simple docstring"""




											_lowerCAmelCase							=			self.get_sd_vae_model(fpaa=UpperCAmelCase_  )
											_lowerCAmelCase							=			self.get_sd_image(UpperCAmelCase_				,     shape=(3, 4, 64, 64)				,     fpaa=UpperCAmelCase_  )

											with torch.no_grad():
																		_lowerCAmelCase							=			model.decode(UpperCAmelCase_  ).sample

											model.enable_xformers_memory_efficient_attention()
											with torch.no_grad():
																		_lowerCAmelCase							=			model.decode(UpperCAmelCase_  ).sample

											assert list(sample.shape  ) == [3, 3, 512, 512]

											assert torch_all_close(UpperCAmelCase_				,     UpperCAmelCase_				,     atol=1E-1  )


				@parameterized.expand([(13,), (16,), (37,)]  )
				@require_torch_gpu
				@unittest.skipIf(not is_xformers_available()				,     reason='xformers is not required when using PyTorch 2.0.'  )
				def 				__lowerCamelCase	(					self	:			str				,     UpperCAmelCase_	:			List[str]  )		->  Union[str, Any]:







											"""simple docstring"""




											_lowerCAmelCase							=			self.get_sd_vae_model()
											_lowerCAmelCase							=			self.get_sd_image(UpperCAmelCase_				,     shape=(3, 4, 64, 64)  )

											with torch.no_grad():
																		_lowerCAmelCase							=			model.decode(UpperCAmelCase_  ).sample

											model.enable_xformers_memory_efficient_attention()
											with torch.no_grad():
																		_lowerCAmelCase							=			model.decode(UpperCAmelCase_  ).sample

											assert list(sample.shape  ) == [3, 3, 512, 512]

											assert torch_all_close(UpperCAmelCase_				,     UpperCAmelCase_				,     atol=1E-2  )







				@parameterized.expand(
				    [
				        # fmt: off
				        [33, [-0.3001, 0.0918, -2.6984, -3.9720, -3.2099, -5.0353, 1.7338, -0.2065, 3.4267]],
				        [47, [-1.5030, -4.3871, -6.0355, -9.1157, -1.6661, -2.7853, 2.1607, -5.0823, 2.5633]],
				        # fmt: on
				    ]  )
				def 				__lowerCamelCase	(					self	:			Any				,     UpperCAmelCase_	:			int				,     UpperCAmelCase_	:			List[Any]  )		->  List[Any]:







											"""simple docstring"""




											_lowerCAmelCase							=			self.get_sd_vae_model()
											_lowerCAmelCase							=			self.get_sd_image(UpperCAmelCase_  )
											_lowerCAmelCase							=			self.get_generator(UpperCAmelCase_  )

											with torch.no_grad():
																		_lowerCAmelCase							=			model.encode(UpperCAmelCase_  ).latent_dist
																		_lowerCAmelCase							=			dist.sample(generator=UpperCAmelCase_  )

											assert list(sample.shape  ) == [image.shape[0], 4] + [i // 8 for i in image.shape[2:]]

											_lowerCAmelCase							=			sample[0, -1, -3:, -3:].flatten().cpu()
											_lowerCAmelCase							=			torch.tensor(UpperCAmelCase_  )

											_lowerCAmelCase							=			3E-3 if torch_device != "mps" else 1E-2
											assert torch_all_close(UpperCAmelCase_				,     UpperCAmelCase_				,     atol=UpperCAmelCase_  )








"""simple docstring"""



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


if is_torch_available():
	import torch

if is_vision_available():
	from PIL import Image

	from transformers import ChineseCLIPImageProcessor
class        _SCREAMING_SNAKE_CASE  (  unittest.TestCase							):






				'''simple docstring'''



				def __init__(					self	:			Optional[Any]				,     UpperCAmelCase_	:			int				,     UpperCAmelCase_	:			Dict=7				,     UpperCAmelCase_	:			List[Any]=3				,     UpperCAmelCase_	:			Tuple=18				,     UpperCAmelCase_	:			List[str]=30				,     UpperCAmelCase_	:			Union[str, Any]=400				,     UpperCAmelCase_	:			Optional[Any]=True				,     UpperCAmelCase_	:			Tuple=None				,     UpperCAmelCase_	:			Optional[int]=True				,     UpperCAmelCase_	:			Any=None				,     UpperCAmelCase_	:			Tuple=True				,     UpperCAmelCase_	:			List[Any]=[0.48145466, 0.4578275, 0.40821073]				,     UpperCAmelCase_	:			List[Any]=[0.26862954, 0.26130258, 0.27577711]				,     UpperCAmelCase_	:			Optional[int]=True				,     )		->  Tuple:







											"""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': 18, 'width': 18}
											_lowerCAmelCase  	=			parent
											_lowerCAmelCase  	=			batch_size
											_lowerCAmelCase  	=			num_channels
											_lowerCAmelCase  	=			image_size
											_lowerCAmelCase  	=			min_resolution
											_lowerCAmelCase  	=			max_resolution
											_lowerCAmelCase  	=			do_resize
											_lowerCAmelCase  	=			size
											_lowerCAmelCase  	=			do_center_crop
											_lowerCAmelCase  	=			crop_size
											_lowerCAmelCase  	=			do_normalize
											_lowerCAmelCase  	=			image_mean
											_lowerCAmelCase  	=			image_std
											_lowerCAmelCase  	=			do_convert_rgb


				def 				__lowerCamelCase	(					self	:			Optional[int]  )		->  int:







											"""simple docstring"""




											return {
											    "do_resize": self.do_resize,
											    "size": self.size,
											    "do_center_crop": self.do_center_crop,
											    "crop_size": self.crop_size,
											    "do_normalize": self.do_normalize,
											    "image_mean": self.image_mean,
											    "image_std": self.image_std,
											    "do_convert_rgb": self.do_convert_rgb,
											}







				def 				__lowerCamelCase	(					self	:			Dict				,     UpperCAmelCase_	:			Dict=False				,     UpperCAmelCase_	:			int=False				,     UpperCAmelCase_	:			Dict=False  )		->  str:







											"""simple docstring"""




											assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"

											if equal_resolution:
																		_lowerCAmelCase  	=			[]
																		for i in range(self.batch_size  ):
																									image_inputs.append(
																									    np.random.randint(
																									        255				,     size=(self.num_channels, self.max_resolution, self.max_resolution)				,     dtype=np.uinta  )  )
											else:
																		_lowerCAmelCase  	=			[]
																		for i in range(self.batch_size  ):
																									_lowerCAmelCase	,		_lowerCAmelCase  	=			np.random.choice(np.arange(self.min_resolution				,     self.max_resolution  )				,     2  )
																									image_inputs.append(np.random.randint(255				,     size=(self.num_channels, width, height)				,     dtype=np.uinta  )  )

											if not numpify and not torchify:
																		# PIL expects the channel dimension as last dimension
																		_lowerCAmelCase  	=			[Image.fromarray(np.moveaxis(UpperCAmelCase_				,     0				,     -1  )  ) for x in image_inputs]

											if torchify:
																		_lowerCAmelCase  	=			[torch.from_numpy(UpperCAmelCase_  ) for x in image_inputs]

											return image_inputs






@require_torch
@require_vision
class        _SCREAMING_SNAKE_CASE  (  UpperCAmelCase      ,				unittest.TestCase							):






				'''simple docstring'''



				SCREAMING_SNAKE_CASE_:							List[Any]							=					ChineseCLIPImageProcessor if is_vision_available() else None


				def 				__lowerCamelCase	(					self	:			Union[str, Any]  )		->  Optional[Any]:







											"""simple docstring"""




											_lowerCAmelCase  	=			ChineseCLIPImageProcessingTester(self				,     do_center_crop=UpperCAmelCase_  )


				@property
				def 				__lowerCamelCase	(					self	:			Union[str, Any]  )		->  int:







											"""simple docstring"""




											return self.image_processor_tester.prepare_image_processor_dict()


				def 				__lowerCamelCase	(					self	:			List[str]  )		->  Optional[Any]:







											"""simple docstring"""




											_lowerCAmelCase  	=			self.image_processing_class(**self.image_processor_dict  )
											self.assertTrue(hasattr(UpperCAmelCase_				,     'do_resize'  )  )
											self.assertTrue(hasattr(UpperCAmelCase_				,     'size'  )  )
											self.assertTrue(hasattr(UpperCAmelCase_				,     'do_center_crop'  )  )
											self.assertTrue(hasattr(UpperCAmelCase_				,     'center_crop'  )  )
											self.assertTrue(hasattr(UpperCAmelCase_				,     'do_normalize'  )  )
											self.assertTrue(hasattr(UpperCAmelCase_				,     'image_mean'  )  )
											self.assertTrue(hasattr(UpperCAmelCase_				,     'image_std'  )  )
											self.assertTrue(hasattr(UpperCAmelCase_				,     'do_convert_rgb'  )  )


				def 				__lowerCamelCase	(					self	:			Dict  )		->  Tuple:







											"""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': 18, 'width': 18}  )

											_lowerCAmelCase  	=			self.image_processing_class.from_dict(self.image_processor_dict				,     size=42				,     crop_size=84  )
											self.assertEqual(image_processor.size				,     {'shortest_edge': 42}  )
											self.assertEqual(image_processor.crop_size				,     {'height': 84, 'width': 84}  )


				def 				__lowerCamelCase	(					self	:			Union[str, Any]  )		->  List[str]:







											"""simple docstring"""




											pass


				def 				__lowerCamelCase	(					self	:			Optional[Any]  )		->  Optional[Any]:







											"""simple docstring"""




											_lowerCAmelCase  	=			self.image_processing_class(**self.image_processor_dict  )
											# create random PIL images
											_lowerCAmelCase  	=			self.image_processor_tester.prepare_inputs(equal_resolution=UpperCAmelCase_  )
											for image in image_inputs:
																		self.assertIsInstance(UpperCAmelCase_				,     Image.Image  )

											# Test not batched input
											_lowerCAmelCase  	=			image_processing(image_inputs[0]				,     return_tensors='pt'  ).pixel_values
											self.assertEqual(
											    encoded_images.shape				,     (
											        1,
											        self.image_processor_tester.num_channels,
											        self.image_processor_tester.crop_size['height'],
											        self.image_processor_tester.crop_size['width'],
											    )				,     )

											# Test batched
											_lowerCAmelCase  	=			image_processing(UpperCAmelCase_				,     return_tensors='pt'  ).pixel_values
											self.assertEqual(
											    encoded_images.shape				,     (
											        self.image_processor_tester.batch_size,
											        self.image_processor_tester.num_channels,
											        self.image_processor_tester.crop_size['height'],
											        self.image_processor_tester.crop_size['width'],
											    )				,     )


				def 				__lowerCamelCase	(					self	:			List[str]  )		->  int:







											"""simple docstring"""




											_lowerCAmelCase  	=			self.image_processing_class(**self.image_processor_dict  )
											# create random numpy tensors
											_lowerCAmelCase  	=			self.image_processor_tester.prepare_inputs(equal_resolution=UpperCAmelCase_				,     numpify=UpperCAmelCase_  )
											for image in image_inputs:
																		self.assertIsInstance(UpperCAmelCase_				,     np.ndarray  )

											# Test not batched input
											_lowerCAmelCase  	=			image_processing(image_inputs[0]				,     return_tensors='pt'  ).pixel_values
											self.assertEqual(
											    encoded_images.shape				,     (
											        1,
											        self.image_processor_tester.num_channels,
											        self.image_processor_tester.crop_size['height'],
											        self.image_processor_tester.crop_size['width'],
											    )				,     )

											# Test batched
											_lowerCAmelCase  	=			image_processing(UpperCAmelCase_				,     return_tensors='pt'  ).pixel_values
											self.assertEqual(
											    encoded_images.shape				,     (
											        self.image_processor_tester.batch_size,
											        self.image_processor_tester.num_channels,
											        self.image_processor_tester.crop_size['height'],
											        self.image_processor_tester.crop_size['width'],
											    )				,     )







				def 				__lowerCamelCase	(					self	:			List[Any]  )		->  Dict:







											"""simple docstring"""




											_lowerCAmelCase  	=			self.image_processing_class(**self.image_processor_dict  )
											# create random PyTorch tensors
											_lowerCAmelCase  	=			self.image_processor_tester.prepare_inputs(equal_resolution=UpperCAmelCase_				,     torchify=UpperCAmelCase_  )
											for image in image_inputs:
																		self.assertIsInstance(UpperCAmelCase_				,     torch.Tensor  )

											# Test not batched input
											_lowerCAmelCase  	=			image_processing(image_inputs[0]				,     return_tensors='pt'  ).pixel_values
											self.assertEqual(
											    encoded_images.shape				,     (
											        1,
											        self.image_processor_tester.num_channels,
											        self.image_processor_tester.crop_size['height'],
											        self.image_processor_tester.crop_size['width'],
											    )				,     )

											# Test batched
											_lowerCAmelCase  	=			image_processing(UpperCAmelCase_				,     return_tensors='pt'  ).pixel_values
											self.assertEqual(
											    encoded_images.shape				,     (
											        self.image_processor_tester.batch_size,
											        self.image_processor_tester.num_channels,
											        self.image_processor_tester.crop_size['height'],
											        self.image_processor_tester.crop_size['width'],
											    )				,     )






@require_torch
@require_vision
class        _SCREAMING_SNAKE_CASE  (  UpperCAmelCase      ,				unittest.TestCase							):






				'''simple docstring'''



				SCREAMING_SNAKE_CASE_:							str							=					ChineseCLIPImageProcessor if is_vision_available() else None


				def 				__lowerCamelCase	(					self	:			List[str]  )		->  List[Any]:







											"""simple docstring"""




											_lowerCAmelCase  	=			ChineseCLIPImageProcessingTester(self				,     num_channels=4				,     do_center_crop=UpperCAmelCase_  )
											_lowerCAmelCase  	=			3


				@property
				def 				__lowerCamelCase	(					self	:			Union[str, Any]  )		->  Dict:







											"""simple docstring"""




											return self.image_processor_tester.prepare_image_processor_dict()


				def 				__lowerCamelCase	(					self	:			Optional[Any]  )		->  Dict:







											"""simple docstring"""




											_lowerCAmelCase  	=			self.image_processing_class(**self.image_processor_dict  )
											self.assertTrue(hasattr(UpperCAmelCase_				,     'do_resize'  )  )
											self.assertTrue(hasattr(UpperCAmelCase_				,     'size'  )  )
											self.assertTrue(hasattr(UpperCAmelCase_				,     'do_center_crop'  )  )
											self.assertTrue(hasattr(UpperCAmelCase_				,     'center_crop'  )  )
											self.assertTrue(hasattr(UpperCAmelCase_				,     'do_normalize'  )  )
											self.assertTrue(hasattr(UpperCAmelCase_				,     'image_mean'  )  )
											self.assertTrue(hasattr(UpperCAmelCase_				,     'image_std'  )  )
											self.assertTrue(hasattr(UpperCAmelCase_				,     'do_convert_rgb'  )  )


				def 				__lowerCamelCase	(					self	:			List[Any]  )		->  Optional[int]:







											"""simple docstring"""




											pass







				def 				__lowerCamelCase	(					self	:			int  )		->  List[Any]:







											"""simple docstring"""




											_lowerCAmelCase  	=			self.image_processing_class(**self.image_processor_dict  )
											# create random PIL images
											_lowerCAmelCase  	=			self.image_processor_tester.prepare_inputs(equal_resolution=UpperCAmelCase_  )
											for image in image_inputs:
																		self.assertIsInstance(UpperCAmelCase_				,     Image.Image  )

											# Test not batched input
											_lowerCAmelCase  	=			image_processing(image_inputs[0]				,     return_tensors='pt'  ).pixel_values
											self.assertEqual(
											    encoded_images.shape				,     (
											        1,
											        self.expected_encoded_image_num_channels,
											        self.image_processor_tester.crop_size['height'],
											        self.image_processor_tester.crop_size['width'],
											    )				,     )

											# Test batched
											_lowerCAmelCase  	=			image_processing(UpperCAmelCase_				,     return_tensors='pt'  ).pixel_values
											self.assertEqual(
											    encoded_images.shape				,     (
											        self.image_processor_tester.batch_size,
											        self.expected_encoded_image_num_channels,
											        self.image_processor_tester.crop_size['height'],
											        self.image_processor_tester.crop_size['width'],
											    )				,     )






