

from ...configuration_utils import PretrainedConfig
from ...utils import logging


A__						=							logging.get_logger(__name__)

A__						=							{
    'caidas/swin2sr-classicalsr-x2-64': (
        'https://huggingface.co/caidas/swin2sr-classicalsr-x2-64/resolve/main/config.json'
    ),
}

class 				__UpperCamelCase				(					SCREAMING_SNAKE_CASE_			):
 _lowercase  :   Dict       				=  "swin2sr"

 _lowercase  :   List[Any]       				=  {
     "hidden_size": "embed_dim",
     "num_attention_heads": "num_heads",
     "num_hidden_layers": "num_layers",
 }







 def __init__(   self: int  , __UpperCamelCase: Any=64  , __UpperCamelCase: Union[str, Any]=1  , __UpperCamelCase: List[str]=3  , __UpperCamelCase: List[str]=1_80  , __UpperCamelCase: List[str]=[6, 6, 6, 6, 6, 6]  , __UpperCamelCase: Tuple=[6, 6, 6, 6, 6, 6]  , __UpperCamelCase: Any=8  , __UpperCamelCase: int=2.0  , __UpperCamelCase: List[Any]=True  , __UpperCamelCase: Optional[int]=0.0  , __UpperCamelCase: Dict=0.0  , __UpperCamelCase: Tuple=0.1  , __UpperCamelCase: List[Any]="gelu"  , __UpperCamelCase: List[Any]=False  , __UpperCamelCase: str=0.02  , __UpperCamelCase: Any=1E-5  , __UpperCamelCase: Any=2  , __UpperCamelCase: List[str]=1.0  , __UpperCamelCase: Tuple="1conv"  , __UpperCamelCase: int="pixelshuffle"  , **__UpperCamelCase: Optional[Any]  , ):

      '''simple docstring'''





      super().__init__(**UpperCamelCase__      )

      __magic_name__							=    image_size
      __magic_name__							=    patch_size
      __magic_name__							=    num_channels
      __magic_name__							=    embed_dim
      __magic_name__							=    depths
      __magic_name__							=    len(UpperCamelCase__      )
      __magic_name__							=    num_heads
      __magic_name__							=    window_size
      __magic_name__							=    mlp_ratio
      __magic_name__							=    qkv_bias
      __magic_name__							=    hidden_dropout_prob
      __magic_name__							=    attention_probs_dropout_prob
      __magic_name__							=    drop_path_rate
      __magic_name__							=    hidden_act
      __magic_name__							=    use_absolute_embeddings
      __magic_name__							=    layer_norm_eps
      __magic_name__							=    initializer_range
      __magic_name__							=    upscale
      __magic_name__							=    img_range
      __magic_name__							=    resi_connection
      __magic_name__							=    upsampler







import gc
import random
import tempfile
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMInverseScheduler,
    DDIMScheduler,
    DPMSolverMultistepInverseScheduler,
    DPMSolverMultistepScheduler,
    StableDiffusionDiffEditPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import load_image, slow
from diffusers.utils.testing_utils import enable_full_determinism, floats_tensor, require_torch_gpu, torch_device

from ..pipeline_params import TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS, TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()

