





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

       @property
       def 						_SCREAMING_SNAKE_CASE(     self       ):






        '''simple docstring'''

        snake_case__      							=			1
        snake_case__      							=			3
        snake_case__      							=			(32, 32)

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

       @property
       def 						_SCREAMING_SNAKE_CASE(     self       ):






        '''simple docstring'''

        torch.manual_seed(0       )
        snake_case__      							=			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 						_SCREAMING_SNAKE_CASE(     self       ):






        '''simple docstring'''

        torch.manual_seed(0       )
        snake_case__      							=			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 						_SCREAMING_SNAKE_CASE(     self       ):






        '''simple docstring'''

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

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

        snake_case__      							=			self.dummy_image.to(_lowerCamelCase       )

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

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

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






        '''simple docstring'''

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

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

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

        snake_case__      							=			self.dummy_image.to(_lowerCamelCase       )

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

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



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

       def 						_SCREAMING_SNAKE_CASE(     self       ):






        '''simple docstring'''

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

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

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

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

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








"""simple docstring"""


import math





def 							a__     (					_UpperCAmelCase		)      ->					list:

 '''simple docstring'''






 if n <= 0:
  raise ValueError("Only positive integers have prime factors"		)
 snake_case__      							=			[]
 while n % 2 == 0:
  pf.append(2		)
  snake_case__      							=			int(n / 2		)
 for i in range(3		,       int(math.sqrt(_UpperCAmelCase		)		) + 1		,       2		):
  while n % i == 0:
   pf.append(_UpperCAmelCase		)
   snake_case__      							=			int(n / i		)
 if n > 2:
  pf.append(_UpperCAmelCase		)
 return pf





def 							a__     (					_UpperCAmelCase		)      ->					int:

 '''simple docstring'''






 if n <= 0:
  raise ValueError("Only positive numbers are accepted"		)
 snake_case__      							=			1
 snake_case__      							=			1
 while n % 2 == 0:
  temp += 1
  snake_case__      							=			int(n / 2		)
 div *= temp
 for i in range(3		,       int(math.sqrt(_UpperCAmelCase		)		) + 1		,       2		):
  snake_case__      							=			1
  while n % i == 0:
   temp += 1
   snake_case__      							=			int(n / i		)
  div *= temp
 if n > 1:
  div *= 2
 return div





def 							a__     (					_UpperCAmelCase		)      ->					int:

 '''simple docstring'''






 if n <= 0:
  raise ValueError("Only positive numbers are accepted"		)
 snake_case__      							=			1
 snake_case__      							=			1
 while n % 2 == 0:
  temp += 1
  snake_case__      							=			int(n / 2		)
 if temp > 1:
  s *= (2**temp - 1) / (2 - 1)
 for i in range(3		,       int(math.sqrt(_UpperCAmelCase		)		) + 1		,       2		):
  snake_case__      							=			1
  while n % i == 0:
   temp += 1
   snake_case__      							=			int(n / i		)
  if temp > 1:
   s *= (i**temp - 1) / (i - 1)
 return int(_UpperCAmelCase		)





def 							a__     (					_UpperCAmelCase		)      ->					int:

 '''simple docstring'''






 snake_case__      							=			n
 for x in set(prime_factors(_UpperCAmelCase		)		):
  s *= (x - 1) / x
 return int(_UpperCAmelCase		)


if __name__ == "__main__":
   import doctest

   doctest.testmod()

