

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




      """simple docstring"""

      @property
      def 		__A  (      self       :							str  ):
            A_	     =							1
            A_	     =							3
            A_	     =							(32, 32)

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





      @property
      def 		__A  (      self       :							Dict  ):
            torch.manual_seed(0  )
            A_	     =							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       :							List[str]  ):
            torch.manual_seed(0  )
            A_	     =							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       :							Dict  ):
            A_	     =							"cpu"
            A_	     =							self.dummy_uncond_unet
            A_	     =							DDIMScheduler()
            A_	     =							self.dummy_vq_model

            A_	     =							LDMSuperResolutionPipeline(unet=UpperCAmelCase	, vqvae=UpperCAmelCase	, scheduler=UpperCAmelCase  )
            ldm.to(UpperCAmelCase  )
            ldm.set_progress_bar_config(disable=UpperCAmelCase  )

            A_	     =							self.dummy_image.to(UpperCAmelCase  )

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

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

            assert image.shape == (1, 64, 64, 3)
            A_	     =							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 		__A  (      self       :							Dict  ):
            A_	     =							self.dummy_uncond_unet
            A_	     =							DDIMScheduler()
            A_	     =							self.dummy_vq_model

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

            A_	     =							LDMSuperResolutionPipeline(unet=UpperCAmelCase	, vqvae=UpperCAmelCase	, scheduler=UpperCAmelCase  )
            ldm.to(UpperCAmelCase  )
            ldm.set_progress_bar_config(disable=UpperCAmelCase  )

            A_	     =							self.dummy_image.to(UpperCAmelCase  )

            A_	     =							ldm(UpperCAmelCase	, num_inference_steps=2	, output_type="numpy"  ).images

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




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




      """simple docstring"""

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

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

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

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

            assert image.shape == (1, 256, 256, 3)
            A_	     =							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


__a						:Dict            = {hex(i)[2:]: i for i in range(16)}  # Use [:2] to strip off the leading '0x'

def 			__snake_case	(   __UpperCamelCase  :   str						):



      """simple docstring"""

      A_	     =							hex_string.strip().lower()
      if not hex_string:
            raise ValueError("Empty string was passed to the function"						)
      A_	     =							hex_string[0] == "-"
      if is_negative:
            A_	     =							hex_string[1:]
      if not all(char in hex_table for char in hex_string						):
            raise ValueError("Non-hexadecimal value was passed to the function"						)
      A_	     =							0
      for char in hex_string:
            A_	     =							16 * decimal_number + hex_table[char]
      return -decimal_number if is_negative else decimal_number


if __name__ == "__main__":
      from doctest import testmod

      testmod()