
import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    StableDiffusionSAGPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

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


enable_full_determinism()







class   lowerCamelCase	(						lowercase__							,				lowercase__							,				unittest.TestCase						):
     UpperCAmelCase__       :							Any     =	StableDiffusionSAGPipeline
     UpperCAmelCase__       :							Union[str, Any]     =	TEXT_TO_IMAGE_PARAMS
     UpperCAmelCase__       :							Any     =	TEXT_TO_IMAGE_BATCH_PARAMS
     UpperCAmelCase__       :							Union[str, Any]     =	TEXT_TO_IMAGE_IMAGE_PARAMS
     UpperCAmelCase__       :							str     =	TEXT_TO_IMAGE_IMAGE_PARAMS
     UpperCAmelCase__       :							List[Any]     =	False





     def 	UpperCAmelCase(self   :					int     )		->		Dict:
         torch.manual_seed(0     )
         snake_case				  =      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       ,					)
         snake_case				  =      DDIMScheduler(
             beta_start=0.0_00_85       ,					beta_end=0.0_12       ,					beta_schedule="scaled_linear"       ,					clip_sample=_A       ,					set_alpha_to_one=_A       ,					)
         torch.manual_seed(0     )
         snake_case				  =      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       ,					)
         torch.manual_seed(0     )
         snake_case				  =      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       ,					)
         snake_case				  =      CLIPTextModel(_A     )
         snake_case				  =      CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"     )

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





     def 	UpperCAmelCase(self   :					str       ,					_A   :					Dict       ,					_A   :					Any=0     )		->		Tuple:
         if str(_A     ).startswith("mps"     ):
             snake_case				  =      torch.manual_seed(_A     )
         else:
             snake_case				  =      torch.Generator(device=_A     ).manual_seed(_A     )
         snake_case				  =      {
             "prompt": ".",
             "generator": generator,
             "num_inference_steps": 2,
             "guidance_scale": 1.0,
             "sag_scale": 1.0,
             "output_type": "numpy",
         }
         return inputs





     def 	UpperCAmelCase(self   :					List[Any]     )		->		int:
         super().test_inference_batch_single_identical(expected_max_diff=3E-3     )







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





     def 	UpperCAmelCase(self   :					Tuple     )		->		str:
         # clean up the VRAM after each test
         super().tearDown()
         gc.collect()
         torch.cuda.empty_cache()





     def 	UpperCAmelCase(self   :					Dict     )		->		Optional[Any]:
         snake_case				  =      StableDiffusionSAGPipeline.from_pretrained("CompVis/stable-diffusion-v1-4"     )
         snake_case				  =      sag_pipe.to(_A     )
         sag_pipe.set_progress_bar_config(disable=_A     )

         snake_case				  =      "."
         snake_case				  =      torch.manual_seed(0     )
         snake_case				  =      sag_pipe(
             [prompt]       ,					generator=_A       ,					guidance_scale=7.5       ,					sag_scale=1.0       ,					num_inference_steps=2_0       ,					output_type="np"     )

         snake_case				  =      output.images

         snake_case				  =      image[0, -3:, -3:, -1]

         assert image.shape == (1, 5_1_2, 5_1_2, 3)
         snake_case				  =      np.array([0.15_68, 0.17_38, 0.16_95, 0.16_93, 0.15_07, 0.17_05, 0.15_47, 0.17_51, 0.19_49]     )

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





     def 	UpperCAmelCase(self   :					str     )		->		Union[str, Any]:
         snake_case				  =      StableDiffusionSAGPipeline.from_pretrained("stabilityai/stable-diffusion-2-1-base"     )
         snake_case				  =      sag_pipe.to(_A     )
         sag_pipe.set_progress_bar_config(disable=_A     )

         snake_case				  =      "."
         snake_case				  =      torch.manual_seed(0     )
         snake_case				  =      sag_pipe(
             [prompt]       ,					generator=_A       ,					guidance_scale=7.5       ,					sag_scale=1.0       ,					num_inference_steps=2_0       ,					output_type="np"     )

         snake_case				  =      output.images

         snake_case				  =      image[0, -3:, -3:, -1]

         assert image.shape == (1, 5_1_2, 5_1_2, 3)
         snake_case				  =      np.array([0.34_59, 0.28_76, 0.25_37, 0.30_02, 0.26_71, 0.21_60, 0.30_26, 0.22_62, 0.23_71]     )

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





     def 	UpperCAmelCase(self   :					Optional[int]     )		->		Optional[Any]:
         snake_case				  =      StableDiffusionSAGPipeline.from_pretrained("stabilityai/stable-diffusion-2-1-base"     )
         snake_case				  =      sag_pipe.to(_A     )
         sag_pipe.set_progress_bar_config(disable=_A     )

         snake_case				  =      "."
         snake_case				  =      torch.manual_seed(0     )
         snake_case				  =      sag_pipe(
             [prompt]       ,					width=7_6_8       ,					height=5_1_2       ,					generator=_A       ,					guidance_scale=7.5       ,					sag_scale=1.0       ,					num_inference_steps=2_0       ,					output_type="np"       ,					)

         snake_case				  =      output.images

         assert image.shape == (1, 5_1_2, 7_6_8, 3)








import os

# Precomputes a list of the 100 first triangular numbers
_A						      =				[int(0.5 * n * (n + 1)) for n in range(1, 1_01)]



def 		lowercase_    (     )							->							Tuple:
    """simple docstring"""

    snake_case				  =      os.path.dirname(os.path.realpath(A__	)	)
    snake_case				  =      os.path.join(A__				,	"words.txt"	)

    snake_case				  =      ""
    with open(A__	) as f:
        snake_case				  =      f.readline()

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


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

