





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_video_inputs


if is_torch_available():
	import torch

if is_vision_available():
	from PIL import Image

	from transformers import VivitImageProcessor




class 	UpperCamelCase_							(  unittest.TestCase     ):


							def __init__(				self     :str				,					__A     :List[Any]				,					__A     :Optional[Any]=7				,					__A     :int=3				,					__A     :int=10				,					__A     :Dict=18				,					__A     :str=30				,					__A     :Any=400				,					__A     :Dict=True				,					__A     :Any=None				,					__A     :List[str]=True				,					__A     :Dict=[0.5, 0.5, 0.5]				,					__A     :List[str]=[0.5, 0.5, 0.5]				,					__A     :List[str]=None				,					) -> List[Any]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   size if size is not None else {"""shortest_edge""": 18}
									SCREAMING_SNAKE_CASE__								=   crop_size if crop_size is not None else {"""height""": 18, """width""": 18}

									SCREAMING_SNAKE_CASE__								=   parent
									SCREAMING_SNAKE_CASE__								=   batch_size
									SCREAMING_SNAKE_CASE__								=   num_channels
									SCREAMING_SNAKE_CASE__								=   num_frames
									SCREAMING_SNAKE_CASE__								=   image_size
									SCREAMING_SNAKE_CASE__								=   min_resolution
									SCREAMING_SNAKE_CASE__								=   max_resolution
									SCREAMING_SNAKE_CASE__								=   do_resize
									SCREAMING_SNAKE_CASE__								=   size
									SCREAMING_SNAKE_CASE__								=   do_normalize
									SCREAMING_SNAKE_CASE__								=   image_mean
									SCREAMING_SNAKE_CASE__								=   image_std
									SCREAMING_SNAKE_CASE__								=   crop_size


							def   _snake_case	(				self     :Tuple		) -> str:



									"""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,
									    "crop_size": self.crop_size,
									}




@require_torch
@require_vision
class 	UpperCamelCase_							(  UpperCamelCase__					,	unittest.TestCase     ):
							lowerCamelCase_							     =       VivitImageProcessor if is_vision_available() else None


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



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   VivitImageProcessingTester(self		)


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



									"""simple docstring"""



									return self.image_processor_tester.prepare_image_processor_dict()


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



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   self.image_processing_class(**self.image_processor_dict		)
									self.assertTrue(hasattr(__A				,					"""image_mean"""		)		)
									self.assertTrue(hasattr(__A				,					"""image_std"""		)		)
									self.assertTrue(hasattr(__A				,					"""do_normalize"""		)		)
									self.assertTrue(hasattr(__A				,					"""do_resize"""		)		)
									self.assertTrue(hasattr(__A				,					"""do_center_crop"""		)		)
									self.assertTrue(hasattr(__A				,					"""size"""		)		)


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



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   self.image_processing_class.from_dict(self.image_processor_dict		)
									self.assertEqual(image_processor.size				,					{"""shortest_edge""": 18}		)
									self.assertEqual(image_processor.crop_size				,					{"""height""": 18, """width""": 18}		)

									SCREAMING_SNAKE_CASE__								=   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   _snake_case	(				self     :List[Any]		) -> Optional[int]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   self.image_processing_class(**self.image_processor_dict		)
									# create random PIL videos
									SCREAMING_SNAKE_CASE__								=   prepare_video_inputs(self.image_processor_tester				,					equal_resolution=__A		)
									for video in video_inputs:
											self.assertIsInstance(__A				,					__A		)
											self.assertIsInstance(video[0]				,					Image.Image		)

									# Test not batched input
									SCREAMING_SNAKE_CASE__								=   image_processing(video_inputs[0]				,					return_tensors="""pt"""		).pixel_values
									self.assertEqual(
									    encoded_videos.shape				,					(
									        1,
									        self.image_processor_tester.num_frames,
									        self.image_processor_tester.num_channels,
									        self.image_processor_tester.crop_size["""height"""],
									        self.image_processor_tester.crop_size["""width"""],
									    )				,					)

									# Test batched
									SCREAMING_SNAKE_CASE__								=   image_processing(__A				,					return_tensors="""pt"""		).pixel_values
									self.assertEqual(
									    encoded_videos.shape				,					(
									        self.image_processor_tester.batch_size,
									        self.image_processor_tester.num_frames,
									        self.image_processor_tester.num_channels,
									        self.image_processor_tester.crop_size["""height"""],
									        self.image_processor_tester.crop_size["""width"""],
									    )				,					)


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



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   self.image_processing_class(**self.image_processor_dict		)
									# create random numpy tensors
									SCREAMING_SNAKE_CASE__								=   prepare_video_inputs(self.image_processor_tester				,					equal_resolution=__A				,					numpify=__A		)
									for video in video_inputs:
											self.assertIsInstance(__A				,					__A		)
											self.assertIsInstance(video[0]				,					np.ndarray		)

									# Test not batched input
									SCREAMING_SNAKE_CASE__								=   image_processing(video_inputs[0]				,					return_tensors="""pt"""		).pixel_values
									self.assertEqual(
									    encoded_videos.shape				,					(
									        1,
									        self.image_processor_tester.num_frames,
									        self.image_processor_tester.num_channels,
									        self.image_processor_tester.crop_size["""height"""],
									        self.image_processor_tester.crop_size["""width"""],
									    )				,					)

									# Test batched
									SCREAMING_SNAKE_CASE__								=   image_processing(__A				,					return_tensors="""pt"""		).pixel_values
									self.assertEqual(
									    encoded_videos.shape				,					(
									        self.image_processor_tester.batch_size,
									        self.image_processor_tester.num_frames,
									        self.image_processor_tester.num_channels,
									        self.image_processor_tester.crop_size["""height"""],
									        self.image_processor_tester.crop_size["""width"""],
									    )				,					)


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



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   self.image_processing_class(**self.image_processor_dict		)
									# create random PyTorch tensors
									SCREAMING_SNAKE_CASE__								=   prepare_video_inputs(self.image_processor_tester				,					equal_resolution=__A				,					torchify=__A		)
									for video in video_inputs:
											self.assertIsInstance(__A				,					__A		)
											self.assertIsInstance(video[0]				,					torch.Tensor		)

									# Test not batched input
									SCREAMING_SNAKE_CASE__								=   image_processing(video_inputs[0]				,					return_tensors="""pt"""		).pixel_values
									self.assertEqual(
									    encoded_videos.shape				,					(
									        1,
									        self.image_processor_tester.num_frames,
									        self.image_processor_tester.num_channels,
									        self.image_processor_tester.crop_size["""height"""],
									        self.image_processor_tester.crop_size["""width"""],
									    )				,					)

									# Test batched
									SCREAMING_SNAKE_CASE__								=   image_processing(__A				,					return_tensors="""pt"""		).pixel_values
									self.assertEqual(
									    encoded_videos.shape				,					(
									        self.image_processor_tester.batch_size,
									        self.image_processor_tester.num_frames,
									        self.image_processor_tester.num_channels,
									        self.image_processor_tester.crop_size["""height"""],
									        self.image_processor_tester.crop_size["""width"""],
									    )				,					)




'''simple docstring'''

import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel

from diffusers import DDIMScheduler, LDMPipeline, UNetaDModel, VQModel
from diffusers.utils.testing_utils import enable_full_determinism, require_torch, slow, torch_device


enable_full_determinism()

class       __magic_name__		(       unittest.TestCase  ):







							@property
							def 				__lowercase     (				self   :			int						):
									torch.manual_seed(0						)
									_a	: int								=				UNetaDModel(
									    block_out_channels=(32, 64)      ,layers_per_block=2      ,sample_size=32      ,in_channels=3      ,out_channels=3      ,down_block_types=('DownBlock2D', 'AttnDownBlock2D')      ,up_block_types=('AttnUpBlock2D', 'UpBlock2D')      ,)
									return model







							@property
							def 				__lowercase     (				self   :			Any						):
									torch.manual_seed(0						)
									_a	: int								=				VQModel(
									    block_out_channels=[32, 64]      ,in_channels=3      ,out_channels=3      ,down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D']      ,up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D']      ,latent_channels=3      ,)
									return model







							@property
							def 				__lowercase     (				self   :			Union[str, Any]						):
									torch.manual_seed(0						)
									_a	: Dict								=				CLIPTextConfig(
									    bos_token_id=0      ,eos_token_id=2      ,hidden_size=32      ,intermediate_size=37      ,layer_norm_eps=1E-05      ,num_attention_heads=4      ,num_hidden_layers=5      ,pad_token_id=1      ,vocab_size=1000      ,)
									return CLIPTextModel(_UpperCAmelCase						)







							def 				__lowercase     (				self   :			Dict						):
									_a	: Union[str, Any]								=				self.dummy_uncond_unet
									_a	: Union[str, Any]								=				DDIMScheduler()
									_a	: Union[str, Any]								=				self.dummy_vq_model

									_a	: List[Any]								=				LDMPipeline(unet=_UpperCAmelCase      ,vqvae=_UpperCAmelCase      ,scheduler=_UpperCAmelCase						)
									ldm.to(_UpperCAmelCase						)
									ldm.set_progress_bar_config(disable=_UpperCAmelCase						)

									_a	: Dict								=				torch.manual_seed(0						)
									_a	: int								=				ldm(generator=_UpperCAmelCase      ,num_inference_steps=2      ,output_type='numpy'						).images

									_a	: Tuple								=				torch.manual_seed(0						)
									_a	: List[Any]								=				ldm(generator=_UpperCAmelCase      ,num_inference_steps=2      ,output_type='numpy'      ,return_dict=_UpperCAmelCase						)[0]

									_a	: Any								=				image[0, -3:, -3:, -1]
									_a	: List[Any]								=				image_from_tuple[0, -3:, -3:, -1]

									assert image.shape == (1, 64, 64, 3)
									_a	: Union[str, Any]								=				np.array([0.85_12, 0.8_18, 0.64_11, 0.68_08, 0.44_65, 0.56_18, 0.46, 0.62_31, 0.51_72]						)
									_a	: Any								=				1E-2 if torch_device != 'mps' else 3E-2

									assert np.abs(image_slice.flatten() - expected_slice						).max() < tolerance
									assert np.abs(image_from_tuple_slice.flatten() - expected_slice						).max() < tolerance

@slow
@require_torch
class       __magic_name__		(       unittest.TestCase  ):







							def 				__lowercase     (				self   :			Optional[int]						):
									_a	: Dict								=				LDMPipeline.from_pretrained('CompVis/ldm-celebahq-256'						)
									ldm.to(_UpperCAmelCase						)
									ldm.set_progress_bar_config(disable=_UpperCAmelCase						)

									_a	: str								=				torch.manual_seed(0						)
									_a	: Optional[Any]								=				ldm(generator=_UpperCAmelCase      ,num_inference_steps=5      ,output_type='numpy'						).images

									_a	: Optional[Any]								=				image[0, -3:, -3:, -1]

									assert image.shape == (1, 256, 256, 3)
									_a	: Union[str, Any]								=				np.array([0.43_99, 0.4_49_75, 0.4_68_25, 0.4_74, 0.43_59, 0.45_81, 0.4_50_95, 0.43_41, 0.44_47]						)
									_a	: List[str]								=				1E-2 if torch_device != 'mps' else 3E-2

									assert np.abs(image_slice.flatten() - expected_slice						).max() < tolerance




