




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        __snake_case      (			self     :      Any	) ->				Optional[int]:
           lowerCamelCase__					     = 1
           lowerCamelCase__					     = 3
           lowerCamelCase__					     = (3_2, 3_2)

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




     @property
     def        __snake_case      (			self     :      Optional[Any]	) ->				int:
           torch.manual_seed(0	)
           lowerCamelCase__					     = 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     :      List[str]	) ->				Union[str, Any]:
           torch.manual_seed(0	)
           lowerCamelCase__					     = 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     :      Optional[int]	) ->				List[Any]:
           lowerCamelCase__					     = 'cpu'
           lowerCamelCase__					     = self.dummy_uncond_unet
           lowerCamelCase__					     = DDIMScheduler()
           lowerCamelCase__					     = self.dummy_vq_model

           lowerCamelCase__					     = LDMSuperResolutionPipeline(unet=A__		,     vqvae=A__		,     scheduler=A__	)
           ldm.to(A__	)
           ldm.set_progress_bar_config(disable=A__	)

           lowerCamelCase__					     = self.dummy_image.to(A__	)

           lowerCamelCase__					     = torch.Generator(device=A__	).manual_seed(0	)
           lowerCamelCase__					     = ldm(image=A__		,     generator=A__		,     num_inference_steps=2		,     output_type='numpy'	).images

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

           assert image.shape == (1, 6_4, 6_4, 3)
           lowerCamelCase__					     = np.array([0.8678, 0.8245, 0.6381, 0.6830, 0.4385, 0.5599, 0.4641, 0.6201, 0.5150]	)

           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     :      Union[str, Any]	) ->				Any:
           lowerCamelCase__					     = self.dummy_uncond_unet
           lowerCamelCase__					     = DDIMScheduler()
           lowerCamelCase__					     = self.dummy_vq_model

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

           lowerCamelCase__					     = LDMSuperResolutionPipeline(unet=A__		,     vqvae=A__		,     scheduler=A__	)
           ldm.to(A__	)
           ldm.set_progress_bar_config(disable=A__	)

           lowerCamelCase__					     = self.dummy_image.to(A__	)

           lowerCamelCase__					     = ldm(A__		,     num_inference_steps=2		,     output_type='numpy'	).images

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






@slow
@require_torch
class 	A	(						unittest.TestCase						):
     """simple docstring"""

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

           lowerCamelCase__					     = LDMSuperResolutionPipeline.from_pretrained('duongna/ldm-super-resolution'		,     device_map='auto'	)
           ldm.set_progress_bar_config(disable=A__	)

           lowerCamelCase__					     = torch.manual_seed(0	)
           lowerCamelCase__					     = ldm(image=A__		,     generator=A__		,     num_inference_steps=2_0		,     output_type='numpy'	).images

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

           assert image.shape == (1, 2_5_6, 2_5_6, 3)
           lowerCamelCase__					     = np.array([0.7644, 0.7679, 0.7642, 0.7633, 0.7666, 0.7560, 0.7425, 0.7257, 0.6907]	)

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





def 	lowerCAmelCase_	(     lowerCamelCase:				int  )    ->	int:


      '''simple docstring'''




      return n * (2 * n - 1)

def 	lowerCAmelCase_	(     lowerCamelCase:				int  )    ->	bool:


      '''simple docstring'''




      lowerCamelCase__					     = (1 + 24 * n) ** 0.5
      return ((1 + root) / 6) % 1 == 0

def 	lowerCAmelCase_	(     lowerCamelCase:				int = 1_44  )    ->	int:


      '''simple docstring'''




      lowerCamelCase__					     = start
      lowerCamelCase__					     = hexagonal_num(lowerCamelCase  )
      while not is_pentagonal(lowerCamelCase  ):
            n += 1
            lowerCamelCase__					     = hexagonal_num(lowerCamelCase  )
      return num


if __name__ == "__main__":
      print(F"""{solution()} = """)