




'''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 			_a  (	_UpperCAmelCase							,							_UpperCAmelCase							,							unittest.TestCase ):
       __a				:     List[str]   				=					IFPipeline
       __a				:     List[str]   				=					TEXT_TO_IMAGE_PARAMS - {"""width""", """height""", """latents"""}
       __a				:     List[str]   				=					TEXT_TO_IMAGE_BATCH_PARAMS
       __a				:     List[Any]   				=					PipelineTesterMixin.required_optional_params - {"""latents"""}
       def     A      (	self						:	str				):



           '''simple docstring'''

           return self._get_dummy_components()
       def     A      (	self						:	Optional[Any]   ,				lowercase						:	Tuple   ,				lowercase						:	List[str]=0				):



           '''simple docstring'''

           if str(lowercase_				).startswith('''mps'''				):
               UpperCAmelCase			       =		torch.manual_seed(lowercase_				)
           else:
               UpperCAmelCase			       =		torch.Generator(device=lowercase_				).manual_seed(lowercase_				)

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

           return inputs
       def     A      (	self						:	List[str]				):



           '''simple docstring'''

           self._test_save_load_optional_components()
       @unittest.skipIf(torch_device != '''cuda'''   ,				reason='''float16 requires CUDA'''				)
       def     A      (	self						:	Optional[Any]				):



           '''simple docstring'''

           super().test_save_load_floataa(expected_max_diff=1E-1				)
       def     A      (	self						:	Optional[int]				):



           '''simple docstring'''

           self._test_attention_slicing_forward_pass(expected_max_diff=1E-2				)
       def     A      (	self						:	Union[str, Any]				):



           '''simple docstring'''

           self._test_save_load_local()
       def     A      (	self						:	str				):



           '''simple docstring'''

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



           '''simple docstring'''

           self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3				)






@slow
@require_torch_gpu
class 			_a  (	unittest.TestCase ):
       def     A      (	self						:	Any				):



           '''simple docstring'''

           super().tearDown()
           gc.collect()
           torch.cuda.empty_cache()
       def     A      (	self						:	Dict				):



           '''simple docstring'''

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

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

           # pre compute text embeddings and remove T5 to save memory

           pipe_a.text_encoder.to('''cuda'''				)

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

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

           UpperCAmelCase			       =		None
           UpperCAmelCase			       =		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(lowercase_   ,				lowercase_   ,				lowercase_   ,				lowercase_				)

           pipe_a.remove_all_hooks()
           pipe_a.remove_all_hooks()

           # img2img

           UpperCAmelCase			       =		IFImgaImgPipeline(**pipe_a.components				)
           UpperCAmelCase			       =		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(lowercase_   ,				lowercase_   ,				lowercase_   ,				lowercase_				)

           pipe_a.remove_all_hooks()
           pipe_a.remove_all_hooks()

           # inpainting

           UpperCAmelCase			       =		IFInpaintingPipeline(**pipe_a.components				)
           UpperCAmelCase			       =		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(lowercase_   ,				lowercase_   ,				lowercase_   ,				lowercase_				)
       def     A      (	self						:	Tuple   ,				lowercase						:	List[Any]   ,				lowercase						:	Optional[int]   ,				lowercase						:	Any   ,				lowercase						:	Optional[Any]				):



           '''simple docstring'''

           _start_torch_memory_measurement()

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

           UpperCAmelCase			       =		output.images[0]

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

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

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

           # pipeline 2

           _start_torch_memory_measurement()

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

           UpperCAmelCase			       =		floats_tensor((1, 3, 64, 64)   ,				rng=random.Random(0				)				).to(lowercase_				)

           UpperCAmelCase			       =		pipe_a(
               prompt_embeds=lowercase_   ,				negative_prompt_embeds=lowercase_   ,				image=lowercase_   ,				generator=lowercase_   ,				num_inference_steps=2   ,				output_type='''np'''   ,				)

           UpperCAmelCase			       =		output.images[0]

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

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

           UpperCAmelCase			       =		load_numpy(
               '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_superresolution_stage_II.npy'''				)
           assert_mean_pixel_difference(lowercase_   ,				lowercase_				)
       def     A      (	self						:	Union[str, Any]   ,				lowercase						:	List[Any]   ,				lowercase						:	Optional[int]   ,				lowercase						:	List[str]   ,				lowercase						:	Any				):



           '''simple docstring'''

           _start_torch_memory_measurement()

           UpperCAmelCase			       =		floats_tensor((1, 3, 64, 64)   ,				rng=random.Random(0				)				).to(lowercase_				)

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

           UpperCAmelCase			       =		pipe_a(
               prompt_embeds=lowercase_   ,				negative_prompt_embeds=lowercase_   ,				image=lowercase_   ,				num_inference_steps=2   ,				generator=lowercase_   ,				output_type='''np'''   ,				)

           UpperCAmelCase			       =		output.images[0]

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

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

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

           # pipeline 2

           _start_torch_memory_measurement()

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

           UpperCAmelCase			       =		floats_tensor((1, 3, 256, 256)   ,				rng=random.Random(0				)				).to(lowercase_				)
           UpperCAmelCase			       =		floats_tensor((1, 3, 64, 64)   ,				rng=random.Random(0				)				).to(lowercase_				)

           UpperCAmelCase			       =		pipe_a(
               prompt_embeds=lowercase_   ,				negative_prompt_embeds=lowercase_   ,				image=lowercase_   ,				original_image=lowercase_   ,				generator=lowercase_   ,				num_inference_steps=2   ,				output_type='''np'''   ,				)

           UpperCAmelCase			       =		output.images[0]

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

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

           UpperCAmelCase			       =		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(lowercase_   ,				lowercase_				)







       def     A      (	self						:	Optional[Any]   ,				lowercase						:	str   ,				lowercase						:	int   ,				lowercase						:	List[str]   ,				lowercase						:	int				):



           '''simple docstring'''

           _start_torch_memory_measurement()

           UpperCAmelCase			       =		floats_tensor((1, 3, 64, 64)   ,				rng=random.Random(0				)				).to(lowercase_				)
           UpperCAmelCase			       =		floats_tensor((1, 3, 64, 64)   ,				rng=random.Random(1				)				).to(lowercase_				)

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

           UpperCAmelCase			       =		output.images[0]

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

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

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

           # pipeline 2

           _start_torch_memory_measurement()

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

           UpperCAmelCase			       =		floats_tensor((1, 3, 64, 64)   ,				rng=random.Random(0				)				).to(lowercase_				)
           UpperCAmelCase			       =		floats_tensor((1, 3, 256, 256)   ,				rng=random.Random(0				)				).to(lowercase_				)
           UpperCAmelCase			       =		floats_tensor((1, 3, 256, 256)   ,				rng=random.Random(1				)				).to(lowercase_				)

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

           UpperCAmelCase			       =		output.images[0]

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

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

           UpperCAmelCase			       =		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(lowercase_   ,				lowercase_				)






def 						snake_case_							():
    torch.cuda.empty_cache()
    torch.cuda.reset_max_memory_allocated()
    torch.cuda.reset_peak_memory_stats()







import os

# Precomputes a list of the 100 first triangular numbers
lowercase_       		=  [int(0.5 * n * (n + 1)) for n in range(1, 101)]
def 						_snake_case(    )							->      int:





    '''simple docstring'''






    A__          =   os.path.dirname(os.path.realpath(SCREAMING_SNAKE_CASE__      )      )
    A__          =   os.path.join(SCREAMING_SNAKE_CASE__    ,			'words.txt'      )

    A__          =   ''
    with open(SCREAMING_SNAKE_CASE__      ) as f:
        A__          =   f.readline()

    A__          =   [word.strip('"'      ) for word in words.strip('\r\n'      ).split(','      )]
    A__          =   [
        word
        for word in [sum(ord(SCREAMING_SNAKE_CASE__      ) - 64 for x in word      ) for word in words]
        if word in TRIANGULAR_NUMBERS
    ]
    return len(SCREAMING_SNAKE_CASE__      )


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

