code: 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 _lowercase					(       unittest.TestCase						):
  
  
  
  
  
  							"""simple docstring"""
  
  
  
  
  							@property
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														_lowercase				=	1
  														_lowercase				=	3
  														_lowercase				=	(32, 32)
  
  														_lowercase				=	floats_tensor((batch_size, num_channels) + sizes     ,   rng=random.Random(0  )  ).to(A_  )
  														return image
  
  
  
  							@property
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														torch.manual_seed(0  )
  														_lowercase				=	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     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														torch.manual_seed(0  )
  														_lowercase				=	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     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														_lowercase				=	"""cpu"""
  														_lowercase				=	self.dummy_uncond_unet
  														_lowercase				=	DDIMScheduler()
  														_lowercase				=	self.dummy_vq_model
  
  														_lowercase				=	LDMSuperResolutionPipeline(unet=A_     ,   vqvae=A_     ,   scheduler=A_  )
  														ldm.to(A_  )
  														ldm.set_progress_bar_config(disable=A_  )
  
  														_lowercase				=	self.dummy_image.to(A_  )
  
  														_lowercase				=	torch.Generator(device=A_  ).manual_seed(0  )
  														_lowercase				=	ldm(image=A_     ,   generator=A_     ,   num_inference_steps=2     ,   output_type="""numpy"""  ).images
  
  														_lowercase				=	image[0, -3:, -3:, -1]
  
  														assert image.shape == (1, 64, 64, 3)
  														_lowercase				=	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     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														_lowercase				=	self.dummy_uncond_unet
  														_lowercase				=	DDIMScheduler()
  														_lowercase				=	self.dummy_vq_model
  
  														# put models in fp16
  														_lowercase				=	unet.half()
  														_lowercase				=	vqvae.half()
  
  														_lowercase				=	LDMSuperResolutionPipeline(unet=A_     ,   vqvae=A_     ,   scheduler=A_  )
  														ldm.to(A_  )
  														ldm.set_progress_bar_config(disable=A_  )
  
  														_lowercase				=	self.dummy_image.to(A_  )
  
  														_lowercase				=	ldm(A_     ,   num_inference_steps=2     ,   output_type="""numpy"""  ).images
  
  														assert image.shape == (1, 64, 64, 3)
  
  
  
  
  
  
  @slow
  @require_torch
  class _lowercase					(       unittest.TestCase						):
  
  
  
  
  
  							"""simple docstring"""
  
  
  
  
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														_lowercase				=	load_image(
  														    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
  														    """/vq_diffusion/teddy_bear_pool.png"""  )
  														_lowercase				=	init_image.resize((64, 64)     ,   resample=PIL_INTERPOLATION["""lanczos"""]  )
  
  														_lowercase				=	LDMSuperResolutionPipeline.from_pretrained("""duongna/ldm-super-resolution"""     ,   device_map="""auto"""  )
  														ldm.set_progress_bar_config(disable=A_  )
  
  														_lowercase				=	torch.manual_seed(0  )
  														_lowercase				=	ldm(image=A_     ,   generator=A_     ,   num_inference_steps=20     ,   output_type="""numpy"""  ).images
  
  														_lowercase				=	image[0, -3:, -3:, -1]
  
  														assert image.shape == (1, 256, 256, 3)
  														_lowercase				=	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
  
  
  
style_context: from ctypes import c_float, sizeof
  from enum import Enum
  from typing import TYPE_CHECKING, Optional, Union
  
  
  if TYPE_CHECKING:
  				from .. import AutoFeatureExtractor, AutoProcessor, AutoTokenizer  # tests_ignore
  
  
  class _lowercase					(       _UpperCAmelCase						):
  
  
  
  
  
  							"""simple docstring"""
  
  
  
  
  							lowerCAmelCase__       =					c_float
  
  
  
  							@property
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														return sizeof(self.value  )
  
  
  
  
  
  
  def 					__lowerCAmelCase			(  _A ,_A ,_A = 0					):
  
  
  
  							"""simple docstring"""
  
  
  							if dimension <= 0:
  														_lowercase				=	fixed_dimension
  
  							dimension -= num_token_to_add
  							return dimension
  
  
  def 					__lowerCAmelCase			(  _A ,_A					):
  
  
  
  							"""simple docstring"""
  
  
  							return num_parameters * dtype.size
  
  
  
  
  
  
  
  def 					__lowerCAmelCase			(  _A					):
  
  
  
  							"""simple docstring"""
  
  
  							from .. import AutoFeatureExtractor, AutoProcessor, AutoTokenizer  # tests_ignore
  
  							try:
  														return AutoProcessor.from_pretrained(_A					)
  							except (ValueError, OSError, KeyError):
  														_lowercase				,       _lowercase				=	None, None
  														try:
  																					_lowercase				=	AutoTokenizer.from_pretrained(_A					)
  														except (OSError, KeyError):
  																					pass
  														try:
  																					_lowercase				=	AutoFeatureExtractor.from_pretrained(_A					)
  														except (OSError, KeyError):
  																					pass
  
  														if tokenizer is not None and feature_extractor is not None:
  																					raise ValueError(
  																					    f'''Couldn\'t auto-detect preprocessor for {model_name}. Found both a tokenizer and a feature extractor.'''					)
  														elif tokenizer is None and feature_extractor is None:
  																					return None
  														elif tokenizer is not None:
  																					return tokenizer
  														else:
  																					return feature_extractor
  
  
  