




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			):







			@property
			def UpperCamelCase      (	self   :      Any				):




									"""simple docstring"""


									_UpperCAmelCase													=					1
									_UpperCAmelCase													=					3
									_UpperCAmelCase													=					(32, 32)

									_UpperCAmelCase													=					floats_tensor((batch_size, num_channels) + sizes   ,   rng=random.Random(0				)				).to(snake_case__				)
									return image







			@property
			def UpperCamelCase      (	self   :      Tuple				):




									"""simple docstring"""


									torch.manual_seed(0				)
									_UpperCAmelCase													=					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   :      Union[str, Any]				):




									"""simple docstring"""


									torch.manual_seed(0				)
									_UpperCAmelCase													=					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   :      List[str]				):




									"""simple docstring"""


									_UpperCAmelCase													=					"cpu"
									_UpperCAmelCase													=					self.dummy_uncond_unet
									_UpperCAmelCase													=					DDIMScheduler()
									_UpperCAmelCase													=					self.dummy_vq_model

									_UpperCAmelCase													=					LDMSuperResolutionPipeline(unet=snake_case__   ,   vqvae=snake_case__   ,   scheduler=snake_case__				)
									ldm.to(snake_case__				)
									ldm.set_progress_bar_config(disable=snake_case__				)

									_UpperCAmelCase													=					self.dummy_image.to(snake_case__				)

									_UpperCAmelCase													=					torch.Generator(device=snake_case__				).manual_seed(0				)
									_UpperCAmelCase													=					ldm(image=snake_case__   ,   generator=snake_case__   ,   num_inference_steps=2   ,   output_type="numpy"				).images

									_UpperCAmelCase													=					image[0, -3:, -3:, -1]

									assert image.shape == (1, 64, 64, 3)
									_UpperCAmelCase													=					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   :      Dict				):




									"""simple docstring"""


									_UpperCAmelCase													=					self.dummy_uncond_unet
									_UpperCAmelCase													=					DDIMScheduler()
									_UpperCAmelCase													=					self.dummy_vq_model

									# put models in fp16
									_UpperCAmelCase													=					unet.half()
									_UpperCAmelCase													=					vqvae.half()

									_UpperCAmelCase													=					LDMSuperResolutionPipeline(unet=snake_case__   ,   vqvae=snake_case__   ,   scheduler=snake_case__				)
									ldm.to(snake_case__				)
									ldm.set_progress_bar_config(disable=snake_case__				)

									_UpperCAmelCase													=					self.dummy_image.to(snake_case__				)

									_UpperCAmelCase													=					ldm(snake_case__   ,   num_inference_steps=2   ,   output_type="numpy"				).images

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






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







			def UpperCamelCase      (	self   :      List[Any]				):




									"""simple docstring"""


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

									_UpperCAmelCase													=					LDMSuperResolutionPipeline.from_pretrained("duongna/ldm-super-resolution"   ,   device_map="auto"				)
									ldm.set_progress_bar_config(disable=snake_case__				)

									_UpperCAmelCase													=					torch.manual_seed(0				)
									_UpperCAmelCase													=					ldm(image=snake_case__   ,   generator=snake_case__   ,   num_inference_steps=20   ,   output_type="numpy"				).images

									_UpperCAmelCase													=					image[0, -3:, -3:, -1]

									assert image.shape == (1, 256, 256, 3)
									_UpperCAmelCase													=					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 __future__ import annotations

from collections.abc import Generator


def 							__SCREAMING_SNAKE_CASE  (      snake_case_						):

						'''simple docstring'''


						if not isinstance(snake_case_     ,   snake_case_						) or n < 1:
												raise Exception("Sequence only defined for positive integers"						)

						yield n
						while n != 1:
												if n % 2 == 0:
																		n //= 2
												else:
																		_UpperCAmelCase													=					3 * n + 1
												yield n


def 							__SCREAMING_SNAKE_CASE  (      ):

						'''simple docstring'''


						_UpperCAmelCase													=					43
						_UpperCAmelCase													=					tuple(collatz_sequence(snake_case_						)						)
						print(snake_case_						)
						print(f"""Collatz sequence from {n} took {len(snake_case_						)} steps."""						)


if __name__ == "__main__":
				main()




