




'''simple docstring'''




import enum
import inspect
import warnings
from functools import wraps
from typing import Callable, Optional

from .logging import get_logger


snake_case__          =						set()
snake_case__          =						get_logger(__name__)




def 						snake_case__    ( lowerCamelCase__				:   Optional[str] = None			)   ->   Dict:

					def decorator(lowerCamelCase__				:   Callable			):
										global _emitted_deprecation_warnings

										if inspect.isclass(lowerCamelCase__			):
															A_ :     str =							deprecated_class_or_function.__init__
															A_ :     str =							deprecated_class_or_function.__name__
										else:
															A_ :     List[Any] =							deprecated_class_or_function
															A_ :     List[str] =							deprecated_function.__name__
															# Support deprecating __init__ class method: class name instead
															A_ :     int =							name if name != '''__init__''' else deprecated_function.__qualname__.split('''.'''			)[-2]

										A_ :     Dict =							(
										    f'{name} is deprecated and will be removed in the next major version of datasets.' + f' {help_message}'
										    if help_message
										    else ''''''
										)

										@wraps(lowerCamelCase__			)
										def wrapper(*lowerCamelCase__				:   Tuple			,		**lowerCamelCase__				:   List[Any]			):
															A_ :     Tuple =							hash(lowerCamelCase__			)
															if func_hash not in _emitted_deprecation_warnings:
																				warnings.warn(lowerCamelCase__			,		category=lowerCamelCase__			,		stacklevel=2			)
																				_emitted_deprecation_warnings.add(lowerCamelCase__			)
															return deprecated_function(*lowerCamelCase__			,		**lowerCamelCase__			)

										A_ :     Optional[int] =							'''deprecated'''

										if inspect.isclass(lowerCamelCase__			):
															A_ :     Any =							wrapper
															return deprecated_class_or_function
										else:
															return wrapper

					return decorator






class     UpperCamelCase_     (enum.EnumMeta    ):







						"""simple docstring"""


						def __getattribute__(     cls      :       List[Any]							, _lowerCamelCase      :       Optional[Any]    ):





											"""simple docstring"""







											A_ :     Any =							super().__getattribute__(_lowerCamelCase    )
											if isinstance(_lowerCamelCase							, enum.Enum    ) and obj._on_access:
																obj._on_access()
											return obj







						def __getitem__(     cls      :       List[Any]							, _lowerCamelCase      :       Optional[int]    ):





											"""simple docstring"""







											A_ :     Optional[int] =							super().__getitem__(_lowerCamelCase    )
											if member._on_access:
																member._on_access()
											return member







						def __call__(     cls      :       int							, _lowerCamelCase      :       List[Any]							, _lowerCamelCase      :       Dict=None							, *, _lowerCamelCase      :       Dict=None							, _lowerCamelCase      :       List[Any]=None							, _lowerCamelCase      :       Any=None							, _lowerCamelCase      :       Optional[int]=1    ):





											"""simple docstring"""







											A_ :     Dict =							super().__call__(_lowerCamelCase							, _lowerCamelCase							, module=_lowerCamelCase							, qualname=_lowerCamelCase							, type=_lowerCamelCase							, start=_lowerCamelCase    )
											if isinstance(_lowerCamelCase							, enum.Enum    ) and obj._on_access:
																obj._on_access()
											return obj






class     UpperCamelCase_     (enum.Enum,      metaclass=a__    ):







						"""simple docstring"""


						def __new__(     cls      :       List[Any]							, _lowerCamelCase      :       Tuple    ):





											"""simple docstring"""







											A_ :     int =							object.__new__(cls    )
											A_ :     Union[str, Any] =							value
											A_ :     str =							member.deprecate
											return member







						@property
						def       _a    (     self      :       Any    ):





											"""simple docstring"""







											return ""







						def       _a    (     self      :       Optional[int]    ):





											"""simple docstring"""







											A_ :     str =							f' {self.help_message}' if self.help_message else ''''''
											warnings.warn(
											    f'\'{self.__objclass__.__name__}\' is deprecated and will be removed in the next major version of datasets.'
											    + help_message							, _lowerCamelCase							, stacklevel=3							, )









'''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