class 				__UpperCamelCase				(					SCREAMING_SNAKE_CASE  ,						SCREAMING_SNAKE_CASE  ,						unittest.TestCase			):
	_lowercase  :   Dict       				=  StableDiffusionDiffEditPipeline
	_lowercase  :   Dict       				=  TEXT_GUIDED_IMAGE_INPAINTING_PARAMS - {"height", "width", "image"} | {"image_latents"}
	_lowercase  :   Dict       				=  TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS - {"image"} | {"image_latents"}
	_lowercase  :   str       				=  frozenset(
	    []			)  # TO-DO: update image_params once pipeline is refactored with VaeImageProcessor.preprocess
	_lowercase  :   int       				=  frozenset([]			)







	def 	_SCREAMING_SNAKE_CASE							(   self: Dict      ):

						'''simple docstring'''





						torch.manual_seed(0      )
						__magic_name__							=    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  , attention_head_dim=(2, 4)  , use_linear_projection=__UpperCamelCase  , )
						__magic_name__							=    DDIMScheduler(
						    beta_start=0.00085  , beta_end=0.012  , beta_schedule='scaled_linear'  , clip_sample=__UpperCamelCase  , set_alpha_to_one=__UpperCamelCase  , )
						__magic_name__							=    DDIMInverseScheduler(
						    beta_start=0.00085  , beta_end=0.012  , beta_schedule='scaled_linear'  , clip_sample=__UpperCamelCase  , set_alpha_to_zero=__UpperCamelCase  , )
						torch.manual_seed(0      )
						__magic_name__							=    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  , sample_size=1_28  , )
						torch.manual_seed(0      )
						__magic_name__							=    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  , hidden_act='gelu'  , projection_dim=5_12  , )
						__magic_name__							=    CLIPTextModel(__UpperCamelCase      )
						__magic_name__							=    CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'      )

						__magic_name__							=    {
						    'unet': unet,
						    'scheduler': scheduler,
						    'inverse_scheduler': inverse_scheduler,
						    'vae': vae,
						    'text_encoder': text_encoder,
						    'tokenizer': tokenizer,
						    'safety_checker': None,
						    'feature_extractor': None,
						}

						return components







	def 	_SCREAMING_SNAKE_CASE							(   self: Optional[int]  , __UpperCamelCase: Optional[Any]  , __UpperCamelCase: List[Any]=0      ):

						'''simple docstring'''





						__magic_name__							=    floats_tensor((1, 16, 16)  , rng=random.Random(__UpperCamelCase      )      ).to(__UpperCamelCase      )
						__magic_name__							=    floats_tensor((1, 2, 4, 16, 16)  , rng=random.Random(__UpperCamelCase      )      ).to(__UpperCamelCase      )
						if str(__UpperCamelCase      ).startswith('mps'      ):
											__magic_name__							=    torch.manual_seed(__UpperCamelCase      )
						else:
											__magic_name__							=    torch.Generator(device=__UpperCamelCase      ).manual_seed(__UpperCamelCase      )
						__magic_name__							=    {
						    'prompt': 'a dog and a newt',
						    'mask_image': mask,
						    'image_latents': latents,
						    'generator': generator,
						    'num_inference_steps': 2,
						    'inpaint_strength': 1.0,
						    'guidance_scale': 6.0,
						    'output_type': 'numpy',
						}

						return inputs







	def 	_SCREAMING_SNAKE_CASE							(   self: str  , __UpperCamelCase: str  , __UpperCamelCase: Optional[int]=0      ):

						'''simple docstring'''





						__magic_name__							=    floats_tensor((1, 3, 32, 32)  , rng=random.Random(__UpperCamelCase      )      ).to(__UpperCamelCase      )
						__magic_name__							=    image.cpu().permute(0  , 2  , 3  , 1      )[0]
						__magic_name__							=    Image.fromarray(np.uinta(__UpperCamelCase      )      ).convert('RGB'      )
						if str(__UpperCamelCase      ).startswith('mps'      ):
											__magic_name__							=    torch.manual_seed(__UpperCamelCase      )
						else:
											__magic_name__							=    torch.Generator(device=__UpperCamelCase      ).manual_seed(__UpperCamelCase      )
						__magic_name__							=    {
						    'image': image,
						    'source_prompt': 'a cat and a frog',
						    'target_prompt': 'a dog and a newt',
						    'generator': generator,
						    'num_inference_steps': 2,
						    'num_maps_per_mask': 2,
						    'mask_encode_strength': 1.0,
						    'guidance_scale': 6.0,
						    'output_type': 'numpy',
						}

						return inputs







	def 	_SCREAMING_SNAKE_CASE							(   self: List[Any]  , __UpperCamelCase: Optional[int]  , __UpperCamelCase: Optional[int]=0      ):

						'''simple docstring'''





						__magic_name__							=    floats_tensor((1, 3, 32, 32)  , rng=random.Random(__UpperCamelCase      )      ).to(__UpperCamelCase      )
						__magic_name__							=    image.cpu().permute(0  , 2  , 3  , 1      )[0]
						__magic_name__							=    Image.fromarray(np.uinta(__UpperCamelCase      )      ).convert('RGB'      )
						if str(__UpperCamelCase      ).startswith('mps'      ):
											__magic_name__							=    torch.manual_seed(__UpperCamelCase      )
						else:
											__magic_name__							=    torch.Generator(device=__UpperCamelCase      ).manual_seed(__UpperCamelCase      )
						__magic_name__							=    {
						    'image': image,
						    'prompt': 'a cat and a frog',
						    'generator': generator,
						    'num_inference_steps': 2,
						    'inpaint_strength': 1.0,
						    'guidance_scale': 6.0,
						    'decode_latents': True,
						    'output_type': 'numpy',
						}
						return inputs







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

						'''simple docstring'''





						if not hasattr(self.pipeline_class  , '_optional_components'      ):
											return

						__magic_name__							=    self.get_dummy_components()
						__magic_name__							=    self.pipeline_class(**__UpperCamelCase      )
						pipe.to(__UpperCamelCase      )
						pipe.set_progress_bar_config(disable=__UpperCamelCase      )

						# set all optional components to None and update pipeline config accordingly
						for optional_component in pipe._optional_components:
											setattr(__UpperCamelCase  , __UpperCamelCase  , __UpperCamelCase      )
						pipe.register_modules(**{optional_component: None for optional_component in pipe._optional_components}      )

						__magic_name__							=    self.get_dummy_inputs(__UpperCamelCase      )
						__magic_name__							=    pipe(**__UpperCamelCase      )[0]

						with tempfile.TemporaryDirectory() as tmpdir:
											pipe.save_pretrained(__UpperCamelCase      )
											__magic_name__							=    self.pipeline_class.from_pretrained(__UpperCamelCase      )
											pipe_loaded.to(__UpperCamelCase      )
											pipe_loaded.set_progress_bar_config(disable=__UpperCamelCase      )

						for optional_component in pipe._optional_components:
											self.assertTrue(
											    getattr(__UpperCamelCase  , __UpperCamelCase      ) is None  , F'`{optional_component}` did not stay set to None after loading.'  , )

						__magic_name__							=    self.get_dummy_inputs(__UpperCamelCase      )
						__magic_name__							=    pipe_loaded(**__UpperCamelCase      )[0]

						__magic_name__							=    np.abs(output - output_loaded      ).max()
						self.assertLess(__UpperCamelCase  , 1E-4      )







	def 	_SCREAMING_SNAKE_CASE							(   self: Tuple      ):

						'''simple docstring'''





						__magic_name__							=    'cpu'

						__magic_name__							=    self.get_dummy_components()
						__magic_name__							=    self.pipeline_class(**__UpperCamelCase      )
						pipe.to(__UpperCamelCase      )
						pipe.set_progress_bar_config(disable=__UpperCamelCase      )

						__magic_name__							=    self.get_dummy_mask_inputs(__UpperCamelCase      )
						__magic_name__							=    pipe.generate_mask(**__UpperCamelCase      )
						__magic_name__							=    mask[0, -3:, -3:]

						self.assertEqual(mask.shape  , (1, 16, 16)      )
						__magic_name__							=    np.array([0] * 9      )
						__magic_name__							=    np.abs(mask_slice.flatten() - expected_slice      ).max()
						self.assertLessEqual(__UpperCamelCase  , 1E-3      )
						self.assertEqual(mask[0, -3, -4]  , 0      )







	def 	_SCREAMING_SNAKE_CASE							(   self: Optional[int]      ):

						'''simple docstring'''





						__magic_name__							=    'cpu'

						__magic_name__							=    self.get_dummy_components()
						__magic_name__							=    self.pipeline_class(**__UpperCamelCase      )
						pipe.to(__UpperCamelCase      )
						pipe.set_progress_bar_config(disable=__UpperCamelCase      )

						__magic_name__							=    self.get_dummy_inversion_inputs(__UpperCamelCase      )
						__magic_name__							=    pipe.invert(**__UpperCamelCase      ).images
						__magic_name__							=    image[0, -1, -3:, -3:]

						self.assertEqual(image.shape  , (2, 32, 32, 3)      )
						__magic_name__							=    np.array(
						    [0.5150, 0.5134, 0.5043, 0.5376, 0.4694, 0.51050, 0.5015, 0.4407, 0.4799]  , )
						__magic_name__							=    np.abs(image_slice.flatten() - expected_slice      ).max()
						self.assertLessEqual(__UpperCamelCase  , 1E-3      )







	def 	_SCREAMING_SNAKE_CASE							(   self: Tuple      ):

						'''simple docstring'''





						super().test_inference_batch_single_identical(expected_max_diff=5E-3      )







	def 	_SCREAMING_SNAKE_CASE							(   self: Dict      ):

						'''simple docstring'''





						__magic_name__							=    'cpu'

						__magic_name__							=    self.get_dummy_components()

						__magic_name__							=    {'beta_start': 0.00085, 'beta_end': 0.012, 'beta_schedule': 'scaled_linear'}
						__magic_name__							=    DPMSolverMultistepScheduler(**__UpperCamelCase      )
						__magic_name__							=    DPMSolverMultistepInverseScheduler(**__UpperCamelCase      )

						__magic_name__							=    self.pipeline_class(**__UpperCamelCase      )
						pipe.to(__UpperCamelCase      )
						pipe.set_progress_bar_config(disable=__UpperCamelCase      )

						__magic_name__							=    self.get_dummy_inversion_inputs(__UpperCamelCase      )
						__magic_name__							=    pipe.invert(**__UpperCamelCase      ).images
						__magic_name__							=    image[0, -1, -3:, -3:]

						self.assertEqual(image.shape  , (2, 32, 32, 3)      )
						__magic_name__							=    np.array(
						    [0.5150, 0.5134, 0.5043, 0.5376, 0.4694, 0.51050, 0.5015, 0.4407, 0.4799]  , )
						__magic_name__							=    np.abs(image_slice.flatten() - expected_slice      ).max()
						self.assertLessEqual(__UpperCamelCase  , 1E-3      )




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







	def 	_SCREAMING_SNAKE_CASE							(   self: Tuple      ):

						'''simple docstring'''





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







	@classmethod
	def 	_SCREAMING_SNAKE_CASE							(   cls: List[str]      ):

						'''simple docstring'''





						__magic_name__							=    load_image(
						    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/diffedit/fruit.png'      )

						__magic_name__							=    raw_image.convert('RGB'      ).resize((7_68, 7_68)      )

						__magic_name__							=    raw_image







	def 	_SCREAMING_SNAKE_CASE							(   self: Optional[Any]      ):

						'''simple docstring'''





						__magic_name__							=    torch.manual_seed(0      )

						__magic_name__							=    StableDiffusionDiffEditPipeline.from_pretrained(
						    'stabilityai/stable-diffusion-2-1'  , safety_checker=__UpperCamelCase  , torch_dtype=torch.floataa      )
						__magic_name__							=    DDIMScheduler.from_config(pipe.scheduler.config      )
						__magic_name__							=    DDIMInverseScheduler.from_config(pipe.scheduler.config      )
						pipe.enable_model_cpu_offload()
						pipe.set_progress_bar_config(disable=__UpperCamelCase      )

						__magic_name__							=    'a bowl of fruit'
						__magic_name__							=    'a bowl of pears'

						__magic_name__							=    pipe.generate_mask(
						    image=self.raw_image  , source_prompt=__UpperCamelCase  , target_prompt=__UpperCamelCase  , generator=__UpperCamelCase  , )

						__magic_name__							=    pipe.invert(
						    prompt=__UpperCamelCase  , image=self.raw_image  , inpaint_strength=0.7  , generator=__UpperCamelCase      ).latents

						__magic_name__							=    pipe(
						    prompt=__UpperCamelCase  , mask_image=__UpperCamelCase  , image_latents=__UpperCamelCase  , generator=__UpperCamelCase  , negative_prompt=__UpperCamelCase  , inpaint_strength=0.7  , output_type='numpy'  , ).images[0]

						__magic_name__							=    (
						    np.array(
						        load_image(
						            'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
						            '/diffedit/pears.png'      ).resize((7_68, 7_68)      )      )
						    / 2_55
						)
						assert np.abs((expected_image - image).max()      ) < 5E-1







	def 	_SCREAMING_SNAKE_CASE							(   self: int      ):

						'''simple docstring'''





						__magic_name__							=    torch.manual_seed(0      )

						__magic_name__							=    StableDiffusionDiffEditPipeline.from_pretrained(
						    'stabilityai/stable-diffusion-2-1'  , safety_checker=__UpperCamelCase  , torch_dtype=torch.floataa      )
						__magic_name__							=    DPMSolverMultistepScheduler.from_config(pipe.scheduler.config      )
						__magic_name__							=    DPMSolverMultistepInverseScheduler.from_config(pipe.scheduler.config      )
						pipe.enable_model_cpu_offload()
						pipe.set_progress_bar_config(disable=__UpperCamelCase      )

						__magic_name__							=    'a bowl of fruit'
						__magic_name__							=    'a bowl of pears'

						__magic_name__							=    pipe.generate_mask(
						    image=self.raw_image  , source_prompt=__UpperCamelCase  , target_prompt=__UpperCamelCase  , generator=__UpperCamelCase  , )

						__magic_name__							=    pipe.invert(
						    prompt=__UpperCamelCase  , image=self.raw_image  , inpaint_strength=0.7  , generator=__UpperCamelCase  , num_inference_steps=25  , ).latents

						__magic_name__							=    pipe(
						    prompt=__UpperCamelCase  , mask_image=__UpperCamelCase  , image_latents=__UpperCamelCase  , generator=__UpperCamelCase  , negative_prompt=__UpperCamelCase  , inpaint_strength=0.7  , num_inference_steps=25  , output_type='numpy'  , ).images[0]

						__magic_name__							=    (
						    np.array(
						        load_image(
						            'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
						            '/diffedit/pears.png'      ).resize((7_68, 7_68)      )      )
						    / 2_55
						)
						assert np.abs((expected_image - image).max()      ) < 5E-1




