"""simple docstring"""




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







				def   lowercase_		(    self    :List[Any]  )      ->					Tuple:




									"""simple docstring"""



									super().tearDown()
									gc.collect()
									torch.cuda.empty_cache()







				@property
				def   lowercase_		(    self    :Any  )      ->					Union[str, Any]:




									"""simple docstring"""



									lowerCamelCase__		:   Optional[Any]  				=					1
									lowerCamelCase__		:   Dict  				=					3
									lowerCamelCase__		:   List[str]  				=					(32, 32)

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







				@property
				def   lowercase_		(    self    :List[str]  )      ->					int:




									"""simple docstring"""



									torch.manual_seed(0  )
									lowerCamelCase__		:   Dict  				=					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   lowercase_		(    self    :Optional[int]  )      ->					Optional[Any]:




									"""simple docstring"""



									torch.manual_seed(0  )
									lowerCamelCase__		:   str  				=					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   lowercase_		(    self    :str  )      ->					Union[str, Any]:




									"""simple docstring"""



									torch.manual_seed(0  )
									lowerCamelCase__		:   Tuple  				=					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(__UpperCAmelCase  )







				@property
				def   lowercase_		(    self    :Any  )      ->					str:




									"""simple docstring"""



									def extract(*__UpperCAmelCase    :Tuple      ,**__UpperCAmelCase    :Tuple  ):

														class        __SCREAMING_SNAKE_CASE     :







																		def __init__(    self    :str  )      ->					Optional[Any]:




																							"""simple docstring"""



																							lowerCamelCase__		:   Any  				=					torch.ones([0]  )







																		def   lowercase_		(    self    :str      ,__UpperCAmelCase    :Tuple  )      ->					Union[str, Any]:




																							"""simple docstring"""



																							self.pixel_values.to(__UpperCAmelCase  )
																							return self





														return Out()

									return extract







				def   lowercase_		(    self    :int  )      ->					int:




									"""simple docstring"""



									lowerCamelCase__		:   Optional[int]  				=					'''cpu'''  # ensure determinism for the device-dependent torch.Generator
									lowerCamelCase__		:   Any  				=					self.dummy_cond_unet
									lowerCamelCase__		:   Dict  				=					DDIMScheduler(
									    beta_start=0.00_085      ,beta_end=0.012      ,beta_schedule='''scaled_linear'''      ,clip_sample=__UpperCAmelCase      ,set_alpha_to_one=__UpperCAmelCase      ,)

									lowerCamelCase__		:   Any  				=					self.dummy_vae
									lowerCamelCase__		:   Union[str, Any]  				=					self.dummy_text_encoder
									lowerCamelCase__		:   str  				=					CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''  )

									# make sure here that pndm scheduler skips prk
									lowerCamelCase__		:   Any  				=					StableDiffusionPipeline(
									    unet=__UpperCAmelCase      ,scheduler=__UpperCAmelCase      ,vae=__UpperCAmelCase      ,text_encoder=__UpperCAmelCase      ,tokenizer=__UpperCAmelCase      ,safety_checker=__UpperCAmelCase      ,feature_extractor=self.dummy_extractor      ,)
									lowerCamelCase__		:   Tuple  				=					sd_pipe.to(__UpperCAmelCase  )
									sd_pipe.set_progress_bar_config(disable=__UpperCAmelCase  )

									lowerCamelCase__		:   Any  				=					'''A painting of a squirrel eating a burger'''

									lowerCamelCase__		:   Tuple  				=					torch.Generator(device=__UpperCAmelCase  ).manual_seed(0  )
									lowerCamelCase__		:   Optional[Any]  				=					sd_pipe([prompt]      ,generator=__UpperCAmelCase      ,guidance_scale=6.0      ,num_inference_steps=2      ,output_type='''np'''  )
									lowerCamelCase__		:   Tuple  				=					output.images

									lowerCamelCase__		:   Union[str, Any]  				=					torch.Generator(device=__UpperCAmelCase  ).manual_seed(0  )
									lowerCamelCase__		:   Tuple  				=					sd_pipe(
									    [prompt]      ,generator=__UpperCAmelCase      ,guidance_scale=6.0      ,num_inference_steps=2      ,output_type='''np'''      ,return_dict=__UpperCAmelCase      ,)[0]

									lowerCamelCase__		:   List[Any]  				=					image[0, -3:, -3:, -1]
									lowerCamelCase__		:   str  				=					image_from_tuple[0, -3:, -3:, -1]

									assert image.shape == (1, 64, 64, 3)
									lowerCamelCase__		:   Any  				=					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   lowercase_		(    self    :Optional[int]  )      ->					List[str]:




									"""simple docstring"""



									lowerCamelCase__		:   Tuple  				=					'''cpu'''  # ensure determinism for the device-dependent torch.Generator
									lowerCamelCase__		:   Optional[Any]  				=					self.dummy_cond_unet
									lowerCamelCase__		:   Dict  				=					PNDMScheduler(skip_prk_steps=__UpperCAmelCase  )
									lowerCamelCase__		:   List[str]  				=					self.dummy_vae
									lowerCamelCase__		:   List[str]  				=					self.dummy_text_encoder
									lowerCamelCase__		:   List[str]  				=					CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''  )

									# make sure here that pndm scheduler skips prk
									lowerCamelCase__		:   int  				=					StableDiffusionPipeline(
									    unet=__UpperCAmelCase      ,scheduler=__UpperCAmelCase      ,vae=__UpperCAmelCase      ,text_encoder=__UpperCAmelCase      ,tokenizer=__UpperCAmelCase      ,safety_checker=__UpperCAmelCase      ,feature_extractor=self.dummy_extractor      ,)
									lowerCamelCase__		:   List[Any]  				=					sd_pipe.to(__UpperCAmelCase  )
									sd_pipe.set_progress_bar_config(disable=__UpperCAmelCase  )

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

									lowerCamelCase__		:   Any  				=					output.images

									lowerCamelCase__		:   Any  				=					torch.Generator(device=__UpperCAmelCase  ).manual_seed(0  )
									lowerCamelCase__		:   List[Any]  				=					sd_pipe(
									    [prompt]      ,generator=__UpperCAmelCase      ,guidance_scale=6.0      ,num_inference_steps=2      ,output_type='''np'''      ,return_dict=__UpperCAmelCase      ,)[0]

									lowerCamelCase__		:   str  				=					image[0, -3:, -3:, -1]
									lowerCamelCase__		:   Optional[Any]  				=					image_from_tuple[0, -3:, -3:, -1]

									assert image.shape == (1, 64, 64, 3)
									lowerCamelCase__		:   Any  				=					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   lowercase_		(    self    :int  )      ->					Optional[int]:




									"""simple docstring"""



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

									lowerCamelCase__		:   Dict  				=					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(__UpperCAmelCase  )
														lowerCamelCase__		:   str  				=					StableDiffusionPipeline.from_pretrained(__UpperCAmelCase  )

									# sanity check that the pipeline still works
									assert pipe.safety_checker is None
									lowerCamelCase__		:   List[Any]  				=					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   lowercase_		(    self    :List[str]  )      ->					Any:




									"""simple docstring"""



									lowerCamelCase__		:   Union[str, Any]  				=					self.dummy_cond_unet
									lowerCamelCase__		:   Tuple  				=					PNDMScheduler(skip_prk_steps=__UpperCAmelCase  )
									lowerCamelCase__		:   Optional[int]  				=					self.dummy_vae
									lowerCamelCase__		:   int  				=					self.dummy_text_encoder
									lowerCamelCase__		:   Dict  				=					CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''  )

									# put models in fp16
									lowerCamelCase__		:   int  				=					unet.half()
									lowerCamelCase__		:   Optional[int]  				=					vae.half()
									lowerCamelCase__		:   List[Any]  				=					bert.half()

									# make sure here that pndm scheduler skips prk
									lowerCamelCase__		:   List[str]  				=					StableDiffusionPipeline(
									    unet=__UpperCAmelCase      ,scheduler=__UpperCAmelCase      ,vae=__UpperCAmelCase      ,text_encoder=__UpperCAmelCase      ,tokenizer=__UpperCAmelCase      ,safety_checker=__UpperCAmelCase      ,feature_extractor=self.dummy_extractor      ,)
									lowerCamelCase__		:   str  				=					sd_pipe.to(__UpperCAmelCase  )
									sd_pipe.set_progress_bar_config(disable=__UpperCAmelCase  )

									lowerCamelCase__		:   List[Any]  				=					'''A painting of a squirrel eating a burger'''
									lowerCamelCase__		:   Optional[int]  				=					sd_pipe([prompt]      ,num_inference_steps=2      ,output_type='''np'''  ).images

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





