



import warnings
from contextlib import contextmanager

from ...processing_utils import ProcessorMixin

class      UpperCAmelCase_						(     UpperCamelCase_ ):

						'''simple docstring'''




						UpperCamelCase__    :				Tuple       						=						['''image_processor''', '''tokenizer''']
						UpperCamelCase__    :				Tuple       						=						'''AutoImageProcessor'''
						UpperCamelCase__    :				Any       						=						'''AutoTokenizer'''






						def __init__(					self   ,							_A=None   ,							_A=None   ,							**_A	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      None
													if "feature_extractor" in kwargs:
																				warnings.warn(
																				    'The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`'
																				    ' instead.'   ,							_A   ,							)
																				__SCREAMING_SNAKE_CASE								=      kwargs.pop('feature_extractor'	)

													__SCREAMING_SNAKE_CASE								=      image_processor if image_processor is not None else feature_extractor
													if image_processor is None:
																				raise ValueError('You need to specify an `image_processor`.'	)
													if tokenizer is None:
																				raise ValueError('You need to specify a `tokenizer`.'	)

													super().__init__(_A   ,							_A	)
													__SCREAMING_SNAKE_CASE								=      self.image_processor
													__SCREAMING_SNAKE_CASE								=      False






						def __call__(					self   ,							*_A   ,							**_A	):







													'''simple docstring'''

													if self._in_target_context_manager:
																				return self.current_processor(*_A   ,							**_A	)

													__SCREAMING_SNAKE_CASE								=      kwargs.pop('images'   ,							_A	)
													__SCREAMING_SNAKE_CASE								=      kwargs.pop('text'   ,							_A	)
													if len(_A	) > 0:
																				__SCREAMING_SNAKE_CASE								=      args[0]
																				__SCREAMING_SNAKE_CASE								=      args[1:]

													if images is None and text is None:
																				raise ValueError('You need to specify either an `images` or `text` input to process.'	)

													if images is not None:
																				__SCREAMING_SNAKE_CASE								=      self.image_processor(_A   ,							*_A   ,							**_A	)
													if text is not None:
																				__SCREAMING_SNAKE_CASE								=      self.tokenizer(_A   ,							**_A	)

													if text is None:
																				return inputs
													elif images is None:
																				return encodings
													else:
																				__SCREAMING_SNAKE_CASE								=      encodings['input_ids']
																				return inputs






						def  _A			(					self   ,							*_A   ,							**_A	):







													'''simple docstring'''

													return self.tokenizer.batch_decode(*_A   ,							**_A	)






						def  _A			(					self   ,							*_A   ,							**_A	):







													'''simple docstring'''

													return self.tokenizer.decode(*_A   ,							**_A	)






						@contextmanager
						def  _A			(					self	):







													'''simple docstring'''

													warnings.warn(
													    '`as_target_processor` is deprecated and will be removed in v5 of Transformers. You can process your '
													    'labels by using the argument `text` of the regular `__call__` method (either in the same call as '
													    'your images inputs, or in a separate call.'	)
													__SCREAMING_SNAKE_CASE								=      True
													__SCREAMING_SNAKE_CASE								=      self.tokenizer
													yield
													__SCREAMING_SNAKE_CASE								=      self.image_processor
													__SCREAMING_SNAKE_CASE								=      False






						@property
						def  _A			(					self	):







													'''simple docstring'''

													warnings.warn(
													    '`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead.'   ,							_A   ,							)
													return self.image_processor_class






						@property
						def  _A			(					self	):







													'''simple docstring'''

													warnings.warn(
													    '`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead.'   ,							_A   ,							)
													return self.image_processor











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

						'''simple docstring'''




						def  _A			(					self	):







													'''simple docstring'''

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






						@property
						def  _A			(					self	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      1
													__SCREAMING_SNAKE_CASE								=      3
													__SCREAMING_SNAKE_CASE								=      (32, 32)

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






						@property
						def  _A			(					self	):







													'''simple docstring'''

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







													'''simple docstring'''

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







													'''simple docstring'''

													torch.manual_seed(0	)
													__SCREAMING_SNAKE_CASE								=      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=1_000   ,							)
													return CLIPTextModel(_A	)






						@property
						def  _A			(					self	):







													'''simple docstring'''

													def extract(*_A   ,							**_A	):

																				class      UpperCAmelCase_						:

																										'''simple docstring'''




																										def __init__(					self	):







																																	'''simple docstring'''

																																	__SCREAMING_SNAKE_CASE								=      torch.ones([0]	)






																										def  _A			(					self   ,							_A	):







																																	'''simple docstring'''

																																	self.pixel_values.to(_A	)
																																	return self







																				return Out()

													return extract






						def  _A			(					self	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      'cpu'  # ensure determinism for the device-dependent torch.Generator
													__SCREAMING_SNAKE_CASE								=      self.dummy_cond_unet
													__SCREAMING_SNAKE_CASE								=      DDIMScheduler(
													    beta_start=0.0_0_0_8_5   ,							beta_end=0.0_1_2   ,							beta_schedule='scaled_linear'   ,							clip_sample=_A   ,							set_alpha_to_one=_A   ,							)

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

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

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

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

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

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

													assert image.shape == (1, 64, 64, 3)
													__SCREAMING_SNAKE_CASE								=      np.array([0.5_7_5_3, 0.6_1_1_4, 0.5_0_0_1, 0.5_0_3_4, 0.5_4_7_0, 0.4_7_2_9, 0.4_9_7_1, 0.4_8_6_7, 0.4_8_6_7]	)

													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  _A			(					self	):







													'''simple docstring'''

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

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

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

													__SCREAMING_SNAKE_CASE								=      output.images

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

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

													assert image.shape == (1, 64, 64, 3)
													__SCREAMING_SNAKE_CASE								=      np.array([0.5_1_2_2, 0.5_7_1_2, 0.4_8_2_5, 0.5_0_5_3, 0.5_6_4_6, 0.4_7_6_9, 0.5_1_7_9, 0.4_8_9_4, 0.4_9_9_4]	)

													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  _A			(					self	):







													'''simple docstring'''

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

													__SCREAMING_SNAKE_CASE								=      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(_A	)
																				__SCREAMING_SNAKE_CASE								=      StableDiffusionPipeline.from_pretrained(_A	)

													# sanity check that the pipeline still works
													assert pipe.safety_checker is None
													__SCREAMING_SNAKE_CASE								=      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  _A			(					self	):







													'''simple docstring'''

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

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

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

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

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







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

						'''simple docstring'''




						def  _A			(					self	):







													'''simple docstring'''

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






						def  _A			(					self	):







													'''simple docstring'''

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

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

													__SCREAMING_SNAKE_CASE								=      3
													__SCREAMING_SNAKE_CASE								=      7

													# no sega enabled
													__SCREAMING_SNAKE_CASE								=      torch.Generator(_A	)
													generator.manual_seed(_A	)
													__SCREAMING_SNAKE_CASE								=      pipe(
													    [prompt]   ,							generator=_A   ,							guidance_scale=_A   ,							num_inference_steps=50   ,							output_type='np'   ,							width=512   ,							height=512   ,							)

													__SCREAMING_SNAKE_CASE								=      output.images
													__SCREAMING_SNAKE_CASE								=      image[0, -3:, -3:, -1]
													__SCREAMING_SNAKE_CASE								=      [
													    0.3_4_6_7_3_1_1_3,
													    0.3_8_4_9_2_7_3_3,
													    0.3_7_5_9_7_3_5_2,
													    0.3_4_0_8_6_3_3_5,
													    0.3_5_6_5_0_7_4_8,
													    0.3_5_5_7_9_2_0_5,
													    0.3_3_8_4_7_6_3,
													    0.3_4_3_4_0_2_3_6,
													    0.3_5_7_3_2_7_1,
													]

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

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

													# with sega enabled
													# generator = torch.manual_seed(seed)
													generator.manual_seed(_A	)
													__SCREAMING_SNAKE_CASE								=      pipe(
													    [prompt]   ,							generator=_A   ,							guidance_scale=_A   ,							num_inference_steps=50   ,							output_type='np'   ,							width=512   ,							height=512   ,							**_A   ,							)

													__SCREAMING_SNAKE_CASE								=      output.images
													__SCREAMING_SNAKE_CASE								=      image[0, -3:, -3:, -1]
													__SCREAMING_SNAKE_CASE								=      [
													    0.4_1_8_8_7_8_2_6,
													    0.3_7_7_2_8_7_6_6,
													    0.3_0_1_3_8_2_7_2,
													    0.4_1_4_1_6_3_3_5,
													    0.4_1_6_6_4_9_8_5,
													    0.3_6_2_8_3_3_9_2,
													    0.3_6_1_9_1_2_4_6,
													    0.4_3_3_6_4_4_6_5,
													    0.4_3_0_0_1_7_3_2,
													]

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

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






						def  _A			(					self	):







													'''simple docstring'''

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

													__SCREAMING_SNAKE_CASE								=      'an image of a crowded boulevard, realistic, 4k'
													__SCREAMING_SNAKE_CASE								=      {
													    '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,
													}

													__SCREAMING_SNAKE_CASE								=      9
													__SCREAMING_SNAKE_CASE								=      7

													# no sega enabled
													__SCREAMING_SNAKE_CASE								=      torch.Generator(_A	)
													generator.manual_seed(_A	)
													__SCREAMING_SNAKE_CASE								=      pipe(
													    [prompt]   ,							generator=_A   ,							guidance_scale=_A   ,							num_inference_steps=50   ,							output_type='np'   ,							width=512   ,							height=512   ,							)

													__SCREAMING_SNAKE_CASE								=      output.images
													__SCREAMING_SNAKE_CASE								=      image[0, -3:, -3:, -1]
													__SCREAMING_SNAKE_CASE								=      [
													    0.4_3_4_9_7_9_9_8,
													    0.9_1_8_1_4_0_6_5,
													    0.7_5_4_0_7_3_9,
													    0.5_5_5_8_0_2_0_5,
													    0.8_4_6_7_2_6_5,
													    0.5_3_8_9_6_9_1,
													    0.6_2_5_7_4_5_0_6,
													    0.5_8_8_9_7_7_6_3,
													    0.5_0_9_2_6_7_5_7,
													]

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

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

													# with sega enabled
													# generator = torch.manual_seed(seed)
													generator.manual_seed(_A	)
													__SCREAMING_SNAKE_CASE								=      pipe(
													    [prompt]   ,							generator=_A   ,							guidance_scale=_A   ,							num_inference_steps=50   ,							output_type='np'   ,							width=512   ,							height=512   ,							**_A   ,							)

													__SCREAMING_SNAKE_CASE								=      output.images
													__SCREAMING_SNAKE_CASE								=      image[0, -3:, -3:, -1]
													__SCREAMING_SNAKE_CASE								=      [
													    0.3_0_8_9_7_1_9,
													    0.3_0_5_0_0_1_4_4,
													    0.2_9_0_1_6_0_4_2,
													    0.3_0_6_3_0_9_6_4,
													    0.3_2_5_6_8_7,
													    0.2_9_4_1_9_2_2_5,
													    0.2_9_0_8_0_9_1,
													    0.2_8_7_2_3_5_9_8,
													    0.2_7_6_9_6_2_9_4,
													]

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

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






						def  _A			(					self	):







													'''simple docstring'''

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

													__SCREAMING_SNAKE_CASE								=      'a castle next to a river'
													__SCREAMING_SNAKE_CASE								=      {
													    '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,
													}

													__SCREAMING_SNAKE_CASE								=      48
													__SCREAMING_SNAKE_CASE								=      7

													# no sega enabled
													__SCREAMING_SNAKE_CASE								=      torch.Generator(_A	)
													generator.manual_seed(_A	)
													__SCREAMING_SNAKE_CASE								=      pipe(
													    [prompt]   ,							generator=_A   ,							guidance_scale=_A   ,							num_inference_steps=50   ,							output_type='np'   ,							width=512   ,							height=512   ,							)

													__SCREAMING_SNAKE_CASE								=      output.images
													__SCREAMING_SNAKE_CASE								=      image[0, -3:, -3:, -1]
													__SCREAMING_SNAKE_CASE								=      [
													    0.7_5_1_6_3_5_5_5,
													    0.7_6_0_3_7_1_4_5,
													    0.6_1_7_8_5,
													    0.9_1_8_9_6_7_3,
													    0.8_6_2_7_7_0_1,
													    0.8_5_1_8_9_6_9_4,
													    0.8_5_1_2_8_1_3,
													    0.8_7_0_1_2_0_7_6,
													    0.8_3_1_2_8_5_7,
													]

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

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

													# with sega enabled
													# generator = torch.manual_seed(seed)
													generator.manual_seed(_A	)
													__SCREAMING_SNAKE_CASE								=      pipe(
													    [prompt]   ,							generator=_A   ,							guidance_scale=_A   ,							num_inference_steps=50   ,							output_type='np'   ,							width=512   ,							height=512   ,							**_A   ,							)

													__SCREAMING_SNAKE_CASE								=      output.images
													__SCREAMING_SNAKE_CASE								=      image[0, -3:, -3:, -1]
													__SCREAMING_SNAKE_CASE								=      [
													    0.7_3_5_5_3_3_6_5,
													    0.7_5_3_7_2_7_1,
													    0.7_4_3_4_1_9_0_5,
													    0.6_6_4_8_0_3_5_6,
													    0.6_4_7_2_9_2_5,
													    0.6_3_0_3_9_4_1_6,
													    0.6_4_8_1_2_9_0_5,
													    0.6_7_4_9_7_1_7,
													    0.6_5_1_7_1_0_2,
													]

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

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






						def  _A			(					self	):







													'''simple docstring'''

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

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

													__SCREAMING_SNAKE_CASE								=      3
													__SCREAMING_SNAKE_CASE								=      7

													# no sega enabled
													__SCREAMING_SNAKE_CASE								=      torch.Generator(_A	)
													generator.manual_seed(_A	)
													__SCREAMING_SNAKE_CASE								=      pipe(
													    [prompt]   ,							generator=_A   ,							guidance_scale=_A   ,							num_inference_steps=50   ,							output_type='np'   ,							width=512   ,							height=512   ,							)

													__SCREAMING_SNAKE_CASE								=      output.images
													__SCREAMING_SNAKE_CASE								=      image[0, -3:, -3:, -1]
													__SCREAMING_SNAKE_CASE								=      [
													    0.3_4_8_8_7_6_9_5,
													    0.3_8_7_6_9_5_3,
													    0.3_7_5,
													    0.3_4_4_2_3_8_2_8,
													    0.3_5_8_1_5_4_3,
													    0.3_5_7_1_7_7_7_3,
													    0.3_3_8_3_7_8_9,
													    0.3_4_5_7_0_3_1_2,
													    0.3_5_9_3_7_5,
													]

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

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

													# with sega enabled
													# generator = torch.manual_seed(seed)
													generator.manual_seed(_A	)
													__SCREAMING_SNAKE_CASE								=      pipe(
													    [prompt]   ,							generator=_A   ,							guidance_scale=_A   ,							num_inference_steps=50   ,							output_type='np'   ,							width=512   ,							height=512   ,							**_A   ,							)

													__SCREAMING_SNAKE_CASE								=      output.images
													__SCREAMING_SNAKE_CASE								=      image[0, -3:, -3:, -1]
													__SCREAMING_SNAKE_CASE								=      [
													    0.4_2_2_8_5_1_5_6,
													    0.3_6_9_1_4_0_6_2,
													    0.2_9_0_7_7_1_4_8,
													    0.4_2_0_4_1_0_1_6,
													    0.4_1_9_1_8_9_4_5,
													    0.3_5_4_9_8_0_4_7,
													    0.3_6_1_8_1_6_4,
													    0.4_4_2_3_8_2_8,
													    0.4_3_1_1_5_2_3_4,
													]

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

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






