'''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 )		->     Union[str, Any]:
           A_     =   1
           A_     =   3
           A_     =   (32, 32)

           A_     =   floats_tensor((batch_size, num_channels) + sizes    ,     rng=random.Random(0 ) ).to(_SCREAMING_SNAKE_CASE )
           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 )		->     Optional[int]:
           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 )		->     str:
           A_     =   '''cpu'''
           A_     =   self.dummy_uncond_unet
           A_     =   DDIMScheduler()
           A_     =   self.dummy_vq_model

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

           A_     =   self.dummy_image.to(_SCREAMING_SNAKE_CASE )

           A_     =   torch.Generator(device=_SCREAMING_SNAKE_CASE ).manual_seed(0 )
           A_     =   ldm(image=_SCREAMING_SNAKE_CASE    ,     generator=_SCREAMING_SNAKE_CASE    ,     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 )		->     Tuple:
           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=_SCREAMING_SNAKE_CASE    ,     vqvae=_SCREAMING_SNAKE_CASE    ,     scheduler=_SCREAMING_SNAKE_CASE )
           ldm.to(_SCREAMING_SNAKE_CASE )
           ldm.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE )

           A_     =   self.dummy_image.to(_SCREAMING_SNAKE_CASE )

           A_     =   ldm(_SCREAMING_SNAKE_CASE    ,     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 )		->     List[Any]:
           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=_SCREAMING_SNAKE_CASE )

           A_     =   torch.manual_seed(0 )
           A_     =   ldm(image=_SCREAMING_SNAKE_CASE    ,     generator=_SCREAMING_SNAKE_CASE    ,     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













'''simple docstring'''



import math




def       _lowerCAmelCase  ( lowerCamelCase_	:     int ):

			if 1 < number < 4:
						# 2 and 3 are primes
						return True
			elif number < 2 or number % 2 == 0 or number % 3 == 0:
						# Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
						return False

			# All primes number are in format of 6k +/- 1
			for i in range(5						,				int(math.sqrt(lowerCamelCase_ ) + 1 )						,				6 ):
						if number % i == 0 or number % (i + 2) == 0:
									return False
			return True




def       _lowerCAmelCase  ( lowerCamelCase_	:     int = 6_0_0_8_5_1_4_7_5_1_4_3 ):

			try:
						__lowercase   =							int(lowerCamelCase_ )
			except (TypeError, ValueError):
						raise TypeError('''Parameter n must be int or castable to int.''' )
			if n <= 0:
						raise ValueError('''Parameter n must be greater than or equal to one.''' )
			__lowercase   =							0
			if is_prime(lowerCamelCase_ ):
						return n
			while n % 2 == 0:
						n //= 2
			if is_prime(lowerCamelCase_ ):
						return n
			for i in range(3						,				int(math.sqrt(lowerCamelCase_ ) ) + 1						,				2 ):
						if n % i == 0:
									if is_prime(n // i ):
												__lowercase   =							n // i
												break
									elif is_prime(lowerCamelCase_ ):
												__lowercase   =							i
			return max_number


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





