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  __lowerCAmelCase	(							unittest.TestCase    ):



 '''simple docstring'''

 @property
 def        __snake_case       (      self							:		Optional[int]	)			->				List[str]:
        _UpperCamelCase  :							Dict	    =	1
        _UpperCamelCase  :							int	    =	3
        _UpperCamelCase  :							str	    =	(3_2, 3_2)

        _UpperCamelCase  :							Tuple	    =	floats_tensor((batch_size, num_channels) + sizes							,      rng=random.Random(0	)	).to(lowerCamelCase	)
        return image

 @property
 def        __snake_case       (      self							:		Any	)			->				Any:
        torch.manual_seed(0	)
        _UpperCamelCase  :							Tuple	    =	UNetaDModel(
            block_out_channels=(3_2, 6_4)							,      layers_per_block=2							,      sample_size=3_2							,      in_channels=6							,      out_channels=3							,      down_block_types=('DownBlock2D', 'AttnDownBlock2D')							,      up_block_types=('AttnUpBlock2D', 'UpBlock2D')							,      )
        return model

 @property
 def        __snake_case       (      self							:		int	)			->				Optional[int]:
        torch.manual_seed(0	)
        _UpperCamelCase  :							Dict	    =	VQModel(
            block_out_channels=[3_2, 6_4]							,      in_channels=3							,      out_channels=3							,      down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D']							,      up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D']							,      latent_channels=3							,      )
        return model

 def        __snake_case       (      self							:		Union[str, Any]	)			->				Optional[int]:
        _UpperCamelCase  :							str	    =	'cpu'
        _UpperCamelCase  :							int	    =	self.dummy_uncond_unet
        _UpperCamelCase  :							List[str]	    =	DDIMScheduler()
        _UpperCamelCase  :							Dict	    =	self.dummy_vq_model

        _UpperCamelCase  :							List[str]	    =	LDMSuperResolutionPipeline(unet=lowerCamelCase							,      vqvae=lowerCamelCase							,      scheduler=lowerCamelCase	)
        ldm.to(lowerCamelCase	)
        ldm.set_progress_bar_config(disable=lowerCamelCase	)

        _UpperCamelCase  :							Optional[int]	    =	self.dummy_image.to(lowerCamelCase	)

        _UpperCamelCase  :							int	    =	torch.Generator(device=lowerCamelCase	).manual_seed(0	)
        _UpperCamelCase  :							Union[str, Any]	    =	ldm(image=lowerCamelCase							,      generator=lowerCamelCase							,      num_inference_steps=2							,      output_type='numpy'	).images

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

        assert image.shape == (1, 6_4, 6_4, 3)
        _UpperCamelCase  :							str	    =	np.array([0.8_6_7_8, 0.8_2_4_5, 0.6_3_8_1, 0.6_8_3_0, 0.4_3_8_5, 0.5_5_9_9, 0.4_6_4_1, 0.6_2_0_1, 0.5_1_5_0]	)

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

 @unittest.skipIf(torch_device != 'cuda'							,      'This test requires a GPU'	)
 def        __snake_case       (      self							:		Tuple	)			->				Dict:
        _UpperCamelCase  :							Tuple	    =	self.dummy_uncond_unet
        _UpperCamelCase  :							Any	    =	DDIMScheduler()
        _UpperCamelCase  :							int	    =	self.dummy_vq_model

        # put models in fp16
        _UpperCamelCase  :							List[Any]	    =	unet.half()
        _UpperCamelCase  :							int	    =	vqvae.half()

        _UpperCamelCase  :							Any	    =	LDMSuperResolutionPipeline(unet=lowerCamelCase							,      vqvae=lowerCamelCase							,      scheduler=lowerCamelCase	)
        ldm.to(lowerCamelCase	)
        ldm.set_progress_bar_config(disable=lowerCamelCase	)

        _UpperCamelCase  :							Optional[int]	    =	self.dummy_image.to(lowerCamelCase	)

        _UpperCamelCase  :							Dict	    =	ldm(lowerCamelCase							,      num_inference_steps=2							,      output_type='numpy'	).images

        assert image.shape == (1, 6_4, 6_4, 3)







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



 '''simple docstring'''

 def        __snake_case       (      self							:		int	)			->				Optional[Any]:
        _UpperCamelCase  :							Dict	    =	load_image(
            'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
            '/vq_diffusion/teddy_bear_pool.png'	)
        _UpperCamelCase  :							Optional[int]	    =	init_image.resize((6_4, 6_4)							,      resample=PIL_INTERPOLATION['lanczos']	)

        _UpperCamelCase  :							Optional[int]	    =	LDMSuperResolutionPipeline.from_pretrained('duongna/ldm-super-resolution'							,      device_map='auto'	)
        ldm.set_progress_bar_config(disable=lowerCamelCase	)

        _UpperCamelCase  :							str	    =	torch.manual_seed(0	)
        _UpperCamelCase  :							str	    =	ldm(image=lowerCamelCase							,      generator=lowerCamelCase							,      num_inference_steps=2_0							,      output_type='numpy'	).images

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

        assert image.shape == (1, 2_5_6, 2_5_6, 3)
        _UpperCamelCase  :							List[Any]	    =	np.array([0.7_6_4_4, 0.7_6_7_9, 0.7_6_4_2, 0.7_6_3_3, 0.7_6_6_6, 0.7_5_6_0, 0.7_4_2_5, 0.7_2_5_7, 0.6_9_0_7]	)

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




