






import gc
import random
import tempfile
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import AutoencoderKL, DDIMScheduler, LMSDiscreteScheduler, PNDMScheduler, UNetaDConditionModel
from diffusers.pipelines.semantic_stable_diffusion import SemanticStableDiffusionPipeline as StableDiffusionPipeline
from diffusers.utils import floats_tensor, nightly, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu


enable_full_determinism()







class 				lowerCamelCase_     (	unittest.TestCase     ):
							def  SCREAMING_SNAKE_CASE_ (						self		:					List[str]					):





								'''simple docstring'''



								super().tearDown()
								gc.collect()
								torch.cuda.empty_cache()
							@property
							def  SCREAMING_SNAKE_CASE_ (						self		:					Dict					):





								'''simple docstring'''



								a		=			1
								a		=			3
								a		=			(32, 32)

								a		=			floats_tensor((batch_size, num_channels) + sizes							,rng=random.Random(0					)					).to(__lowerCamelCase					)
								return image
							@property
							def  SCREAMING_SNAKE_CASE_ (						self		:					int					):





								'''simple docstring'''



								torch.manual_seed(0					)
								a		=			UNetaDConditionModel(
								    block_out_channels=(32, 64)							,layers_per_block=2							,sample_size=32							,in_channels=4							,out_channels=4							,down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')							,up_block_types=('''CrossAttnUpBlock2D''', '''UpBlock2D''')							,cross_attention_dim=32							,)
								return model
							@property
							def  SCREAMING_SNAKE_CASE_ (						self		:					Union[str, Any]					):





								'''simple docstring'''



								torch.manual_seed(0					)
								a		=			AutoencoderKL(
								    block_out_channels=[32, 64]							,in_channels=3							,out_channels=3							,down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D''']							,up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D''']							,latent_channels=4							,)
								return model
							@property
							def  SCREAMING_SNAKE_CASE_ (						self		:					Any					):





								'''simple docstring'''



								torch.manual_seed(0					)
								a		=			CLIPTextConfig(
								    bos_token_id=0							,eos_token_id=2							,hidden_size=32							,intermediate_size=37							,layer_norm_eps=1e-05							,num_attention_heads=4							,num_hidden_layers=5							,pad_token_id=1							,vocab_size=10_00							,)
								return CLIPTextModel(__lowerCamelCase					)
							@property
							def  SCREAMING_SNAKE_CASE_ (						self		:					Dict					):





								'''simple docstring'''



								def extract(*__lowerCamelCase		:					Optional[Any]							,**__lowerCamelCase		:					Union[str, Any]					):







									class 				lowerCamelCase_     :
																def __init__(						self		:					Any					):





																	'''simple docstring'''



																	a		=			torch.ones([0]					)




																def  SCREAMING_SNAKE_CASE_ (						self		:					int							,__lowerCamelCase		:					Union[str, Any]					):





																	'''simple docstring'''



																	self.pixel_values.to(__lowerCamelCase					)
																	return self


									return Out()

								return extract
							def  SCREAMING_SNAKE_CASE_ (						self		:					List[str]					):





								'''simple docstring'''



								a		=			'''cpu'''  # ensure determinism for the device-dependent torch.Generator
								a		=			self.dummy_cond_unet
								a		=			DDIMScheduler(
								    beta_start=0.00_085							,beta_end=0.012							,beta_schedule='''scaled_linear'''							,clip_sample=__lowerCamelCase							,set_alpha_to_one=__lowerCamelCase							,)

								a		=			self.dummy_vae
								a		=			self.dummy_text_encoder
								a		=			CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''					)

								# make sure here that pndm scheduler skips prk
								a		=			StableDiffusionPipeline(
								    unet=__lowerCamelCase							,scheduler=__lowerCamelCase							,vae=__lowerCamelCase							,text_encoder=__lowerCamelCase							,tokenizer=__lowerCamelCase							,safety_checker=__lowerCamelCase							,feature_extractor=self.dummy_extractor							,)
								a		=			sd_pipe.to(__lowerCamelCase					)
								sd_pipe.set_progress_bar_config(disable=__lowerCamelCase					)

								a		=			'''A painting of a squirrel eating a burger'''

								a		=			torch.Generator(device=__lowerCamelCase					).manual_seed(0					)
								a		=			sd_pipe([prompt]							,generator=__lowerCamelCase							,guidance_scale=6.0							,num_inference_steps=2							,output_type='''np'''					)
								a		=			output.images

								a		=			torch.Generator(device=__lowerCamelCase					).manual_seed(0					)
								a		=			sd_pipe(
								    [prompt]							,generator=__lowerCamelCase							,guidance_scale=6.0							,num_inference_steps=2							,output_type='''np'''							,return_dict=__lowerCamelCase							,)[0]

								a		=			image[0, -3:, -3:, -1]
								a		=			image_from_tuple[0, -3:, -3:, -1]

								assert image.shape == (1, 64, 64, 3)
								a		=			np.array([0.5_753, 0.6_114, 0.5_001, 0.5_034, 0.5_470, 0.4_729, 0.4_971, 0.4_867, 0.4_867]					)

								assert np.abs(image_slice.flatten() - expected_slice					).max() < 1e-2
								assert np.abs(image_from_tuple_slice.flatten() - expected_slice					).max() < 1e-2
							def  SCREAMING_SNAKE_CASE_ (						self		:					List[str]					):





								'''simple docstring'''



								a		=			'''cpu'''  # ensure determinism for the device-dependent torch.Generator
								a		=			self.dummy_cond_unet
								a		=			PNDMScheduler(skip_prk_steps=__lowerCamelCase					)
								a		=			self.dummy_vae
								a		=			self.dummy_text_encoder
								a		=			CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''					)

								# make sure here that pndm scheduler skips prk
								a		=			StableDiffusionPipeline(
								    unet=__lowerCamelCase							,scheduler=__lowerCamelCase							,vae=__lowerCamelCase							,text_encoder=__lowerCamelCase							,tokenizer=__lowerCamelCase							,safety_checker=__lowerCamelCase							,feature_extractor=self.dummy_extractor							,)
								a		=			sd_pipe.to(__lowerCamelCase					)
								sd_pipe.set_progress_bar_config(disable=__lowerCamelCase					)

								a		=			'''A painting of a squirrel eating a burger'''
								a		=			torch.Generator(device=__lowerCamelCase					).manual_seed(0					)
								a		=			sd_pipe([prompt]							,generator=__lowerCamelCase							,guidance_scale=6.0							,num_inference_steps=2							,output_type='''np'''					)

								a		=			output.images

								a		=			torch.Generator(device=__lowerCamelCase					).manual_seed(0					)
								a		=			sd_pipe(
								    [prompt]							,generator=__lowerCamelCase							,guidance_scale=6.0							,num_inference_steps=2							,output_type='''np'''							,return_dict=__lowerCamelCase							,)[0]

								a		=			image[0, -3:, -3:, -1]
								a		=			image_from_tuple[0, -3:, -3:, -1]

								assert image.shape == (1, 64, 64, 3)
								a		=			np.array([0.5_122, 0.5_712, 0.4_825, 0.5_053, 0.5_646, 0.4_769, 0.5_179, 0.4_894, 0.4_994]					)

								assert np.abs(image_slice.flatten() - expected_slice					).max() < 1e-2
								assert np.abs(image_from_tuple_slice.flatten() - expected_slice					).max() < 1e-2
							def  SCREAMING_SNAKE_CASE_ (						self		:					List[str]					):





								'''simple docstring'''



								a		=			StableDiffusionPipeline.from_pretrained(
								    '''hf-internal-testing/tiny-stable-diffusion-lms-pipe'''							,safety_checker=__lowerCamelCase					)
								assert isinstance(__lowerCamelCase							,__lowerCamelCase					)
								assert isinstance(pipe.scheduler							,__lowerCamelCase					)
								assert pipe.safety_checker is None

								a		=			pipe('''example prompt'''							,num_inference_steps=2					).images[0]
								assert image is not None

								# check that there's no error when saving a pipeline with one of the models being None
								with tempfile.TemporaryDirectory() as tmpdirname:
									pipe.save_pretrained(__lowerCamelCase					)
									a		=			StableDiffusionPipeline.from_pretrained(__lowerCamelCase					)

								# sanity check that the pipeline still works
								assert pipe.safety_checker is None
								a		=			pipe('''example prompt'''							,num_inference_steps=2					).images[0]
								assert image is not None




							@unittest.skipIf(torch_device != '''cuda'''							,'''This test requires a GPU'''					)
							def  SCREAMING_SNAKE_CASE_ (						self		:					Union[str, Any]					):





								'''simple docstring'''



								a		=			self.dummy_cond_unet
								a		=			PNDMScheduler(skip_prk_steps=__lowerCamelCase					)
								a		=			self.dummy_vae
								a		=			self.dummy_text_encoder
								a		=			CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''					)

								# put models in fp16
								a		=			unet.half()
								a		=			vae.half()
								a		=			bert.half()

								# make sure here that pndm scheduler skips prk
								a		=			StableDiffusionPipeline(
								    unet=__lowerCamelCase							,scheduler=__lowerCamelCase							,vae=__lowerCamelCase							,text_encoder=__lowerCamelCase							,tokenizer=__lowerCamelCase							,safety_checker=__lowerCamelCase							,feature_extractor=self.dummy_extractor							,)
								a		=			sd_pipe.to(__lowerCamelCase					)
								sd_pipe.set_progress_bar_config(disable=__lowerCamelCase					)

								a		=			'''A painting of a squirrel eating a burger'''
								a		=			sd_pipe([prompt]							,num_inference_steps=2							,output_type='''np'''					).images

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







@nightly
@require_torch_gpu
class 				lowerCamelCase_     (	unittest.TestCase     ):
							def  SCREAMING_SNAKE_CASE_ (						self		:					str					):





								'''simple docstring'''



								super().tearDown()
								gc.collect()
								torch.cuda.empty_cache()
							def  SCREAMING_SNAKE_CASE_ (						self		:					Any					):





								'''simple docstring'''



								a		=			'''cuda'''
								a		=			StableDiffusionPipeline.from_pretrained('''runwayml/stable-diffusion-v1-5'''					)
								a		=			pipe.to(__lowerCamelCase					)
								pipe.set_progress_bar_config(disable=__lowerCamelCase					)

								a		=			'''a photo of a cat'''
								a		=			{
								    '''editing_prompt''': ['''sunglasses'''],
								    '''reverse_editing_direction''': [False],
								    '''edit_warmup_steps''': 10,
								    '''edit_guidance_scale''': 6,
								    '''edit_threshold''': 0.95,
								    '''edit_momentum_scale''': 0.5,
								    '''edit_mom_beta''': 0.6,
								}

								a		=			3
								a		=			7

								# no sega enabled
								a		=			torch.Generator(__lowerCamelCase					)
								generator.manual_seed(__lowerCamelCase					)
								a		=			pipe(
								    [prompt]							,generator=__lowerCamelCase							,guidance_scale=__lowerCamelCase							,num_inference_steps=50							,output_type='''np'''							,width=5_12							,height=5_12							,)

								a		=			output.images
								a		=			image[0, -3:, -3:, -1]
								a		=			[
								    0.34_673_113,
								    0.38_492_733,
								    0.37_597_352,
								    0.34_086_335,
								    0.35_650_748,
								    0.35_579_205,
								    0.3_384_763,
								    0.34_340_236,
								    0.3_573_271,
								]

								assert image.shape == (1, 5_12, 5_12, 3)

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

								# with sega enabled
								# generator = torch.manual_seed(seed)
								generator.manual_seed(__lowerCamelCase					)
								a		=			pipe(
								    [prompt]							,generator=__lowerCamelCase							,guidance_scale=__lowerCamelCase							,num_inference_steps=50							,output_type='''np'''							,width=5_12							,height=5_12							,**__lowerCamelCase							,)

								a		=			output.images
								a		=			image[0, -3:, -3:, -1]
								a		=			[
								    0.41_887_826,
								    0.37_728_766,
								    0.30_138_272,
								    0.41_416_335,
								    0.41_664_985,
								    0.36_283_392,
								    0.36_191_246,
								    0.43_364_465,
								    0.43_001_732,
								]

								assert image.shape == (1, 5_12, 5_12, 3)

								assert np.abs(image_slice.flatten() - expected_slice					).max() < 1e-2
							def  SCREAMING_SNAKE_CASE_ (						self		:					Union[str, Any]					):





								'''simple docstring'''



								a		=			'''cuda'''
								a		=			StableDiffusionPipeline.from_pretrained('''runwayml/stable-diffusion-v1-5'''					)
								a		=			pipe.to(__lowerCamelCase					)
								pipe.set_progress_bar_config(disable=__lowerCamelCase					)

								a		=			'''an image of a crowded boulevard, realistic, 4k'''
								a		=			{
								    '''editing_prompt''': '''crowd, crowded, people''',
								    '''reverse_editing_direction''': True,
								    '''edit_warmup_steps''': 10,
								    '''edit_guidance_scale''': 8.3,
								    '''edit_threshold''': 0.9,
								    '''edit_momentum_scale''': 0.5,
								    '''edit_mom_beta''': 0.6,
								}

								a		=			9
								a		=			7

								# no sega enabled
								a		=			torch.Generator(__lowerCamelCase					)
								generator.manual_seed(__lowerCamelCase					)
								a		=			pipe(
								    [prompt]							,generator=__lowerCamelCase							,guidance_scale=__lowerCamelCase							,num_inference_steps=50							,output_type='''np'''							,width=5_12							,height=5_12							,)

								a		=			output.images
								a		=			image[0, -3:, -3:, -1]
								a		=			[
								    0.43_497_998,
								    0.91_814_065,
								    0.7_540_739,
								    0.55_580_205,
								    0.8_467_265,
								    0.5_389_691,
								    0.62_574_506,
								    0.58_897_763,
								    0.50_926_757,
								]

								assert image.shape == (1, 5_12, 5_12, 3)

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

								# with sega enabled
								# generator = torch.manual_seed(seed)
								generator.manual_seed(__lowerCamelCase					)
								a		=			pipe(
								    [prompt]							,generator=__lowerCamelCase							,guidance_scale=__lowerCamelCase							,num_inference_steps=50							,output_type='''np'''							,width=5_12							,height=5_12							,**__lowerCamelCase							,)

								a		=			output.images
								a		=			image[0, -3:, -3:, -1]
								a		=			[
								    0.3_089_719,
								    0.30_500_144,
								    0.29_016_042,
								    0.30_630_964,
								    0.325_687,
								    0.29_419_225,
								    0.2_908_091,
								    0.28_723_598,
								    0.27_696_294,
								]

								assert image.shape == (1, 5_12, 5_12, 3)

								assert np.abs(image_slice.flatten() - expected_slice					).max() < 1e-2
							def  SCREAMING_SNAKE_CASE_ (						self		:					Optional[Any]					):





								'''simple docstring'''



								a		=			'''cuda'''
								a		=			StableDiffusionPipeline.from_pretrained('''runwayml/stable-diffusion-v1-5'''					)
								a		=			pipe.to(__lowerCamelCase					)
								pipe.set_progress_bar_config(disable=__lowerCamelCase					)

								a		=			'''a castle next to a river'''
								a		=			{
								    '''editing_prompt''': ['''boat on a river, boat''', '''monet, impression, sunrise'''],
								    '''reverse_editing_direction''': False,
								    '''edit_warmup_steps''': [15, 18],
								    '''edit_guidance_scale''': 6,
								    '''edit_threshold''': [0.9, 0.8],
								    '''edit_momentum_scale''': 0.5,
								    '''edit_mom_beta''': 0.6,
								}

								a		=			48
								a		=			7

								# no sega enabled
								a		=			torch.Generator(__lowerCamelCase					)
								generator.manual_seed(__lowerCamelCase					)
								a		=			pipe(
								    [prompt]							,generator=__lowerCamelCase							,guidance_scale=__lowerCamelCase							,num_inference_steps=50							,output_type='''np'''							,width=5_12							,height=5_12							,)

								a		=			output.images
								a		=			image[0, -3:, -3:, -1]
								a		=			[
								    0.75_163_555,
								    0.76_037_145,
								    0.61_785,
								    0.9_189_673,
								    0.8_627_701,
								    0.85_189_694,
								    0.8_512_813,
								    0.87_012_076,
								    0.8_312_857,
								]

								assert image.shape == (1, 5_12, 5_12, 3)

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

								# with sega enabled
								# generator = torch.manual_seed(seed)
								generator.manual_seed(__lowerCamelCase					)
								a		=			pipe(
								    [prompt]							,generator=__lowerCamelCase							,guidance_scale=__lowerCamelCase							,num_inference_steps=50							,output_type='''np'''							,width=5_12							,height=5_12							,**__lowerCamelCase							,)

								a		=			output.images
								a		=			image[0, -3:, -3:, -1]
								a		=			[
								    0.73_553_365,
								    0.7_537_271,
								    0.74_341_905,
								    0.66_480_356,
								    0.6_472_925,
								    0.63_039_416,
								    0.64_812_905,
								    0.6_749_717,
								    0.6_517_102,
								]

								assert image.shape == (1, 5_12, 5_12, 3)

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




							def  SCREAMING_SNAKE_CASE_ (						self		:					Union[str, Any]					):





								'''simple docstring'''



								a		=			'''cuda'''
								a		=			StableDiffusionPipeline.from_pretrained('''runwayml/stable-diffusion-v1-5'''							,torch_dtype=torch.floataa					)
								a		=			pipe.to(__lowerCamelCase					)
								pipe.set_progress_bar_config(disable=__lowerCamelCase					)

								a		=			'''a photo of a cat'''
								a		=			{
								    '''editing_prompt''': ['''sunglasses'''],
								    '''reverse_editing_direction''': [False],
								    '''edit_warmup_steps''': 10,
								    '''edit_guidance_scale''': 6,
								    '''edit_threshold''': 0.95,
								    '''edit_momentum_scale''': 0.5,
								    '''edit_mom_beta''': 0.6,
								}

								a		=			3
								a		=			7

								# no sega enabled
								a		=			torch.Generator(__lowerCamelCase					)
								generator.manual_seed(__lowerCamelCase					)
								a		=			pipe(
								    [prompt]							,generator=__lowerCamelCase							,guidance_scale=__lowerCamelCase							,num_inference_steps=50							,output_type='''np'''							,width=5_12							,height=5_12							,)

								a		=			output.images
								a		=			image[0, -3:, -3:, -1]
								a		=			[
								    0.34_887_695,
								    0.3_876_953,
								    0.375,
								    0.34_423_828,
								    0.3_581_543,
								    0.35_717_773,
								    0.3_383_789,
								    0.34_570_312,
								    0.359_375,
								]

								assert image.shape == (1, 5_12, 5_12, 3)

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

								# with sega enabled
								# generator = torch.manual_seed(seed)
								generator.manual_seed(__lowerCamelCase					)
								a		=			pipe(
								    [prompt]							,generator=__lowerCamelCase							,guidance_scale=__lowerCamelCase							,num_inference_steps=50							,output_type='''np'''							,width=5_12							,height=5_12							,**__lowerCamelCase							,)

								a		=			output.images
								a		=			image[0, -3:, -3:, -1]
								a		=			[
								    0.42_285_156,
								    0.36_914_062,
								    0.29_077_148,
								    0.42_041_016,
								    0.41_918_945,
								    0.35_498_047,
								    0.3_618_164,
								    0.4_423_828,
								    0.43_115_234,
								]

								assert image.shape == (1, 5_12, 5_12, 3)

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













def   SCREAMING_SNAKE_CASE__						(   snake_case_  )   ->  int:


	"""simple docstring"""



	return n * (2 * n - 1)





def   SCREAMING_SNAKE_CASE__						(   snake_case_  )   ->  bool:


	"""simple docstring"""



	a		=			(1 + 2_4 * n) ** 0.5
	return ((1 + root) / 6) % 1 == 0





def   SCREAMING_SNAKE_CASE__						(   snake_case_ = 1_4_4  )   ->  int:


	"""simple docstring"""



	a		=			start
	a		=			hexagonal_num(snake_case_  )
	while not is_pentagonal(snake_case_  ):
		n += 1
		a		=			hexagonal_num(snake_case_  )
	return num


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





