






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







		"""simple docstring"""



		snake_case    =   StableDiffusionDiffEditPipeline
		snake_case    =   TEXT_GUIDED_IMAGE_INPAINTING_PARAMS - {"height", "width", "image"} | {"image_latents"}
		snake_case    =   TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS - {"image"} | {"image_latents"}
		snake_case    =   frozenset(
		    [] )  # TO-DO: update image_params once pipeline is refactored with VaeImageProcessor.preprocess
		snake_case    =   frozenset([] )
		def       A(  self		:       Any		)    ->   Union[str, Any]:


						'''simple docstring'''
						torch.manual_seed(0		)
						A	 =      UNetaDConditionModel(
						    block_out_channels=(3_2, 6_4)						,layers_per_block=2						,sample_size=3_2						,in_channels=4						,out_channels=4						,down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')						,up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D')						,cross_attention_dim=3_2						,attention_head_dim=(2, 4)						,use_linear_projection=_SCREAMING_SNAKE_CASE						,)
						A	 =      DDIMScheduler(
						    beta_start=0.00085						,beta_end=0.012						,beta_schedule='scaled_linear'						,clip_sample=_SCREAMING_SNAKE_CASE						,set_alpha_to_one=_SCREAMING_SNAKE_CASE						,)
						A	 =      DDIMInverseScheduler(
						    beta_start=0.00085						,beta_end=0.012						,beta_schedule='scaled_linear'						,clip_sample=_SCREAMING_SNAKE_CASE						,set_alpha_to_zero=_SCREAMING_SNAKE_CASE						,)
						torch.manual_seed(0		)
						A	 =      AutoencoderKL(
						    block_out_channels=[3_2, 6_4]						,in_channels=3						,out_channels=3						,down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D']						,up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D']						,latent_channels=4						,sample_size=1_2_8						,)
						torch.manual_seed(0		)
						A	 =      CLIPTextConfig(
						    bos_token_id=0						,eos_token_id=2						,hidden_size=3_2						,intermediate_size=3_7						,layer_norm_eps=1E-05						,num_attention_heads=4						,num_hidden_layers=5						,pad_token_id=1						,vocab_size=1_0_0_0						,hidden_act='gelu'						,projection_dim=5_1_2						,)
						A	 =      CLIPTextModel(_SCREAMING_SNAKE_CASE		)
						A	 =      CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'		)

						A	 =      {
						    '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       A(  self		:       Dict						,_SCREAMING_SNAKE_CASE		:       int						,_SCREAMING_SNAKE_CASE		:       Any=0		)    ->   Optional[int]:


						'''simple docstring'''
						A	 =      floats_tensor((1, 1_6, 1_6)						,rng=random.Random(_SCREAMING_SNAKE_CASE		)		).to(_SCREAMING_SNAKE_CASE		)
						A	 =      floats_tensor((1, 2, 4, 1_6, 1_6)						,rng=random.Random(_SCREAMING_SNAKE_CASE		)		).to(_SCREAMING_SNAKE_CASE		)
						if str(_SCREAMING_SNAKE_CASE		).startswith('mps'		):
										A	 =      torch.manual_seed(_SCREAMING_SNAKE_CASE		)
						else:
										A	 =      torch.Generator(device=_SCREAMING_SNAKE_CASE		).manual_seed(_SCREAMING_SNAKE_CASE		)
						A	 =      {
						    '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       A(  self		:       List[str]						,_SCREAMING_SNAKE_CASE		:       int						,_SCREAMING_SNAKE_CASE		:       Optional[Any]=0		)    ->   Any:


						'''simple docstring'''
						A	 =      floats_tensor((1, 3, 3_2, 3_2)						,rng=random.Random(_SCREAMING_SNAKE_CASE		)		).to(_SCREAMING_SNAKE_CASE		)
						A	 =      image.cpu().permute(0						,2						,3						,1		)[0]
						A	 =      Image.fromarray(np.uinta(_SCREAMING_SNAKE_CASE		)		).convert('RGB'		)
						if str(_SCREAMING_SNAKE_CASE		).startswith('mps'		):
										A	 =      torch.manual_seed(_SCREAMING_SNAKE_CASE		)
						else:
										A	 =      torch.Generator(device=_SCREAMING_SNAKE_CASE		).manual_seed(_SCREAMING_SNAKE_CASE		)
						A	 =      {
						    '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       A(  self		:       List[Any]						,_SCREAMING_SNAKE_CASE		:       Optional[Any]						,_SCREAMING_SNAKE_CASE		:       Optional[int]=0		)    ->   Any:


						'''simple docstring'''
						A	 =      floats_tensor((1, 3, 3_2, 3_2)						,rng=random.Random(_SCREAMING_SNAKE_CASE		)		).to(_SCREAMING_SNAKE_CASE		)
						A	 =      image.cpu().permute(0						,2						,3						,1		)[0]
						A	 =      Image.fromarray(np.uinta(_SCREAMING_SNAKE_CASE		)		).convert('RGB'		)
						if str(_SCREAMING_SNAKE_CASE		).startswith('mps'		):
										A	 =      torch.manual_seed(_SCREAMING_SNAKE_CASE		)
						else:
										A	 =      torch.Generator(device=_SCREAMING_SNAKE_CASE		).manual_seed(_SCREAMING_SNAKE_CASE		)
						A	 =      {
						    '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       A(  self		:       int		)    ->   Tuple:


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

						A	 =      self.get_dummy_components()
						A	 =      self.pipeline_class(**_SCREAMING_SNAKE_CASE		)
						pipe.to(_SCREAMING_SNAKE_CASE		)
						pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE		)

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

						A	 =      self.get_dummy_inputs(_SCREAMING_SNAKE_CASE		)
						A	 =      pipe(**_SCREAMING_SNAKE_CASE		)[0]

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

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

						A	 =      self.get_dummy_inputs(_SCREAMING_SNAKE_CASE		)
						A	 =      pipe_loaded(**_SCREAMING_SNAKE_CASE		)[0]

						A	 =      np.abs(output - output_loaded		).max()
						self.assertLess(_SCREAMING_SNAKE_CASE						,1E-4		)
		def       A(  self		:       List[Any]		)    ->   List[Any]:


						'''simple docstring'''
						A	 =      'cpu'

						A	 =      self.get_dummy_components()
						A	 =      self.pipeline_class(**_SCREAMING_SNAKE_CASE		)
						pipe.to(_SCREAMING_SNAKE_CASE		)
						pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE		)

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

						self.assertEqual(mask.shape						,(1, 1_6, 1_6)		)
						A	 =      np.array([0] * 9		)
						A	 =      np.abs(mask_slice.flatten() - expected_slice		).max()
						self.assertLessEqual(_SCREAMING_SNAKE_CASE						,1E-3		)
						self.assertEqual(mask[0, -3, -4]						,0		)
		def       A(  self		:       List[str]		)    ->   Optional[Any]:


						'''simple docstring'''
						A	 =      'cpu'

						A	 =      self.get_dummy_components()
						A	 =      self.pipeline_class(**_SCREAMING_SNAKE_CASE		)
						pipe.to(_SCREAMING_SNAKE_CASE		)
						pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE		)

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

						self.assertEqual(image.shape						,(2, 3_2, 3_2, 3)		)
						A	 =      np.array(
						    [0.5150, 0.5134, 0.5043, 0.5376, 0.4694, 0.51050, 0.5015, 0.4407, 0.4799]						,)
						A	 =      np.abs(image_slice.flatten() - expected_slice		).max()
						self.assertLessEqual(_SCREAMING_SNAKE_CASE						,1E-3		)
		def       A(  self		:       Optional[Any]		)    ->   Dict:


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







		def       A(  self		:       Optional[Any]		)    ->   Optional[int]:


						'''simple docstring'''
						A	 =      'cpu'

						A	 =      self.get_dummy_components()

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

						A	 =      self.pipeline_class(**_SCREAMING_SNAKE_CASE		)
						pipe.to(_SCREAMING_SNAKE_CASE		)
						pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE		)

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

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


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







		"""simple docstring"""



		def       A(  self		:       List[str]		)    ->   int:


						'''simple docstring'''
						super().tearDown()
						gc.collect()
						torch.cuda.empty_cache()
		@classmethod
		def       A(  cls		:       Optional[int]		)    ->   Dict:


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

						A	 =      raw_image.convert('RGB'		).resize((7_6_8, 7_6_8)		)

						A	 =      raw_image
		def       A(  self		:       Tuple		)    ->   List[str]:


						'''simple docstring'''
						A	 =      torch.manual_seed(0		)

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

						A	 =      'a bowl of fruit'
						A	 =      'a bowl of pears'

						A	 =      pipe.generate_mask(
						    image=self.raw_image						,source_prompt=_SCREAMING_SNAKE_CASE						,target_prompt=_SCREAMING_SNAKE_CASE						,generator=_SCREAMING_SNAKE_CASE						,)

						A	 =      pipe.invert(
						    prompt=_SCREAMING_SNAKE_CASE						,image=self.raw_image						,inpaint_strength=0.7						,generator=_SCREAMING_SNAKE_CASE		).latents

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

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







		def       A(  self		:       Any		)    ->   int:


						'''simple docstring'''
						A	 =      torch.manual_seed(0		)

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

						A	 =      'a bowl of fruit'
						A	 =      'a bowl of pears'

						A	 =      pipe.generate_mask(
						    image=self.raw_image						,source_prompt=_SCREAMING_SNAKE_CASE						,target_prompt=_SCREAMING_SNAKE_CASE						,generator=_SCREAMING_SNAKE_CASE						,)

						A	 =      pipe.invert(
						    prompt=_SCREAMING_SNAKE_CASE						,image=self.raw_image						,inpaint_strength=0.7						,generator=_SCREAMING_SNAKE_CASE						,num_inference_steps=2_5						,).latents

						A	 =      pipe(
						    prompt=_SCREAMING_SNAKE_CASE						,mask_image=_SCREAMING_SNAKE_CASE						,image_latents=_SCREAMING_SNAKE_CASE						,generator=_SCREAMING_SNAKE_CASE						,negative_prompt=_SCREAMING_SNAKE_CASE						,inpaint_strength=0.7						,num_inference_steps=2_5						,output_type='numpy'						,).images[0]

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













from itertools import permutations







def      snake_case		(							UpperCAmelCase	:       tuple   ):
				if num[3] % 2 != 0:
								return False

				if (num[2] + num[3] + num[4]) % 3 != 0:
								return False

				if num[5] % 5 != 0:
								return False

				A	 =      [7, 11, 13, 17]
				for i, test in enumerate(UpperCAmelCase   ):
								if (num[i + 4] * 1_00 + num[i + 5] * 10 + num[i + 6]) % test != 0:
												return False
				return True







def      snake_case		(							UpperCAmelCase	:       int = 10   ):
				return sum(
				    int(''.join(map(UpperCAmelCase,						UpperCAmelCase   )   )   )
				    for num in permutations(range(UpperCAmelCase   )   )
				    if is_substring_divisible(UpperCAmelCase   )   )


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





