




"""simple docstring"""

import gc
import random
import unittest

import torch

from diffusers import (
    IFImgaImgPipeline,
    IFImgaImgSuperResolutionPipeline,
    IFInpaintingPipeline,
    IFInpaintingSuperResolutionPipeline,
    IFPipeline,
    IFSuperResolutionPipeline,
)
from diffusers.models.attention_processor import AttnAddedKVProcessor
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import floats_tensor, load_numpy, require_torch_gpu, skip_mps, slow, torch_device

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference
from . import IFPipelineTesterMixin





@skip_mps
class 							lowercase_			(	__lowerCAmelCase     ,      __lowerCAmelCase     ,      unittest.TestCase				):



 '''simple docstring'''
 UpperCAmelCase       :	List[str]     =      IFPipeline
 UpperCAmelCase       :	List[str]     =      TEXT_TO_IMAGE_PARAMS - {'''width''', '''height''', '''latents'''}
 UpperCAmelCase       :	Optional[Any]     =      TEXT_TO_IMAGE_BATCH_PARAMS
 UpperCAmelCase       :	Any     =      PipelineTesterMixin.required_optional_params - {'''latents'''}

 def      lowerCAmelCase_				(					self			:			int						):
       return self._get_dummy_components()

 def      lowerCAmelCase_				(					self			:			List[Any]       ,				_UpperCAmelCase			:			Tuple       ,				_UpperCAmelCase			:			str=0						):
       if str(_UpperCAmelCase						).startswith('mps'						):
             _A     =  torch.manual_seed(_UpperCAmelCase						)
       else:
             _A     =  torch.Generator(device=_UpperCAmelCase						).manual_seed(_UpperCAmelCase						)

       _A     =  {
           'prompt': 'A painting of a squirrel eating a burger',
           'generator': generator,
           'num_inference_steps': 2,
           'output_type': 'numpy',
       }

       return inputs

 def      lowerCAmelCase_				(					self			:			Union[str, Any]						):
       self._test_save_load_optional_components()

 @unittest.skipIf(torch_device != 'cuda'       ,				reason='float16 requires CUDA'						)
 def      lowerCAmelCase_				(					self			:			Optional[int]						):
       # Due to non-determinism in save load of the hf-internal-testing/tiny-random-t5 text encoder
       super().test_save_load_floataa(expected_max_diff=1E-1						)

 def      lowerCAmelCase_				(					self			:			int						):
       self._test_attention_slicing_forward_pass(expected_max_diff=1E-2						)

 def      lowerCAmelCase_				(					self			:			int						):
       self._test_save_load_local()

 def      lowerCAmelCase_				(					self			:			Any						):
       self._test_inference_batch_single_identical(
           expected_max_diff=1E-2       ,				)



 @unittest.skipIf(
     torch_device != 'cuda' or not is_xformers_available()       ,				reason='XFormers attention is only available with CUDA and `xformers` installed'       ,				)
 def      lowerCAmelCase_				(					self			:			Union[str, Any]						):
       self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3						)





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



 '''simple docstring'''

 def      lowerCAmelCase_				(					self			:			List[Any]						):
       # clean up the VRAM after each test
       super().tearDown()
       gc.collect()
       torch.cuda.empty_cache()

 def      lowerCAmelCase_				(					self			:			Optional[Any]						):
       # if

       _A     =  IFPipeline.from_pretrained('DeepFloyd/IF-I-XL-v1.0'       ,				variant='fp16'       ,				torch_dtype=torch.floataa						)

       _A     =  IFSuperResolutionPipeline.from_pretrained(
           'DeepFloyd/IF-II-L-v1.0'       ,				variant='fp16'       ,				torch_dtype=torch.floataa       ,				text_encoder=_UpperCAmelCase       ,				tokenizer=_UpperCAmelCase						)

       # pre compute text embeddings and remove T5 to save memory

       pipe_a.text_encoder.to('cuda'						)

       _A  ,       _A     =  pipe_a.encode_prompt('anime turtle'       ,				device='cuda'						)

       del pipe_a.tokenizer
       del pipe_a.text_encoder
       gc.collect()

       _A     =  None
       _A     =  None

       pipe_a.enable_model_cpu_offload()
       pipe_a.enable_model_cpu_offload()

       pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()						)
       pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()						)

       self._test_if(_UpperCAmelCase       ,				_UpperCAmelCase       ,				_UpperCAmelCase       ,				_UpperCAmelCase						)

       pipe_a.remove_all_hooks()
       pipe_a.remove_all_hooks()

       # img2img

       _A     =  IFImgaImgPipeline(**pipe_a.components						)
       _A     =  IFImgaImgSuperResolutionPipeline(**pipe_a.components						)

       pipe_a.enable_model_cpu_offload()
       pipe_a.enable_model_cpu_offload()

       pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()						)
       pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()						)

       self._test_if_imgaimg(_UpperCAmelCase       ,				_UpperCAmelCase       ,				_UpperCAmelCase       ,				_UpperCAmelCase						)

       pipe_a.remove_all_hooks()
       pipe_a.remove_all_hooks()

       # inpainting

       _A     =  IFInpaintingPipeline(**pipe_a.components						)
       _A     =  IFInpaintingSuperResolutionPipeline(**pipe_a.components						)

       pipe_a.enable_model_cpu_offload()
       pipe_a.enable_model_cpu_offload()

       pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()						)
       pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()						)

       self._test_if_inpainting(_UpperCAmelCase       ,				_UpperCAmelCase       ,				_UpperCAmelCase       ,				_UpperCAmelCase						)

 def      lowerCAmelCase_				(					self			:			List[Any]       ,				_UpperCAmelCase			:			Optional[Any]       ,				_UpperCAmelCase			:			Any       ,				_UpperCAmelCase			:			int       ,				_UpperCAmelCase			:			Optional[Any]						):
       # pipeline 1

       _start_torch_memory_measurement()

       _A     =  torch.Generator(device='cpu'						).manual_seed(0						)
       _A     =  pipe_a(
           prompt_embeds=_UpperCAmelCase       ,				negative_prompt_embeds=_UpperCAmelCase       ,				num_inference_steps=2       ,				generator=_UpperCAmelCase       ,				output_type='np'       ,				)

       _A     =  output.images[0]

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

       _A     =  torch.cuda.max_memory_allocated()
       assert mem_bytes < 13 * 10**9

       _A     =  load_numpy(
           'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if.npy'						)
       assert_mean_pixel_difference(_UpperCAmelCase       ,				_UpperCAmelCase						)

       # pipeline 2

       _start_torch_memory_measurement()

       _A     =  torch.Generator(device='cpu'						).manual_seed(0						)

       _A     =  floats_tensor((1, 3, 64, 64)       ,				rng=random.Random(0						)						).to(_UpperCAmelCase						)

       _A     =  pipe_a(
           prompt_embeds=_UpperCAmelCase       ,				negative_prompt_embeds=_UpperCAmelCase       ,				image=_UpperCAmelCase       ,				generator=_UpperCAmelCase       ,				num_inference_steps=2       ,				output_type='np'       ,				)

       _A     =  output.images[0]

       assert image.shape == (256, 256, 3)

       _A     =  torch.cuda.max_memory_allocated()
       assert mem_bytes < 4 * 10**9

       _A     =  load_numpy(
           'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_superresolution_stage_II.npy'						)
       assert_mean_pixel_difference(_UpperCAmelCase       ,				_UpperCAmelCase						)

 def      lowerCAmelCase_				(					self			:			Tuple       ,				_UpperCAmelCase			:			Optional[int]       ,				_UpperCAmelCase			:			int       ,				_UpperCAmelCase			:			str       ,				_UpperCAmelCase			:			Optional[Any]						):
       # pipeline 1

       _start_torch_memory_measurement()

       _A     =  floats_tensor((1, 3, 64, 64)       ,				rng=random.Random(0						)						).to(_UpperCAmelCase						)

       _A     =  torch.Generator(device='cpu'						).manual_seed(0						)

       _A     =  pipe_a(
           prompt_embeds=_UpperCAmelCase       ,				negative_prompt_embeds=_UpperCAmelCase       ,				image=_UpperCAmelCase       ,				num_inference_steps=2       ,				generator=_UpperCAmelCase       ,				output_type='np'       ,				)

       _A     =  output.images[0]

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

       _A     =  torch.cuda.max_memory_allocated()
       assert mem_bytes < 10 * 10**9

       _A     =  load_numpy(
           'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_img2img.npy'						)
       assert_mean_pixel_difference(_UpperCAmelCase       ,				_UpperCAmelCase						)

       # pipeline 2

       _start_torch_memory_measurement()

       _A     =  torch.Generator(device='cpu'						).manual_seed(0						)

       _A     =  floats_tensor((1, 3, 256, 256)       ,				rng=random.Random(0						)						).to(_UpperCAmelCase						)
       _A     =  floats_tensor((1, 3, 64, 64)       ,				rng=random.Random(0						)						).to(_UpperCAmelCase						)

       _A     =  pipe_a(
           prompt_embeds=_UpperCAmelCase       ,				negative_prompt_embeds=_UpperCAmelCase       ,				image=_UpperCAmelCase       ,				original_image=_UpperCAmelCase       ,				generator=_UpperCAmelCase       ,				num_inference_steps=2       ,				output_type='np'       ,				)

       _A     =  output.images[0]

       assert image.shape == (256, 256, 3)

       _A     =  torch.cuda.max_memory_allocated()
       assert mem_bytes < 4 * 10**9

       _A     =  load_numpy(
           'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_img2img_superresolution_stage_II.npy'						)
       assert_mean_pixel_difference(_UpperCAmelCase       ,				_UpperCAmelCase						)



 def      lowerCAmelCase_				(					self			:			int       ,				_UpperCAmelCase			:			Optional[int]       ,				_UpperCAmelCase			:			int       ,				_UpperCAmelCase			:			Dict       ,				_UpperCAmelCase			:			Optional[Any]						):
       # pipeline 1

       _start_torch_memory_measurement()

       _A     =  floats_tensor((1, 3, 64, 64)       ,				rng=random.Random(0						)						).to(_UpperCAmelCase						)
       _A     =  floats_tensor((1, 3, 64, 64)       ,				rng=random.Random(1						)						).to(_UpperCAmelCase						)

       _A     =  torch.Generator(device='cpu'						).manual_seed(0						)
       _A     =  pipe_a(
           prompt_embeds=_UpperCAmelCase       ,				negative_prompt_embeds=_UpperCAmelCase       ,				image=_UpperCAmelCase       ,				mask_image=_UpperCAmelCase       ,				num_inference_steps=2       ,				generator=_UpperCAmelCase       ,				output_type='np'       ,				)

       _A     =  output.images[0]

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

       _A     =  torch.cuda.max_memory_allocated()
       assert mem_bytes < 10 * 10**9

       _A     =  load_numpy(
           'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_inpainting.npy'						)
       assert_mean_pixel_difference(_UpperCAmelCase       ,				_UpperCAmelCase						)

       # pipeline 2

       _start_torch_memory_measurement()

       _A     =  torch.Generator(device='cpu'						).manual_seed(0						)

       _A     =  floats_tensor((1, 3, 64, 64)       ,				rng=random.Random(0						)						).to(_UpperCAmelCase						)
       _A     =  floats_tensor((1, 3, 256, 256)       ,				rng=random.Random(0						)						).to(_UpperCAmelCase						)
       _A     =  floats_tensor((1, 3, 256, 256)       ,				rng=random.Random(1						)						).to(_UpperCAmelCase						)

       _A     =  pipe_a(
           prompt_embeds=_UpperCAmelCase       ,				negative_prompt_embeds=_UpperCAmelCase       ,				image=_UpperCAmelCase       ,				mask_image=_UpperCAmelCase       ,				original_image=_UpperCAmelCase       ,				generator=_UpperCAmelCase       ,				num_inference_steps=2       ,				output_type='np'       ,				)

       _A     =  output.images[0]

       assert image.shape == (256, 256, 3)

       _A     =  torch.cuda.max_memory_allocated()
       assert mem_bytes < 4 * 10**9

       _A     =  load_numpy(
           'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_inpainting_superresolution_stage_II.npy'						)
       assert_mean_pixel_difference(_UpperCAmelCase       ,				_UpperCAmelCase						)






def 		_snake_case	(   )       ->   Optional[int]:






      '''simple docstring'''


      torch.cuda.empty_cache()
      torch.cuda.reset_max_memory_allocated()
      torch.cuda.reset_peak_memory_stats()






"""simple docstring"""







def     UpperCAmelCase_					(				):




			'''simple docstring'''



			_lowerCamelCase					:					str	       =    0
			for i in range(1      ,							10_01						):
						total += i**i
			return str(__a						)[-10:]


if __name__ == "__main__":
	print(solution())





