





'''simple docstring'''







import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    EulerAncestralDiscreteScheduler,
    PNDMScheduler,
    StableDiffusionModelEditingPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu, skip_mps

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineKarrasSchedulerTesterMixin, PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()


@skip_mps
class        __a   (lowerCamelCase							,		lowerCamelCase							,		lowerCamelCase							,		unittest.TestCase  ):
							__a       : str          =							StableDiffusionModelEditingPipeline
							__a       : Optional[int]          =							TEXT_TO_IMAGE_PARAMS
							__a       : Any          =							TEXT_TO_IMAGE_BATCH_PARAMS
							__a       : int          =							TEXT_TO_IMAGE_IMAGE_PARAMS
							__a       : Union[str, Any]          =							TEXT_TO_IMAGE_IMAGE_PARAMS

							def      UpperCAmelCase__						(				self				:  str )       ->							Dict:







													"""simple docstring"""
													torch.manual_seed(0 )
													UpperCAmelCase_      :   List[Any]      =	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							,  )
													UpperCAmelCase_      :   str      =	DDIMScheduler()
													torch.manual_seed(0 )
													UpperCAmelCase_      :   Any      =	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							,  )
													torch.manual_seed(0 )
													UpperCAmelCase_      :   List[Any]      =	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							,  )
													UpperCAmelCase_      :   Dict      =	CLIPTextModel(__magic_name__ )
													UpperCAmelCase_      :   str      =	CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip''' )

													UpperCAmelCase_      :   Tuple      =	{
													    """unet""": unet,
													    """scheduler""": scheduler,
													    """vae""": vae,
													    """text_encoder""": text_encoder,
													    """tokenizer""": tokenizer,
													    """safety_checker""": None,
													    """feature_extractor""": None,
													}
													return components

							def      UpperCAmelCase__						(				self				:  Any							,  __magic_name__				:  Optional[Any]							,  __magic_name__				:  Optional[Any]=0 )       ->							List[str]:







													"""simple docstring"""
													UpperCAmelCase_      :   List[Any]      =	torch.manual_seed(__magic_name__ )
													UpperCAmelCase_      :   Tuple      =	{
													    """prompt""": """A field of roses""",
													    """generator""": generator,
													    # Setting height and width to None to prevent OOMs on CPU.
													    """height""": None,
													    """width""": None,
													    """num_inference_steps""": 2,
													    """guidance_scale""": 6.0,
													    """output_type""": """numpy""",
													}
													return inputs

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







													"""simple docstring"""
													UpperCAmelCase_      :   int      =	"""cpu"""  # ensure determinism for the device-dependent torch.Generator
													UpperCAmelCase_      :   Union[str, Any]      =	self.get_dummy_components()
													UpperCAmelCase_      :   Union[str, Any]      =	StableDiffusionModelEditingPipeline(**__magic_name__ )
													UpperCAmelCase_      :   Dict      =	sd_pipe.to(__magic_name__ )
													sd_pipe.set_progress_bar_config(disable=__magic_name__ )

													UpperCAmelCase_      :   int      =	self.get_dummy_inputs(__magic_name__ )
													UpperCAmelCase_      :   Dict      =	sd_pipe(**__magic_name__ ).images
													UpperCAmelCase_      :   List[Any]      =	image[0, -3:, -3:, -1]
													assert image.shape == (1, 64, 64, 3)

													UpperCAmelCase_      :   Union[str, Any]      =	np.array([0.4_7_5_5, 0.5_1_3_2, 0.4_9_7_6, 0.3_9_0_4, 0.3_5_5_4, 0.4_7_6_5, 0.5_1_3_9, 0.5_1_5_8, 0.4_8_8_9] )

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

							def      UpperCAmelCase__						(				self				:  Union[str, Any] )       ->							Optional[Any]:







													"""simple docstring"""
													UpperCAmelCase_      :   int      =	"""cpu"""  # ensure determinism for the device-dependent torch.Generator
													UpperCAmelCase_      :   Dict      =	self.get_dummy_components()
													UpperCAmelCase_      :   Optional[Any]      =	StableDiffusionModelEditingPipeline(**__magic_name__ )
													UpperCAmelCase_      :   Dict      =	sd_pipe.to(__magic_name__ )
													sd_pipe.set_progress_bar_config(disable=__magic_name__ )

													UpperCAmelCase_      :   Optional[Any]      =	self.get_dummy_inputs(__magic_name__ )
													UpperCAmelCase_      :   str      =	"""french fries"""
													UpperCAmelCase_      :   Dict      =	sd_pipe(**__magic_name__							,  negative_prompt=__magic_name__ )
													UpperCAmelCase_      :   Optional[Any]      =	output.images
													UpperCAmelCase_      :   int      =	image[0, -3:, -3:, -1]

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

													UpperCAmelCase_      :   int      =	np.array([0.4_9_9_2, 0.5_1_0_1, 0.5_0_0_4, 0.3_9_4_9, 0.3_6_0_4, 0.4_7_3_5, 0.5_2_1_6, 0.5_2_0_4, 0.4_9_1_3] )

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

							def      UpperCAmelCase__						(				self				:  Tuple )       ->							Optional[Any]:







													"""simple docstring"""
													UpperCAmelCase_      :   Any      =	"""cpu"""  # ensure determinism for the device-dependent torch.Generator
													UpperCAmelCase_      :   List[str]      =	self.get_dummy_components()
													UpperCAmelCase_      :   Optional[Any]      =	EulerAncestralDiscreteScheduler(
													    beta_start=0.0_0_0_8_5							,  beta_end=0.0_1_2							,  beta_schedule='''scaled_linear''' )
													UpperCAmelCase_      :   int      =	StableDiffusionModelEditingPipeline(**__magic_name__ )
													UpperCAmelCase_      :   Optional[int]      =	sd_pipe.to(__magic_name__ )
													sd_pipe.set_progress_bar_config(disable=__magic_name__ )

													UpperCAmelCase_      :   Optional[int]      =	self.get_dummy_inputs(__magic_name__ )
													UpperCAmelCase_      :   Union[str, Any]      =	sd_pipe(**__magic_name__ ).images
													UpperCAmelCase_      :   Optional[int]      =	image[0, -3:, -3:, -1]

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

													UpperCAmelCase_      :   List[Any]      =	np.array([0.4_7_4_7, 0.5_3_7_2, 0.4_7_7_9, 0.4_9_8_2, 0.5_5_4_3, 0.4_8_1_6, 0.5_2_3_8, 0.4_9_0_4, 0.5_0_2_7] )

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

							def      UpperCAmelCase__						(				self				:  Tuple )       ->							Optional[int]:







													"""simple docstring"""
													UpperCAmelCase_      :   Any      =	"""cpu"""  # ensure determinism for the device-dependent torch.Generator
													UpperCAmelCase_      :   Optional[int]      =	self.get_dummy_components()
													UpperCAmelCase_      :   Dict      =	PNDMScheduler()
													UpperCAmelCase_      :   Tuple      =	StableDiffusionModelEditingPipeline(**__magic_name__ )
													UpperCAmelCase_      :   Optional[int]      =	sd_pipe.to(__magic_name__ )
													sd_pipe.set_progress_bar_config(disable=__magic_name__ )

													UpperCAmelCase_      :   Any      =	self.get_dummy_inputs(__magic_name__ )
													# the pipeline does not expect pndm so test if it raises error.
													with self.assertRaises(__magic_name__ ):
																			UpperCAmelCase_      :   Union[str, Any]      =	sd_pipe(**__magic_name__ ).images

							def      UpperCAmelCase__						(				self				:  Tuple )       ->							Any:







													"""simple docstring"""
													super().test_inference_batch_single_identical(expected_max_diff=5E-3 )



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







													"""simple docstring"""
													super().test_attention_slicing_forward_pass(expected_max_diff=5E-3 )





@slow
@require_torch_gpu
class        __a   (unittest.TestCase  ):

							def      UpperCAmelCase__						(				self				:  Optional[Any] )       ->							List[Any]:







													"""simple docstring"""
													super().tearDown()
													gc.collect()
													torch.cuda.empty_cache()

							def      UpperCAmelCase__						(				self				:  Union[str, Any]							,  __magic_name__				:  Any=0 )       ->							Any:







													"""simple docstring"""
													UpperCAmelCase_      :   Union[str, Any]      =	torch.manual_seed(__magic_name__ )
													UpperCAmelCase_      :   Tuple      =	{
													    """prompt""": """A field of roses""",
													    """generator""": generator,
													    """num_inference_steps""": 3,
													    """guidance_scale""": 7.5,
													    """output_type""": """numpy""",
													}
													return inputs

							def      UpperCAmelCase__						(				self				:  List[Any] )       ->							Union[str, Any]:







													"""simple docstring"""
													UpperCAmelCase_      :   Union[str, Any]      =	"""CompVis/stable-diffusion-v1-4"""
													UpperCAmelCase_      :   str      =	StableDiffusionModelEditingPipeline.from_pretrained(__magic_name__							,  safety_checker=__magic_name__ )
													pipe.to(__magic_name__ )
													pipe.set_progress_bar_config(disable=__magic_name__ )
													pipe.enable_attention_slicing()

													UpperCAmelCase_      :   List[str]      =	self.get_inputs()
													UpperCAmelCase_      :   Optional[int]      =	pipe(**__magic_name__ ).images
													UpperCAmelCase_      :   str      =	image[0, -3:, -3:, -1].flatten()

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

													UpperCAmelCase_      :   Any      =	np.array(
													    [0.6_7_4_9_4_9_6, 0.6_3_8_6_4_5_3, 0.5_1_4_4_3_2_6_7, 0.6_6_0_9_4_9_0_5, 0.6_1_9_2_1_2_1_5, 0.5_4_9_1_3_3_2, 0.5_7_4_4_4_1_7, 0.5_8_0_7_5_1_0_6, 0.5_1_7_4_6_5_8] )

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

													# make sure image changes after editing
													pipe.edit_model('''A pack of roses'''							,  '''A pack of blue roses''' )

													UpperCAmelCase_      :   Tuple      =	pipe(**__magic_name__ ).images
													UpperCAmelCase_      :   str      =	image[0, -3:, -3:, -1].flatten()

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

													assert np.abs(expected_slice - image_slice ).max() > 1E-1



							def      UpperCAmelCase__						(				self				:  Union[str, Any] )       ->							Optional[Any]:







													"""simple docstring"""
													torch.cuda.empty_cache()
													torch.cuda.reset_max_memory_allocated()
													torch.cuda.reset_peak_memory_stats()

													UpperCAmelCase_      :   Optional[int]      =	"""CompVis/stable-diffusion-v1-4"""
													UpperCAmelCase_      :   Dict      =	DDIMScheduler.from_pretrained(__magic_name__							,  subfolder='''scheduler''' )
													UpperCAmelCase_      :   Optional[Any]      =	StableDiffusionModelEditingPipeline.from_pretrained(
													    __magic_name__							,  scheduler=__magic_name__							,  safety_checker=__magic_name__ )
													UpperCAmelCase_      :   Optional[Any]      =	pipe.to(__magic_name__ )
													pipe.set_progress_bar_config(disable=__magic_name__ )
													pipe.enable_attention_slicing(1 )
													pipe.enable_sequential_cpu_offload()

													UpperCAmelCase_      :   Dict      =	self.get_inputs()
													UpperCAmelCase_      :   Optional[Any]      =	pipe(**__magic_name__ )

													UpperCAmelCase_      :   str      =	torch.cuda.max_memory_allocated()
													# make sure that less than 4.4 GB is allocated
													assert mem_bytes < 4.4 * 10**9













"""simple docstring"""



from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


A_     =				{
    '''configuration_deformable_detr''': ['''DEFORMABLE_DETR_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''DeformableDetrConfig'''],
}

try:
						if not is_vision_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						A_     =				['''DeformableDetrFeatureExtractor''']
						A_     =				['''DeformableDetrImageProcessor''']

try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						A_     =				[
						    '''DEFORMABLE_DETR_PRETRAINED_MODEL_ARCHIVE_LIST''',
						    '''DeformableDetrForObjectDetection''',
						    '''DeformableDetrModel''',
						    '''DeformableDetrPreTrainedModel''',
						]


if TYPE_CHECKING:
						from .configuration_deformable_detr import DEFORMABLE_DETR_PRETRAINED_CONFIG_ARCHIVE_MAP, DeformableDetrConfig

						try:
												if not is_vision_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .feature_extraction_deformable_detr import DeformableDetrFeatureExtractor
												from .image_processing_deformable_detr import DeformableDetrImageProcessor

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_deformable_detr import (
												    DEFORMABLE_DETR_PRETRAINED_MODEL_ARCHIVE_LIST,
												    DeformableDetrForObjectDetection,
												    DeformableDetrModel,
												    DeformableDetrPreTrainedModel,
												)

else:
						import sys

						A_     =				_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)






