
'''simple docstring'''
import random
import unittest

import numpy as np
import torch

from diffusers import DDIMScheduler, LDMSuperResolutionPipeline, UNetaDModel, VQModel
from diffusers.utils import PIL_INTERPOLATION, floats_tensor, load_image, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch


enable_full_determinism()







class 			__A					(			unittest.TestCase      ):
 @property
 def 		lowercase_( self      :     Optional[Any]							):



   """simple docstring"""





   __A		:  Dict       				=		1
   __A		:  List[str]       				=		3
   __A		:  List[Any]       				=		(32, 32)

   __A		:  Any       				=		floats_tensor((batch_size, num_channels) + sizes					, rng=random.Random(0							)							).to(_lowerCAmelCase							)
   return image
 @property
 def 		lowercase_( self      :     Tuple							):



   """simple docstring"""





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



   """simple docstring"""





   torch.manual_seed(0							)
   __A		:  Any       				=		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
 def 		lowercase_( self      :     Optional[Any]							):



   """simple docstring"""





   __A		:  Optional[Any]       				=		"""cpu"""
   __A		:  List[Any]       				=		self.dummy_uncond_unet
   __A		:  Dict       				=		DDIMScheduler()
   __A		:  int       				=		self.dummy_vq_model

   __A		:  List[Any]       				=		LDMSuperResolutionPipeline(unet=_lowerCAmelCase					, vqvae=_lowerCAmelCase					, scheduler=_lowerCAmelCase							)
   ldm.to(_lowerCAmelCase							)
   ldm.set_progress_bar_config(disable=_lowerCAmelCase							)

   __A		:  List[str]       				=		self.dummy_image.to(_lowerCAmelCase							)

   __A		:  List[str]       				=		torch.Generator(device=_lowerCAmelCase							).manual_seed(0							)
   __A		:  List[Any]       				=		ldm(image=_lowerCAmelCase					, generator=_lowerCAmelCase					, num_inference_steps=2					, output_type="""numpy"""							).images

   __A		:  Tuple       				=		image[0, -3:, -3:, -1]

   assert image.shape == (1, 64, 64, 3)
   __A		:  Optional[int]       				=		np.array([0.8_678, 0.8_245, 0.6_381, 0.6_830, 0.4_385, 0.5_599, 0.4_641, 0.6_201, 0.5_150]							)

   assert np.abs(image_slice.flatten() - expected_slice							).max() < 1e-2






 @unittest.skipIf(torch_device != """cuda"""					, """This test requires a GPU"""							)
 def 		lowercase_( self      :     Optional[int]							):



   """simple docstring"""





   __A		:  List[Any]       				=		self.dummy_uncond_unet
   __A		:  int       				=		DDIMScheduler()
   __A		:  List[str]       				=		self.dummy_vq_model

   # put models in fp16
   __A		:  Any       				=		unet.half()
   __A		:  Optional[Any]       				=		vqvae.half()

   __A		:  Union[str, Any]       				=		LDMSuperResolutionPipeline(unet=_lowerCAmelCase					, vqvae=_lowerCAmelCase					, scheduler=_lowerCAmelCase							)
   ldm.to(_lowerCAmelCase							)
   ldm.set_progress_bar_config(disable=_lowerCAmelCase							)

   __A		:  List[Any]       				=		self.dummy_image.to(_lowerCAmelCase							)

   __A		:  str       				=		ldm(_lowerCAmelCase					, num_inference_steps=2					, output_type="""numpy"""							).images

   assert image.shape == (1, 64, 64, 3)







@slow
@require_torch
class 			__A					(			unittest.TestCase      ):
 def 		lowercase_( self      :     Dict							):



   """simple docstring"""





   __A		:  Optional[int]       				=		load_image(
       """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
       """/vq_diffusion/teddy_bear_pool.png"""							)
   __A		:  Optional[int]       				=		init_image.resize((64, 64)					, resample=PIL_INTERPOLATION["""lanczos"""]							)

   __A		:  List[Any]       				=		LDMSuperResolutionPipeline.from_pretrained("""duongna/ldm-super-resolution"""					, device_map="""auto"""							)
   ldm.set_progress_bar_config(disable=_lowerCAmelCase							)

   __A		:  Optional[int]       				=		torch.manual_seed(0							)
   __A		:  Optional[int]       				=		ldm(image=_lowerCAmelCase					, generator=_lowerCAmelCase					, num_inference_steps=20					, output_type="""numpy"""							).images

   __A		:  Dict       				=		image[0, -3:, -3:, -1]

   assert image.shape == (1, 2_56, 2_56, 3)
   __A		:  Union[str, Any]       				=		np.array([0.7_644, 0.7_679, 0.7_642, 0.7_633, 0.7_666, 0.7_560, 0.7_425, 0.7_257, 0.6_907]							)

   assert np.abs(image_slice.flatten() - expected_slice							).max() < 1e-2







from ..utils import DummyObject, requires_backends

class      __snake_case				(   metaclass=_UpperCAmelCase):
					SCREAMING_SNAKE_CASE_		:       str								=			["torch", "transformers", "k_diffusion"]
					def __init__(						self       :						Tuple	,      *_lowerCAmelCase       :						Union[str, Any]	,      **_lowerCAmelCase       :						Union[str, Any]  )							->					Dict:



											'''simple docstring'''





											requires_backends(self	,      ['torch', 'transformers', 'k_diffusion']  )
					@classmethod
					def 	a			(						cls       :						Optional[int]	,      *_lowerCAmelCase       :						Any	,      **_lowerCAmelCase       :						Optional[Any]  )							->					Optional[Any]:



											'''simple docstring'''





											requires_backends(cls	,      ['torch', 'transformers', 'k_diffusion']  )







					@classmethod
					def 	a			(						cls       :						Union[str, Any]	,      *_lowerCAmelCase       :						Tuple	,      **_lowerCAmelCase       :						str  )							->					Tuple:



											'''simple docstring'''





											requires_backends(cls	,      ['torch', 'transformers', 'k_diffusion']  )

