



import gc
import unittest

import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTextModelWithProjection, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    DDPMScheduler,
    PriorTransformer,
    StableUnCLIPPipeline,
    UNetaDConditionModel,
)
from diffusers.pipelines.stable_diffusion.stable_unclip_image_normalizer import StableUnCLIPImageNormalizer
from diffusers.utils.testing_utils import enable_full_determinism, load_numpy, require_torch_gpu, slow, torch_device

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import (
    PipelineKarrasSchedulerTesterMixin,
    PipelineLatentTesterMixin,
    PipelineTesterMixin,
    assert_mean_pixel_difference,
)


enable_full_determinism()






class    SCREAMING_SNAKE_CASE			(							__lowerCamelCase			,      __lowerCamelCase			,      __lowerCamelCase			,      unittest.TestCase					):
							__lowerCamelCase	:	Any    =StableUnCLIPPipeline
							__lowerCamelCase	:	List[str]    =TEXT_TO_IMAGE_PARAMS
							__lowerCamelCase	:	Optional[Any]    =TEXT_TO_IMAGE_BATCH_PARAMS
							__lowerCamelCase	:	Optional[int]    =TEXT_TO_IMAGE_IMAGE_PARAMS
							__lowerCamelCase	:	Optional[Any]    =TEXT_TO_IMAGE_IMAGE_PARAMS

							# TODO(will) Expected attn_bias.stride(1) == 0 to be true, but got false
							__lowerCamelCase	:	Optional[int]    =False





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

											'''simple docstring'''
											__a       =		32
											__a       =		embedder_hidden_size

											# prior components

											torch.manual_seed(0	)
											__a       =		CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""	)

											torch.manual_seed(0	)
											__a       =		CLIPTextModelWithProjection(
											    CLIPTextConfig(
											        bos_token_id=0      ,				eos_token_id=2      ,				hidden_size=UpperCamelCase_      ,				projection_dim=UpperCamelCase_      ,				intermediate_size=37      ,				layer_norm_eps=1E-05      ,				num_attention_heads=4      ,				num_hidden_layers=5      ,				pad_token_id=1      ,				vocab_size=1000      ,				)	)

											torch.manual_seed(0	)
											__a       =		PriorTransformer(
											    num_attention_heads=2      ,				attention_head_dim=12      ,				embedding_dim=UpperCamelCase_      ,				num_layers=1      ,				)

											torch.manual_seed(0	)
											__a       =		DDPMScheduler(
											    variance_type="""fixed_small_log"""      ,				prediction_type="""sample"""      ,				num_train_timesteps=1000      ,				clip_sample=UpperCamelCase_      ,				clip_sample_range=5.0      ,				beta_schedule="""squaredcos_cap_v2"""      ,				)

											# regular denoising components

											torch.manual_seed(0	)
											__a       =		StableUnCLIPImageNormalizer(embedding_dim=UpperCamelCase_	)
											__a       =		DDPMScheduler(beta_schedule="""squaredcos_cap_v2"""	)

											torch.manual_seed(0	)
											__a       =		CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""	)

											torch.manual_seed(0	)
											__a       =		CLIPTextModel(
											    CLIPTextConfig(
											        bos_token_id=0      ,				eos_token_id=2      ,				hidden_size=UpperCamelCase_      ,				projection_dim=32      ,				intermediate_size=37      ,				layer_norm_eps=1E-05      ,				num_attention_heads=4      ,				num_hidden_layers=5      ,				pad_token_id=1      ,				vocab_size=1000      ,				)	)

											torch.manual_seed(0	)
											__a       =		UNetaDConditionModel(
											    sample_size=32      ,				in_channels=4      ,				out_channels=4      ,				down_block_types=("""CrossAttnDownBlock2D""", """DownBlock2D""")      ,				up_block_types=("""UpBlock2D""", """CrossAttnUpBlock2D""")      ,				block_out_channels=(32, 64)      ,				attention_head_dim=(2, 4)      ,				class_embed_type="""projection"""      ,				projection_class_embeddings_input_dim=embedder_projection_dim * 2      ,				cross_attention_dim=UpperCamelCase_      ,				layers_per_block=1      ,				upcast_attention=UpperCamelCase_      ,				use_linear_projection=UpperCamelCase_      ,				)

											torch.manual_seed(0	)
											__a       =		DDIMScheduler(
											    beta_schedule="""scaled_linear"""      ,				beta_start=0.00085      ,				beta_end=0.012      ,				prediction_type="""v_prediction"""      ,				set_alpha_to_one=UpperCamelCase_      ,				steps_offset=1      ,				)

											torch.manual_seed(0	)
											__a       =		AutoencoderKL()

											__a       =		{
											    # prior components
											    """prior_tokenizer""": prior_tokenizer,
											    """prior_text_encoder""": prior_text_encoder,
											    """prior""": prior,
											    """prior_scheduler""": prior_scheduler,
											    # image noising components
											    """image_normalizer""": image_normalizer,
											    """image_noising_scheduler""": image_noising_scheduler,
											    # regular denoising components
											    """tokenizer""": tokenizer,
											    """text_encoder""": text_encoder,
											    """unet""": unet,
											    """scheduler""": scheduler,
											    """vae""": vae,
											}

											return components





							def 						UpperCamelCase_					(   self		:		Union[str, Any]      ,				__lowercase		:		int      ,				__lowercase		:		Optional[int]=0	):

											'''simple docstring'''
											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,
											    """prior_num_inference_steps""": 2,
											    """output_type""": """numpy""",
											}
											return inputs





							def 						UpperCamelCase_					(   self		:		List[str]	):

											'''simple docstring'''
											__a       =		torch_device == """cpu"""

											self._test_attention_slicing_forward_pass(test_max_difference=UpperCamelCase_	)







							def 						UpperCamelCase_					(   self		:		Dict	):

											'''simple docstring'''
											__a       =		torch_device in ["""cpu""", """mps"""]

											self._test_inference_batch_single_identical(test_max_difference=UpperCamelCase_	)






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





							def 						UpperCamelCase_					(   self		:		Optional[int]	):

											'''simple docstring'''
											# clean up the VRAM after each test
											super().tearDown()
											gc.collect()
											torch.cuda.empty_cache()





							def 						UpperCamelCase_					(   self		:		List[str]	):

											'''simple docstring'''
											__a       =		load_numpy(
											    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/stable_unclip_2_1_l_anime_turtle_fp16.npy"""	)

											__a       =		StableUnCLIPPipeline.from_pretrained("""fusing/stable-unclip-2-1-l"""      ,				torch_dtype=torch.floataa	)
											pipe.to(UpperCamelCase_	)
											pipe.set_progress_bar_config(disable=UpperCamelCase_	)
											# stable unclip will oom when integration tests are run on a V100,
											# so turn on memory savings
											pipe.enable_attention_slicing()
											pipe.enable_sequential_cpu_offload()

											__a       =		torch.Generator(device="""cpu"""	).manual_seed(0	)
											__a       =		pipe("""anime turle"""      ,				generator=UpperCamelCase_      ,				output_type="""np"""	)

											__a       =		output.images[0]

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

											assert_mean_pixel_difference(UpperCamelCase_      ,				UpperCamelCase_	)







							def 						UpperCamelCase_					(   self		:		Optional[Any]	):

											'''simple docstring'''
											torch.cuda.empty_cache()
											torch.cuda.reset_max_memory_allocated()
											torch.cuda.reset_peak_memory_stats()

											__a       =		StableUnCLIPPipeline.from_pretrained("""fusing/stable-unclip-2-1-l"""      ,				torch_dtype=torch.floataa	)
											__a       =		pipe.to(UpperCamelCase_	)
											pipe.set_progress_bar_config(disable=UpperCamelCase_	)
											pipe.enable_attention_slicing()
											pipe.enable_sequential_cpu_offload()

											__a       =		pipe(
											    """anime turtle"""      ,				prior_num_inference_steps=2      ,				num_inference_steps=2      ,				output_type="""np"""      ,				)

											__a       =		torch.cuda.max_memory_allocated()
											# make sure that less than 7 GB is allocated
											assert mem_bytes < 7 * 10**9





import os

def   lowerCAmelCase__						(							):
				"""simple docstring"""







				__a       =		os.path.dirname(os.path.realpath(_SCREAMING_SNAKE_CASE    )    )
				__a       =		os.path.join(_SCREAMING_SNAKE_CASE				,     """triangle.txt"""    )

				with open(_SCREAMING_SNAKE_CASE    ) as f:
								__a       =		f.readlines()

				__a       =		[]
				for line in triangle:
								__a       =		[]
								for number in line.strip().split(""" """    ):
												numbers_from_line.append(int(_SCREAMING_SNAKE_CASE    )    )
								a.append(_SCREAMING_SNAKE_CASE    )

				for i in range(1				,     len(_SCREAMING_SNAKE_CASE    )    ):
								for j in range(len(a[i]    )    ):
												__a       =		a[i - 1][j] if j != len(a[i - 1]    ) else 0
												__a       =		a[i - 1][j - 1] if j > 0 else 0
												a[i][j] += max(_SCREAMING_SNAKE_CASE				,     _SCREAMING_SNAKE_CASE    )
				return max(a[-1]    )


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