import unittest
from dataclasses import dataclass
from typing import List, Union

import numpy as np
import PIL.Image

from diffusers.utils.outputs import BaseOutput




@dataclass
class  __lowerCAmelCase	(							a_    ):



 '''simple docstring'''
 _lowerCamelCase    :						Union[List[PIL.Image.Image], np.ndarray]







class  __lowerCAmelCase	(							unittest.TestCase    ):



 '''simple docstring'''

 def        __snake_case       (      self							:		int	)			->				Tuple:
        _UpperCamelCase  :							str	    =	CustomOutput(images=np.random.rand(1							,      3							,      4							,      4	)	)

        # check every way of getting the attribute
        assert isinstance(outputs.images							,      np.ndarray	)
        assert outputs.images.shape == (1, 3, 4, 4)
        assert isinstance(outputs['images']							,      np.ndarray	)
        assert outputs["images"].shape == (1, 3, 4, 4)
        assert isinstance(outputs[0]							,      np.ndarray	)
        assert outputs[0].shape == (1, 3, 4, 4)

        # test with a non-tensor attribute
        _UpperCamelCase  :							str	    =	CustomOutput(images=[PIL.Image.new('RGB'							,      (4, 4)	)]	)

        # check every way of getting the attribute
        assert isinstance(outputs.images							,      lowerCamelCase	)
        assert isinstance(outputs.images[0]							,      PIL.Image.Image	)
        assert isinstance(outputs['images']							,      lowerCamelCase	)
        assert isinstance(outputs['images'][0]							,      PIL.Image.Image	)
        assert isinstance(outputs[0]							,      lowerCamelCase	)
        assert isinstance(outputs[0][0]							,      PIL.Image.Image	)

 def        __snake_case       (      self							:		Any	)			->				Dict:
        # test output reinitialization with a `dict` for compatibility with `accelerate`
        _UpperCamelCase  :							Tuple	    =	CustomOutput({'images': np.random.rand(1							,      3							,      4							,      4	)}	)

        # check every way of getting the attribute
        assert isinstance(outputs.images							,      np.ndarray	)
        assert outputs.images.shape == (1, 3, 4, 4)
        assert isinstance(outputs['images']							,      np.ndarray	)
        assert outputs["images"].shape == (1, 3, 4, 4)
        assert isinstance(outputs[0]							,      np.ndarray	)
        assert outputs[0].shape == (1, 3, 4, 4)

        # test with a non-tensor attribute
        _UpperCamelCase  :							int	    =	CustomOutput({'images': [PIL.Image.new('RGB'							,      (4, 4)	)]}	)

        # check every way of getting the attribute
        assert isinstance(outputs.images							,      lowerCamelCase	)
        assert isinstance(outputs.images[0]							,      PIL.Image.Image	)
        assert isinstance(outputs['images']							,      lowerCamelCase	)
        assert isinstance(outputs['images'][0]							,      PIL.Image.Image	)
        assert isinstance(outputs[0]							,      lowerCamelCase	)
        assert isinstance(outputs[0][0]							,      PIL.Image.Image	)