@nightly
@require_torch_gpu
class        __SCREAMING_SNAKE_CASE     (   unittest.TestCase							):







				def   lowercase_		(    self    :Optional[Any]  )      ->					str:




									"""simple docstring"""



									super().tearDown()
									gc.collect()
									torch.cuda.empty_cache()







				def   lowercase_		(    self    :List[Any]  )      ->					List[Any]:




									"""simple docstring"""



									lowerCamelCase__		:   Any  				=					'''cuda'''
									lowerCamelCase__		:   Dict  				=					StableDiffusionPipeline.from_pretrained('''runwayml/stable-diffusion-v1-5'''  )
									lowerCamelCase__		:   List[str]  				=					pipe.to(__UpperCAmelCase  )
									pipe.set_progress_bar_config(disable=__UpperCAmelCase  )

									lowerCamelCase__		:   Dict  				=					'''a photo of a cat'''
									lowerCamelCase__		:   Optional[int]  				=					{
									    '''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,
									}

									lowerCamelCase__		:   List[str]  				=					3
									lowerCamelCase__		:   int  				=					7

									# no sega enabled
									lowerCamelCase__		:   List[Any]  				=					torch.Generator(__UpperCAmelCase  )
									generator.manual_seed(__UpperCAmelCase  )
									lowerCamelCase__		:   str  				=					pipe(
									    [prompt]      ,generator=__UpperCAmelCase      ,guidance_scale=__UpperCAmelCase      ,num_inference_steps=50      ,output_type='''np'''      ,width=5_12      ,height=5_12      ,)

									lowerCamelCase__		:   str  				=					output.images
									lowerCamelCase__		:   str  				=					image[0, -3:, -3:, -1]
									lowerCamelCase__		:   Tuple  				=					[
									    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(__UpperCAmelCase  )
									lowerCamelCase__		:   List[Any]  				=					pipe(
									    [prompt]      ,generator=__UpperCAmelCase      ,guidance_scale=__UpperCAmelCase      ,num_inference_steps=50      ,output_type='''np'''      ,width=5_12      ,height=5_12      ,**__UpperCAmelCase      ,)

									lowerCamelCase__		:   Union[str, Any]  				=					output.images
									lowerCamelCase__		:   Optional[int]  				=					image[0, -3:, -3:, -1]
									lowerCamelCase__		:   int  				=					[
									    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   lowercase_		(    self    :Optional[int]  )      ->					Optional[int]:




									"""simple docstring"""



									lowerCamelCase__		:   Dict  				=					'''cuda'''
									lowerCamelCase__		:   Any  				=					StableDiffusionPipeline.from_pretrained('''runwayml/stable-diffusion-v1-5'''  )
									lowerCamelCase__		:   str  				=					pipe.to(__UpperCAmelCase  )
									pipe.set_progress_bar_config(disable=__UpperCAmelCase  )

									lowerCamelCase__		:   Optional[int]  				=					'''an image of a crowded boulevard, realistic, 4k'''
									lowerCamelCase__		:   List[str]  				=					{
									    '''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,
									}

									lowerCamelCase__		:   Tuple  				=					9
									lowerCamelCase__		:   Optional[Any]  				=					7

									# no sega enabled
									lowerCamelCase__		:   Any  				=					torch.Generator(__UpperCAmelCase  )
									generator.manual_seed(__UpperCAmelCase  )
									lowerCamelCase__		:   Optional[int]  				=					pipe(
									    [prompt]      ,generator=__UpperCAmelCase      ,guidance_scale=__UpperCAmelCase      ,num_inference_steps=50      ,output_type='''np'''      ,width=5_12      ,height=5_12      ,)

									lowerCamelCase__		:   List[str]  				=					output.images
									lowerCamelCase__		:   List[Any]  				=					image[0, -3:, -3:, -1]
									lowerCamelCase__		:   Dict  				=					[
									    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(__UpperCAmelCase  )
									lowerCamelCase__		:   int  				=					pipe(
									    [prompt]      ,generator=__UpperCAmelCase      ,guidance_scale=__UpperCAmelCase      ,num_inference_steps=50      ,output_type='''np'''      ,width=5_12      ,height=5_12      ,**__UpperCAmelCase      ,)

									lowerCamelCase__		:   str  				=					output.images
									lowerCamelCase__		:   Dict  				=					image[0, -3:, -3:, -1]
									lowerCamelCase__		:   Dict  				=					[
									    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   lowercase_		(    self    :Tuple  )      ->					int:




									"""simple docstring"""



									lowerCamelCase__		:   Any  				=					'''cuda'''
									lowerCamelCase__		:   Dict  				=					StableDiffusionPipeline.from_pretrained('''runwayml/stable-diffusion-v1-5'''  )
									lowerCamelCase__		:   Optional[int]  				=					pipe.to(__UpperCAmelCase  )
									pipe.set_progress_bar_config(disable=__UpperCAmelCase  )

									lowerCamelCase__		:   List[Any]  				=					'''a castle next to a river'''
									lowerCamelCase__		:   str  				=					{
									    '''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,
									}

									lowerCamelCase__		:   Tuple  				=					48
									lowerCamelCase__		:   Union[str, Any]  				=					7

									# no sega enabled
									lowerCamelCase__		:   Tuple  				=					torch.Generator(__UpperCAmelCase  )
									generator.manual_seed(__UpperCAmelCase  )
									lowerCamelCase__		:   int  				=					pipe(
									    [prompt]      ,generator=__UpperCAmelCase      ,guidance_scale=__UpperCAmelCase      ,num_inference_steps=50      ,output_type='''np'''      ,width=5_12      ,height=5_12      ,)

									lowerCamelCase__		:   str  				=					output.images
									lowerCamelCase__		:   str  				=					image[0, -3:, -3:, -1]
									lowerCamelCase__		:   Optional[Any]  				=					[
									    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(__UpperCAmelCase  )
									lowerCamelCase__		:   Optional[int]  				=					pipe(
									    [prompt]      ,generator=__UpperCAmelCase      ,guidance_scale=__UpperCAmelCase      ,num_inference_steps=50      ,output_type='''np'''      ,width=5_12      ,height=5_12      ,**__UpperCAmelCase      ,)

									lowerCamelCase__		:   List[str]  				=					output.images
									lowerCamelCase__		:   Dict  				=					image[0, -3:, -3:, -1]
									lowerCamelCase__		:   List[Any]  				=					[
									    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   lowercase_		(    self    :Any  )      ->					str:




									"""simple docstring"""



									lowerCamelCase__		:   Optional[Any]  				=					'''cuda'''
									lowerCamelCase__		:   List[Any]  				=					StableDiffusionPipeline.from_pretrained('''runwayml/stable-diffusion-v1-5'''      ,torch_dtype=torch.floataa  )
									lowerCamelCase__		:   Union[str, Any]  				=					pipe.to(__UpperCAmelCase  )
									pipe.set_progress_bar_config(disable=__UpperCAmelCase  )

									lowerCamelCase__		:   str  				=					'''a photo of a cat'''
									lowerCamelCase__		:   Optional[int]  				=					{
									    '''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,
									}

									lowerCamelCase__		:   str  				=					3
									lowerCamelCase__		:   Optional[Any]  				=					7

									# no sega enabled
									lowerCamelCase__		:   List[str]  				=					torch.Generator(__UpperCAmelCase  )
									generator.manual_seed(__UpperCAmelCase  )
									lowerCamelCase__		:   Union[str, Any]  				=					pipe(
									    [prompt]      ,generator=__UpperCAmelCase      ,guidance_scale=__UpperCAmelCase      ,num_inference_steps=50      ,output_type='''np'''      ,width=5_12      ,height=5_12      ,)

									lowerCamelCase__		:   Optional[int]  				=					output.images
									lowerCamelCase__		:   Dict  				=					image[0, -3:, -3:, -1]
									lowerCamelCase__		:   Tuple  				=					[
									    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(__UpperCAmelCase  )
									lowerCamelCase__		:   int  				=					pipe(
									    [prompt]      ,generator=__UpperCAmelCase      ,guidance_scale=__UpperCAmelCase      ,num_inference_steps=50      ,output_type='''np'''      ,width=5_12      ,height=5_12      ,**__UpperCAmelCase      ,)

									lowerCamelCase__		:   Any  				=					output.images
									lowerCamelCase__		:   List[Any]  				=					image[0, -3:, -3:, -1]
									lowerCamelCase__		:   Tuple  				=					[
									    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







"""simple docstring"""




from collections.abc import Callable

UpperCAmelCase       :    Optional[int]									=			Callable[[float], float]  # type alias for a real -> real function



def 				__a       (			_lowercase							, _lowercase							, _lowercase							, ):







					"""simple docstring"""





					lowerCamelCase__		:   Tuple  				=					float(_lowercase						)
					while True:
										try:
															lowerCamelCase__		:   str  				=					prev_guess - function(_lowercase						) / derivative(_lowercase						)
										except ZeroDivisionError:
															raise ZeroDivisionError('''Could not find root'''						) from None
										if abs(prev_guess - next_guess						) < 10**-5:
															return next_guess
										lowerCamelCase__		:   List[str]  				=					next_guess



def 				__a       (			_lowercase						):







					"""simple docstring"""





					return (x**3) - (2 * x) - 5



def 				__a       (			_lowercase						):







					"""simple docstring"""





					return 3 * (x**2) - 2


if __name__ == "__main__":
					print(newton(f, fa, 3))






