



import gc
import unittest

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

from diffusers import TransformeraDModel, VQDiffusionPipeline, VQDiffusionScheduler, VQModel
from diffusers.pipelines.vq_diffusion.pipeline_vq_diffusion import LearnedClassifierFreeSamplingEmbeddings
from diffusers.utils import load_numpy, slow, torch_device
from diffusers.utils.testing_utils import require_torch_gpu


lowercase_	       =			False






class 						__a (     unittest.TestCase				):



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



	@property
	def 		UpperCamelCase							(						self							:    Any)->							Optional[int]:
						return 12



	@property
	def 		UpperCamelCase							(						self							:    str)->							Optional[int]:
						return 12



	@property
	def 		UpperCamelCase							(						self							:    List[str])->							Optional[Any]:
						return 32



	@property
	def 		UpperCamelCase							(						self							:    int)->							Optional[int]:
						torch.manual_seed(0)
						__lowerCAmelCase	   =VQModel(
						    block_out_channels=[32, 64]				,	in_channels=3				,	out_channels=3				,	down_block_types=["""DownEncoderBlock2D""", """DownEncoderBlock2D"""]				,	up_block_types=["""UpDecoderBlock2D""", """UpDecoderBlock2D"""]				,	latent_channels=3				,	num_vq_embeddings=self.num_embed				,	vq_embed_dim=3				,	)
						return model



	@property
	def 		UpperCamelCase							(						self							:    List[str])->							str:
						__lowerCAmelCase	   =CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip""")
						return tokenizer



	@property
	def 		UpperCamelCase							(						self							:    Tuple)->							Optional[int]:
						torch.manual_seed(0)
						__lowerCAmelCase	   =CLIPTextConfig(
						    bos_token_id=0				,	eos_token_id=2				,	hidden_size=self.text_embedder_hidden_size				,	intermediate_size=37				,	layer_norm_eps=1e-05				,	num_attention_heads=4				,	num_hidden_layers=5				,	pad_token_id=1				,	vocab_size=10_00				,	)
						return CLIPTextModel(snake_case_)



	@property
	def 		UpperCamelCase							(						self							:    str)->							List[str]:
						torch.manual_seed(0)

						__lowerCAmelCase	   =12
						__lowerCAmelCase	   =12

						__lowerCAmelCase	   ={
						    """attention_bias""": True,
						    """cross_attention_dim""": 32,
						    """attention_head_dim""": height * width,
						    """num_attention_heads""": 1,
						    """num_vector_embeds""": self.num_embed,
						    """num_embeds_ada_norm""": self.num_embeds_ada_norm,
						    """norm_num_groups""": 32,
						    """sample_size""": width,
						    """activation_fn""": """geglu-approximate""",
						}

						__lowerCAmelCase	   =TransformeraDModel(**snake_case_)
						return model



	def 		UpperCamelCase							(						self							:    str)->							Tuple:
						__lowerCAmelCase	   ="""cpu"""

						__lowerCAmelCase	   =self.dummy_vqvae
						__lowerCAmelCase	   =self.dummy_text_encoder
						__lowerCAmelCase	   =self.dummy_tokenizer
						__lowerCAmelCase	   =self.dummy_transformer
						__lowerCAmelCase	   =VQDiffusionScheduler(self.num_embed)
						__lowerCAmelCase	   =LearnedClassifierFreeSamplingEmbeddings(learnable=snake_case_)

						__lowerCAmelCase	   =VQDiffusionPipeline(
						    vqvae=snake_case_				,	text_encoder=snake_case_				,	tokenizer=snake_case_				,	transformer=snake_case_				,	scheduler=snake_case_				,	learned_classifier_free_sampling_embeddings=snake_case_				,	)
						__lowerCAmelCase	   =pipe.to(snake_case_)
						pipe.set_progress_bar_config(disable=snake_case_)

						__lowerCAmelCase	   ="""teddy bear playing in the pool"""

						__lowerCAmelCase	   =torch.Generator(device=snake_case_).manual_seed(0)
						__lowerCAmelCase	   =pipe([prompt]				,	generator=snake_case_				,	num_inference_steps=2				,	output_type="""np""")
						__lowerCAmelCase	   =output.images

						__lowerCAmelCase	   =torch.Generator(device=snake_case_).manual_seed(0)
						__lowerCAmelCase	   =pipe(
						    [prompt]				,	generator=snake_case_				,	output_type="""np"""				,	return_dict=snake_case_				,	num_inference_steps=2)[0]

						__lowerCAmelCase	   =image[0, -3:, -3:, -1]
						__lowerCAmelCase	   =image_from_tuple[0, -3:, -3:, -1]

						assert image.shape == (1, 24, 24, 3)

						__lowerCAmelCase	   =np.array([0.6_5_5_1, 0.6_1_6_8, 0.5_0_0_8, 0.5_6_7_6, 0.5_6_5_9, 0.4_2_9_5, 0.6_0_7_3, 0.5_5_9_9, 0.4_9_9_2])

						assert np.abs(image_slice.flatten() - expected_slice).max() < 1e-2
						assert np.abs(image_from_tuple_slice.flatten() - expected_slice).max() < 1e-2



	def 		UpperCamelCase							(						self							:    str)->							Optional[int]:
						__lowerCAmelCase	   ="""cpu"""

						__lowerCAmelCase	   =self.dummy_vqvae
						__lowerCAmelCase	   =self.dummy_text_encoder
						__lowerCAmelCase	   =self.dummy_tokenizer
						__lowerCAmelCase	   =self.dummy_transformer
						__lowerCAmelCase	   =VQDiffusionScheduler(self.num_embed)
						__lowerCAmelCase	   =LearnedClassifierFreeSamplingEmbeddings(
						    learnable=snake_case_				,	hidden_size=self.text_embedder_hidden_size				,	length=tokenizer.model_max_length)

						__lowerCAmelCase	   =VQDiffusionPipeline(
						    vqvae=snake_case_				,	text_encoder=snake_case_				,	tokenizer=snake_case_				,	transformer=snake_case_				,	scheduler=snake_case_				,	learned_classifier_free_sampling_embeddings=snake_case_				,	)
						__lowerCAmelCase	   =pipe.to(snake_case_)
						pipe.set_progress_bar_config(disable=snake_case_)

						__lowerCAmelCase	   ="""teddy bear playing in the pool"""

						__lowerCAmelCase	   =torch.Generator(device=snake_case_).manual_seed(0)
						__lowerCAmelCase	   =pipe([prompt]				,	generator=snake_case_				,	num_inference_steps=2				,	output_type="""np""")
						__lowerCAmelCase	   =output.images

						__lowerCAmelCase	   =torch.Generator(device=snake_case_).manual_seed(0)
						__lowerCAmelCase	   =pipe(
						    [prompt]				,	generator=snake_case_				,	output_type="""np"""				,	return_dict=snake_case_				,	num_inference_steps=2)[0]

						__lowerCAmelCase	   =image[0, -3:, -3:, -1]
						__lowerCAmelCase	   =image_from_tuple[0, -3:, -3:, -1]

						assert image.shape == (1, 24, 24, 3)

						__lowerCAmelCase	   =np.array([0.6_6_9_3, 0.6_0_7_5, 0.4_9_5_9, 0.5_7_0_1, 0.5_5_8_3, 0.4_3_3_3, 0.6_1_7_1, 0.5_6_8_4, 0.4_9_8_8])

						assert np.abs(image_slice.flatten() - expected_slice).max() < 2.0
						assert np.abs(image_from_tuple_slice.flatten() - expected_slice).max() < 1e-2






@slow
@require_torch_gpu
class 						__a (     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							:    Optional[int])->							Tuple:
						__lowerCAmelCase	   =load_numpy(
						    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
						    """/vq_diffusion/teddy_bear_pool_classifier_free_sampling.npy""")

						__lowerCAmelCase	   =VQDiffusionPipeline.from_pretrained("""microsoft/vq-diffusion-ithq""")
						__lowerCAmelCase	   =pipeline.to(snake_case_)
						pipeline.set_progress_bar_config(disable=snake_case_)

						# requires GPU generator for gumbel softmax
						# don't use GPU generator in tests though
						__lowerCAmelCase	   =torch.Generator(device=snake_case_).manual_seed(0)
						__lowerCAmelCase	   =pipeline(
						    """teddy bear playing in the pool"""				,	num_images_per_prompt=1				,	generator=snake_case_				,	output_type="""np"""				,	)

						__lowerCAmelCase	   =output.images[0]

						assert image.shape == (2_56, 2_56, 3)
						assert np.abs(expected_image - image).max() < 2.0









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>",
					)




