




'''simple docstring'''




import unittest
from dataclasses import dataclass
from typing import Optional

from transformers.utils import ModelOutput






@dataclass
class     UpperCamelCase_     (UpperCAmelCase_    ):







						"""simple docstring"""


						_lowerCAmelCase    						=					4_2
						_lowerCAmelCase    						=					None
						_lowerCAmelCase    						=					None






class     UpperCamelCase_     (unittest.TestCase    ):







						"""simple docstring"""


						def       _a    (     self      :       int    ):





											"""simple docstring"""







											A_ :     List[Any] =							ModelOutputTest(a=30    )
											self.assertEqual(x.a							, 30    )
											self.assertIsNone(x.b    )
											self.assertIsNone(x.c    )
											with self.assertRaises(_lowerCamelCase    ):
																A_ :     Optional[Any] =							x.d







						def       _a    (     self      :       str    ):





											"""simple docstring"""







											A_ :     Dict =							ModelOutputTest(a=30							, b=10    )
											self.assertEqual(x[0]							, 30    )
											self.assertEqual(x[1]							, 10    )
											self.assertEqual(x[:2]							, (30, 10)    )
											self.assertEqual(x[:]							, (30, 10)    )

											A_ :     int =							ModelOutputTest(a=30							, c=10    )
											self.assertEqual(x[0]							, 30    )
											self.assertEqual(x[1]							, 10    )
											self.assertEqual(x[:2]							, (30, 10)    )
											self.assertEqual(x[:]							, (30, 10)    )







						def       _a    (     self      :       Any    ):





											"""simple docstring"""







											A_ :     Optional[int] =							ModelOutputTest(a=30							, b=10    )
											self.assertEqual(x['''a''']							, 30    )
											self.assertEqual(x['''b''']							, 10    )
											with self.assertRaises(_lowerCamelCase    ):
																A_ :     List[Any] =							x['''c''']

											A_ :     List[Any] =							ModelOutputTest(a=30							, c=10    )
											self.assertEqual(x['''a''']							, 30    )
											self.assertEqual(x['''c''']							, 10    )
											with self.assertRaises(_lowerCamelCase    ):
																A_ :     str =							x['''b''']







						def       _a    (     self      :       int    ):





											"""simple docstring"""







											A_ :     Optional[Any] =							ModelOutputTest(a=30    )
											self.assertEqual(list(x.keys()    )							, ['''a''']    )
											self.assertEqual(list(x.values()    )							, [30]    )
											self.assertEqual(list(x.items()    )							, [('''a''', 30)]    )
											self.assertEqual(list(_lowerCamelCase    )							, ['''a''']    )

											A_ :     str =							ModelOutputTest(a=30							, b=10    )
											self.assertEqual(list(x.keys()    )							, ['''a''', '''b''']    )
											self.assertEqual(list(x.values()    )							, [30, 10]    )
											self.assertEqual(list(x.items()    )							, [('''a''', 30), ('''b''', 10)]    )
											self.assertEqual(list(_lowerCamelCase    )							, ['''a''', '''b''']    )

											A_ :     Optional[int] =							ModelOutputTest(a=30							, c=10    )
											self.assertEqual(list(x.keys()    )							, ['''a''', '''c''']    )
											self.assertEqual(list(x.values()    )							, [30, 10]    )
											self.assertEqual(list(x.items()    )							, [('''a''', 30), ('''c''', 10)]    )
											self.assertEqual(list(_lowerCamelCase    )							, ['''a''', '''c''']    )

											with self.assertRaises(_lowerCamelCase    ):
																A_ :     str =							x.update({'''d''': 20}    )
											with self.assertRaises(_lowerCamelCase    ):
																del x["a"]
											with self.assertRaises(_lowerCamelCase    ):
																A_ :     Optional[Any] =							x.pop('''a'''    )
											with self.assertRaises(_lowerCamelCase    ):
																A_ :     str =							x.setdefault('''d'''							, 32    )







						def       _a    (     self      :       int    ):





											"""simple docstring"""







											A_ :     List[Any] =							ModelOutputTest(a=30    )
											A_ :     str =							10
											self.assertEqual(x.a							, 10    )
											self.assertEqual(x['''a''']							, 10    )







						def       _a    (     self      :       int    ):





											"""simple docstring"""







											A_ :     Optional[int] =							ModelOutputTest(a=30    )
											A_ :     Dict =							10
											self.assertEqual(x.a							, 10    )
											self.assertEqual(x['''a''']							, 10    )







						def       _a    (     self      :       str    ):





											"""simple docstring"""







											A_ :     Tuple =							ModelOutputTest({'''a''': 30, '''b''': 10}    )
											self.assertEqual(list(x.keys()    )							, ['''a''', '''b''']    )
											self.assertEqual(x.a							, 30    )
											self.assertEqual(x.b							, 10    )







						def       _a    (     self      :       Union[str, Any]    ):





											"""simple docstring"""







											A_ :     str =							ModelOutputTest([('''a''', 30), ('''b''', 10)]    )
											self.assertEqual(list(x.keys()    )							, ['''a''', '''b''']    )
											self.assertEqual(x.a							, 30    )
											self.assertEqual(x.b							, 10    )

											with self.assertRaises(_lowerCamelCase    ):
																A_ :     Optional[Any] =							ModelOutputTest([('''a''', 30), (10, 10)]    )

											A_ :     int =							ModelOutputTest(a=(30, 30)    )
											self.assertEqual(list(x.keys()    )							, ['''a''']    )
											self.assertEqual(x.a							, (30, 30)    )









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







						"""simple docstring"""


						@property
						def       _a    (     self      :       int    ):





											"""simple docstring"""







											A_ :     Dict =							1
											A_ :     Any =							3
											A_ :     Any =							(32, 32)

											A_ :     Dict =							floats_tensor((batch_size, num_channels) + sizes							, rng=random.Random(0    )    ).to(_lowerCamelCase    )
											return image







						@property
						def       _a    (     self      :       Dict    ):





											"""simple docstring"""







											torch.manual_seed(0    )
											A_ :     Optional[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       _a    (     self      :       Any    ):





											"""simple docstring"""







											torch.manual_seed(0    )
											A_ :     Dict =							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       _a    (     self      :       List[Any]    ):





											"""simple docstring"""







											A_ :     Any =							'''cpu'''
											A_ :     Optional[Any] =							self.dummy_uncond_unet
											A_ :     str =							DDIMScheduler()
											A_ :     Optional[int] =							self.dummy_vq_model

											A_ :     Optional[Any] =							LDMSuperResolutionPipeline(unet=_lowerCamelCase							, vqvae=_lowerCamelCase							, scheduler=_lowerCamelCase    )
											ldm.to(_lowerCamelCase    )
											ldm.set_progress_bar_config(disable=_lowerCamelCase    )

											A_ :     Any =							self.dummy_image.to(_lowerCamelCase    )

											A_ :     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_ :     str =							image[0, -3:, -3:, -1]

											assert image.shape == (1, 64, 64, 3)
											A_ :     List[Any] =							np.array([0.86_78, 0.82_45, 0.63_81, 0.68_30, 0.43_85, 0.55_99, 0.46_41, 0.62_01, 0.51_50]    )

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







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





											"""simple docstring"""







											A_ :     Tuple =							self.dummy_uncond_unet
											A_ :     List[str] =							DDIMScheduler()
											A_ :     str =							self.dummy_vq_model

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

											A_ :     Optional[Any] =							LDMSuperResolutionPipeline(unet=_lowerCamelCase							, vqvae=_lowerCamelCase							, scheduler=_lowerCamelCase    )
											ldm.to(_lowerCamelCase    )
											ldm.set_progress_bar_config(disable=_lowerCamelCase    )

											A_ :     Optional[Any] =							self.dummy_image.to(_lowerCamelCase    )

											A_ :     Optional[Any] =							ldm(_lowerCamelCase							, num_inference_steps=2							, output_type='''numpy'''    ).images

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






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







						"""simple docstring"""


						def       _a    (     self      :       int    ):





											"""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_ :     List[str] =							init_image.resize((64, 64)							, resample=PIL_INTERPOLATION['''lanczos''']    )

											A_ :     List[str] =							LDMSuperResolutionPipeline.from_pretrained('''duongna/ldm-super-resolution'''							, device_map='''auto'''    )
											ldm.set_progress_bar_config(disable=_lowerCamelCase    )

											A_ :     List[str] =							torch.manual_seed(0    )
											A_ :     str =							ldm(image=_lowerCamelCase							, generator=_lowerCamelCase							, num_inference_steps=20							, output_type='''numpy'''    ).images

											A_ :     str =							image[0, -3:, -3:, -1]

											assert image.shape == (1, 256, 256, 3)
											A_ :     Optional[Any] =							np.array([0.76_44, 0.76_79, 0.76_42, 0.76_33, 0.76_66, 0.75_60, 0.74_25, 0.72_57, 0.69_07]    )

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



