





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   (       snake_case__				,						snake_case__				,						snake_case__				,						unittest.TestCase    ):
							snake_case       : Union[str, Any]         =    StableUnCLIPPipeline
							snake_case       : Optional[Any]         =    TEXT_TO_IMAGE_PARAMS
							snake_case       : Optional[int]         =    TEXT_TO_IMAGE_BATCH_PARAMS
							snake_case       : Optional[Any]         =    TEXT_TO_IMAGE_IMAGE_PARAMS
							snake_case       : List[Any]         =    TEXT_TO_IMAGE_IMAGE_PARAMS

							# TODO(will) Expected attn_bias.stride(1) == 0 to be true, but got false
							snake_case       : str         =    False






							def 			_lowerCamelCase						(  self					):
														UpperCamelCase__			       =     32
														UpperCamelCase__			       =     embedder_hidden_size

														# prior components

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

														torch.manual_seed(0					)
														UpperCamelCase__			       =     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					)
														UpperCamelCase__			       =     PriorTransformer(
														    num_attention_heads=2					,	attention_head_dim=12					,	embedding_dim=UpperCAmelCase_					,	num_layers=1					,	)

														torch.manual_seed(0					)
														UpperCamelCase__			       =     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					)
														UpperCamelCase__			       =     StableUnCLIPImageNormalizer(embedding_dim=UpperCAmelCase_					)
														UpperCamelCase__			       =     DDPMScheduler(beta_schedule="""squaredcos_cap_v2"""					)

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

														torch.manual_seed(0					)
														UpperCamelCase__			       =     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					)
														UpperCamelCase__			       =     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					)
														UpperCamelCase__			       =     DDIMScheduler(
														    beta_schedule="""scaled_linear"""					,	beta_start=0.0_0085					,	beta_end=0.012					,	prediction_type="""v_prediction"""					,	set_alpha_to_one=UpperCAmelCase_					,	steps_offset=1					,	)

														torch.manual_seed(0					)
														UpperCamelCase__			       =     AutoencoderKL()

														UpperCamelCase__			       =     {
														    # 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 			_lowerCamelCase						(  self					,	__lowerCAmelCase					,	__lowerCAmelCase=0					):
														if str(UpperCAmelCase_					).startswith("""mps"""					):
																					UpperCamelCase__			       =     torch.manual_seed(UpperCAmelCase_					)
														else:
																					UpperCamelCase__			       =     torch.Generator(device=UpperCAmelCase_					).manual_seed(UpperCAmelCase_					)
														UpperCamelCase__			       =     {
														    "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 			_lowerCamelCase						(  self					):
														UpperCamelCase__			       =     torch_device == "cpu"

														self._test_attention_slicing_forward_pass(test_max_difference=UpperCAmelCase_					)







							def 			_lowerCamelCase						(  self					):
														UpperCamelCase__			       =     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 			_lowerCamelCase						(  self					):
														super().tearDown()
														gc.collect()
														torch.cuda.empty_cache()






							def 			_lowerCamelCase						(  self					):
														UpperCamelCase__			       =     load_numpy(
														    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/stable_unclip_2_1_l_anime_turtle_fp16.npy"""					)

														UpperCamelCase__			       =     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()

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

														UpperCamelCase__			       =     output.images[0]

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

														assert_mean_pixel_difference(UpperCAmelCase_					,	UpperCAmelCase_					)







							def 			_lowerCamelCase						(  self					):
														torch.cuda.empty_cache()
														torch.cuda.reset_max_memory_allocated()
														torch.cuda.reset_peak_memory_stats()

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

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

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











from typing import Dict

import numpy as np
import torch

from . import residue_constants as rc
from .tensor_utils import tensor_tree_map, tree_map





def       _UpperCamelCase       (a__				:Dict[str, torch.Tensor]    ):






							"""simple docstring"""





							UpperCamelCase__			       =     []
							UpperCamelCase__			       =     []
							UpperCamelCase__			       =     []

							for rt in rc.restypes:
														UpperCamelCase__			       =     rc.restype_name_to_atomaa_names[rc.restype_atoa[rt]]
														restype_atomaa_to_atomaa_list.append([(rc.atom_order[name] if name else 0) for name in atom_names]    )
														UpperCamelCase__			       =     {name: i for i, name in enumerate(a__    )}
														restype_atomaa_to_atomaa_list.append(
														    [(atom_name_to_idxaa[name] if name in atom_name_to_idxaa else 0) for name in rc.atom_types]    )

														restype_atomaa_mask_list.append([(1.0 if name else 0.0) for name in atom_names]    )

							# Add dummy mapping for restype 'UNK'
							restype_atomaa_to_atomaa_list.append([0] * 14    )
							restype_atomaa_to_atomaa_list.append([0] * 37    )
							restype_atomaa_mask_list.append([0.0] * 14    )

							UpperCamelCase__			       =     torch.tensor(
							    a__				,     dtype=torch.intaa				,     device=protein["""aatype"""].device				,     )
							UpperCamelCase__			       =     torch.tensor(
							    a__				,     dtype=torch.intaa				,     device=protein["""aatype"""].device				,     )
							UpperCamelCase__			       =     torch.tensor(
							    a__				,     dtype=torch.floataa				,     device=protein["""aatype"""].device				,     )
							UpperCamelCase__			       =     protein["""aatype"""].to(torch.long    )

							# create the mapping for (residx, atom14) --> atom37, i.e. an array
							# with shape (num_res, 14) containing the atom37 indices for this protein
							UpperCamelCase__			       =     restype_atomaa_to_atomaa[protein_aatype]
							UpperCamelCase__			       =     restype_atomaa_mask[protein_aatype]

							UpperCamelCase__			       =     residx_atomaa_mask
							UpperCamelCase__			       =     residx_atomaa_to_atomaa.long()

							# create the gather indices for mapping back
							UpperCamelCase__			       =     restype_atomaa_to_atomaa[protein_aatype]
							UpperCamelCase__			       =     residx_atomaa_to_atomaa.long()

							# create the corresponding mask
							UpperCamelCase__			       =     torch.zeros([21, 37]				,     dtype=torch.floataa				,     device=protein["""aatype"""].device    )
							for restype, restype_letter in enumerate(rc.restypes    ):
														UpperCamelCase__			       =     rc.restype_atoa[restype_letter]
														UpperCamelCase__			       =     rc.residue_atoms[restype_name]
														for atom_name in atom_names:
																					UpperCamelCase__			       =     rc.atom_order[atom_name]
																					UpperCamelCase__			       =     1

							UpperCamelCase__			       =     restype_atomaa_mask[protein_aatype]
							UpperCamelCase__			       =     residx_atomaa_mask

							return protein





def       _UpperCamelCase       (a__				:Dict[str, torch.Tensor]    ):






							"""simple docstring"""





							UpperCamelCase__			       =     tree_map(lambda a__    : torch.tensor(a__				,     device=batch["""aatype"""].device    )				,     a__				,     np.ndarray    )
							UpperCamelCase__			       =     tensor_tree_map(lambda a__    : np.array(a__    )				,     make_atomaa_masks(a__    )    )
							return out




