



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 						__a (     SCREAMING_SNAKE_CASE	,    SCREAMING_SNAKE_CASE	,    SCREAMING_SNAKE_CASE	,    unittest.TestCase				):
	SCREAMING_SNAKE_CASE       =       StableUnCLIPPipeline
	SCREAMING_SNAKE_CASE       =       TEXT_TO_IMAGE_PARAMS
	SCREAMING_SNAKE_CASE       =       TEXT_TO_IMAGE_BATCH_PARAMS
	SCREAMING_SNAKE_CASE       =       TEXT_TO_IMAGE_IMAGE_PARAMS
	SCREAMING_SNAKE_CASE       =       TEXT_TO_IMAGE_IMAGE_PARAMS

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






	def 		UpperCamelCase							(						self							:    Optional[int])->							List[str]:
						__lowerCAmelCase	   =32
						__lowerCAmelCase	   =embedder_hidden_size

						# prior components

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

						torch.manual_seed(0)
						__lowerCAmelCase	   =CLIPTextModelWithProjection(
						    CLIPTextConfig(
						        bos_token_id=0				,	eos_token_id=2				,	hidden_size=snake_case_				,	projection_dim=snake_case_				,	intermediate_size=37				,	layer_norm_eps=1e-05				,	num_attention_heads=4				,	num_hidden_layers=5				,	pad_token_id=1				,	vocab_size=10_00				,	))

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

						torch.manual_seed(0)
						__lowerCAmelCase	   =DDPMScheduler(
						    variance_type="""fixed_small_log"""				,	prediction_type="""sample"""				,	num_train_timesteps=10_00				,	clip_sample=snake_case_				,	clip_sample_range=5.0				,	beta_schedule="""squaredcos_cap_v2"""				,	)

						# regular denoising components

						torch.manual_seed(0)
						__lowerCAmelCase	   =StableUnCLIPImageNormalizer(embedding_dim=snake_case_)
						__lowerCAmelCase	   =DDPMScheduler(beta_schedule="""squaredcos_cap_v2""")

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

						torch.manual_seed(0)
						__lowerCAmelCase	   =CLIPTextModel(
						    CLIPTextConfig(
						        bos_token_id=0				,	eos_token_id=2				,	hidden_size=snake_case_				,	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=10_00				,	))

						torch.manual_seed(0)
						__lowerCAmelCase	   =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=snake_case_				,	layers_per_block=1				,	upcast_attention=snake_case_				,	use_linear_projection=snake_case_				,	)

						torch.manual_seed(0)
						__lowerCAmelCase	   =DDIMScheduler(
						    beta_schedule="""scaled_linear"""				,	beta_start=0.0_0_0_8_5				,	beta_end=0.0_1_2				,	prediction_type="""v_prediction"""				,	set_alpha_to_one=snake_case_				,	steps_offset=1				,	)

						torch.manual_seed(0)
						__lowerCAmelCase	   =AutoencoderKL()

						__lowerCAmelCase	   ={
						    # 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							:    Optional[Any]				,	snake_case_							:    Tuple				,	snake_case_							:    Dict=0)->							List[str]:
						if str(snake_case_).startswith("""mps"""):
											__lowerCAmelCase	   =torch.manual_seed(snake_case_)
						else:
											__lowerCAmelCase	   =torch.Generator(device=snake_case_).manual_seed(snake_case_)
						__lowerCAmelCase	   ={
						    """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							:    Any)->							List[str]:
						__lowerCAmelCase	   =torch_device == """cpu"""

						self._test_attention_slicing_forward_pass(test_max_difference=snake_case_)






	def 		UpperCamelCase							(						self							:    Dict)->							Dict:
						__lowerCAmelCase	   =torch_device in ["""cpu""", """mps"""]

						self._test_inference_batch_single_identical(test_max_difference=snake_case_)






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






	def 		UpperCamelCase							(						self							:    Tuple)->							Optional[Any]:
						# clean up the VRAM after each test
						super().tearDown()
						gc.collect()
						torch.cuda.empty_cache()






	def 		UpperCamelCase							(						self							:    Dict)->							int:
						__lowerCAmelCase	   =load_numpy(
						    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/stable_unclip_2_1_l_anime_turtle_fp16.npy""")

						__lowerCAmelCase	   =StableUnCLIPPipeline.from_pretrained("""fusing/stable-unclip-2-1-l"""				,	torch_dtype=torch.floataa)
						pipe.to(snake_case_)
						pipe.set_progress_bar_config(disable=snake_case_)
						# 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()

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

						__lowerCAmelCase	   =output.images[0]

						assert image.shape == (7_68, 7_68, 3)

						assert_mean_pixel_difference(snake_case_				,	snake_case_)






	def 		UpperCamelCase							(						self							:    Optional[Any])->							str:
						torch.cuda.empty_cache()
						torch.cuda.reset_max_memory_allocated()
						torch.cuda.reset_peak_memory_stats()

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

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

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









from dataclasses import asdict, dataclass
from typing import Optional

from ...configuration_utils import PretrainedConfig
from ...utils import logging


lowercase_	       =			logging.get_logger(__name__)

# TODO Update this
lowercase_	       =			{
    '''facebook/esm-1b''': '''https://huggingface.co/facebook/esm-1b/resolve/main/config.json''',
    # See all ESM models at https://huggingface.co/models?filter=esm
}






class 						__a (     SCREAMING_SNAKE_CASE				):
	SCREAMING_SNAKE_CASE       =       "esm"



	def __init__(						self							:    Any				,	snake_case_							:    List[str]=None				,	snake_case_							:    Tuple=None				,	snake_case_							:    str=None				,	snake_case_							:    str=7_68				,	snake_case_							:    Optional[int]=12				,	snake_case_							:    Tuple=12				,	snake_case_							:    Dict=30_72				,	snake_case_							:    Optional[Any]=0.1				,	snake_case_							:    Dict=0.1				,	snake_case_							:    Optional[Any]=10_26				,	snake_case_							:    int=0.0_2				,	snake_case_							:    Any=1e-12				,	snake_case_							:    Union[str, Any]="absolute"				,	snake_case_							:    Optional[int]=True				,	snake_case_							:    Tuple=None				,	snake_case_							:    Optional[int]=False				,	snake_case_							:    int=False				,	snake_case_							:    Optional[int]=None				,	snake_case_							:    List[Any]=None				,	**snake_case_							:    Optional[int]				,	)->							Any:
						super().__init__(pad_token_id=snake_case_				,	mask_token_id=snake_case_				,	**snake_case_)

						__lowerCAmelCase	   =vocab_size
						__lowerCAmelCase	   =hidden_size
						__lowerCAmelCase	   =num_hidden_layers
						__lowerCAmelCase	   =num_attention_heads
						__lowerCAmelCase	   =intermediate_size
						__lowerCAmelCase	   =hidden_dropout_prob
						__lowerCAmelCase	   =attention_probs_dropout_prob
						__lowerCAmelCase	   =max_position_embeddings
						__lowerCAmelCase	   =initializer_range
						__lowerCAmelCase	   =layer_norm_eps
						__lowerCAmelCase	   =position_embedding_type
						__lowerCAmelCase	   =use_cache
						__lowerCAmelCase	   =emb_layer_norm_before
						__lowerCAmelCase	   =token_dropout
						__lowerCAmelCase	   =is_folding_model
						if is_folding_model:
											if esmfold_config is None:
																logger.info("""No esmfold_config supplied for folding model, using default values.""")
																__lowerCAmelCase	   =EsmFoldConfig()
											elif isinstance(snake_case_				,	snake_case_):
																__lowerCAmelCase	   =EsmFoldConfig(**snake_case_)
											__lowerCAmelCase	   =esmfold_config
											if vocab_list is None:
																logger.warning("""No vocab_list supplied for folding model, assuming the ESM-2 vocabulary!""")
																__lowerCAmelCase	   =get_default_vocab_list()
											else:
																__lowerCAmelCase	   =vocab_list
						else:
											__lowerCAmelCase	   =None
											__lowerCAmelCase	   =None
						if self.esmfold_config is not None and getattr(self.esmfold_config				,	"""use_esm_attn_map"""				,	snake_case_):
											raise ValueError("""The HuggingFace port of ESMFold does not support use_esm_attn_map at this time!""")



	def 		UpperCamelCase							(						self							:    Dict)->							Union[str, Any]:
						__lowerCAmelCase	   =super().to_dict()
						if isinstance(self.esmfold_config				,	snake_case_):
											__lowerCAmelCase	   =self.esmfold_config.to_dict()
						return output






@dataclass
class 						__a :
	SCREAMING_SNAKE_CASE       =       None
	SCREAMING_SNAKE_CASE       =       True
	SCREAMING_SNAKE_CASE       =       False
	SCREAMING_SNAKE_CASE       =       False
	SCREAMING_SNAKE_CASE       =       False
	SCREAMING_SNAKE_CASE       =       0

	SCREAMING_SNAKE_CASE       =       True
	SCREAMING_SNAKE_CASE       =       False

	SCREAMING_SNAKE_CASE       =       128
	SCREAMING_SNAKE_CASE       =       None



	def 		UpperCamelCase							(						self							:    Dict)->							List[Any]:
						if self.trunk is None:
											__lowerCAmelCase	   =TrunkConfig()
						elif isinstance(self.trunk				,	snake_case_):
											__lowerCAmelCase	   =TrunkConfig(**self.trunk)



	def 		UpperCamelCase							(						self							:    Optional[Any])->							int:
						__lowerCAmelCase	   =asdict(self)
						__lowerCAmelCase	   =self.trunk.to_dict()
						return output






@dataclass
class 						__a :
	SCREAMING_SNAKE_CASE       =       48
	SCREAMING_SNAKE_CASE       =       1024
	SCREAMING_SNAKE_CASE       =       128
	SCREAMING_SNAKE_CASE       =       32
	SCREAMING_SNAKE_CASE       =       32
	SCREAMING_SNAKE_CASE       =       32
	SCREAMING_SNAKE_CASE       =       0
	SCREAMING_SNAKE_CASE       =       0
	SCREAMING_SNAKE_CASE       =       False
	SCREAMING_SNAKE_CASE       =       4
	SCREAMING_SNAKE_CASE       =       128
	SCREAMING_SNAKE_CASE       =       None



	def 		UpperCamelCase							(						self							:    Tuple)->							Optional[int]:
						if self.structure_module is None:
											__lowerCAmelCase	   =StructureModuleConfig()
						elif isinstance(self.structure_module				,	snake_case_):
											__lowerCAmelCase	   =StructureModuleConfig(**self.structure_module)

						if self.max_recycles <= 0:
											raise ValueError(F"""`max_recycles` should be positive, got {self.max_recycles}.""")
						if self.sequence_state_dim % self.sequence_state_dim != 0:
											raise ValueError(
											    """`sequence_state_dim` should be a round multiple of `sequence_state_dim`, got"""
											    F""" {self.sequence_state_dim} and {self.sequence_state_dim}.""")
						if self.pairwise_state_dim % self.pairwise_state_dim != 0:
											raise ValueError(
											    """`pairwise_state_dim` should be a round multiple of `pairwise_state_dim`, got"""
											    F""" {self.pairwise_state_dim} and {self.pairwise_state_dim}.""")

						__lowerCAmelCase	   =self.sequence_state_dim // self.sequence_head_width
						__lowerCAmelCase	   =self.pairwise_state_dim // self.pairwise_head_width

						if self.sequence_state_dim != sequence_num_heads * self.sequence_head_width:
											raise ValueError(
											    """`sequence_state_dim` should be equal to `sequence_num_heads * sequence_head_width, got"""
											    F""" {self.sequence_state_dim} != {sequence_num_heads} * {self.sequence_head_width}.""")
						if self.pairwise_state_dim != pairwise_num_heads * self.pairwise_head_width:
											raise ValueError(
											    """`pairwise_state_dim` should be equal to `pairwise_num_heads * pairwise_head_width, got"""
											    F""" {self.pairwise_state_dim} != {pairwise_num_heads} * {self.pairwise_head_width}.""")
						if self.pairwise_state_dim % 2 != 0:
											raise ValueError(F"""`pairwise_state_dim` should be even, got {self.pairwise_state_dim}.""")

						if self.dropout >= 0.4:
											raise ValueError(F"""`dropout` should not be greater than 0.4, got {self.dropout}.""")



	def 		UpperCamelCase							(						self							:    Dict)->							Any:
						__lowerCAmelCase	   =asdict(self)
						__lowerCAmelCase	   =self.structure_module.to_dict()
						return output






@dataclass
class 						__a :
	SCREAMING_SNAKE_CASE       =       384
	SCREAMING_SNAKE_CASE       =       128
	SCREAMING_SNAKE_CASE       =       16
	SCREAMING_SNAKE_CASE       =       128
	SCREAMING_SNAKE_CASE       =       12
	SCREAMING_SNAKE_CASE       =       4
	SCREAMING_SNAKE_CASE       =       8
	SCREAMING_SNAKE_CASE       =       0.1
	SCREAMING_SNAKE_CASE       =       8
	SCREAMING_SNAKE_CASE       =       1
	SCREAMING_SNAKE_CASE       =       2
	SCREAMING_SNAKE_CASE       =       7
	SCREAMING_SNAKE_CASE       =       10
	SCREAMING_SNAKE_CASE       =       1E-8
	SCREAMING_SNAKE_CASE       =       1E5



	def 		UpperCamelCase							(						self							:    Any)->							Tuple:
						return asdict(self)






def 					__lowerCAmelCase		(  )  ->						List[Any]:
					return (
					    "<cls>",
					    "<pad>",
					    "<eos>",
					    "<unk>",
					    "L",
					    "A",
					    "G",
					    "V",
					    "S",
					    "E",
					    "R",
					    "T",
					    "I",
					    "D",
					    "P",
					    "K",
					    "Q",
					    "N",
					    "F",
					    "Y",
					    "M",
					    "H",
					    "W",
					    "C",
					    "X",
					    "B",
					    "U",
					    "Z",
					    "O",
					    ".",
					    "-",
					    "<null_1>",
					    "<mask>",
					)




