
"""simple docstring"""



from dataclasses import asdict, dataclass
from typing import Optional

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


UpperCamelCase__          =	logging.get_logger(__name__)

# TODO Update this
UpperCamelCase__          =	{
    '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			(					lowercase      ):
      UpperCamelCase							:   str           =     """esm"""



      def __init__(   self     ,	UpperCamelCase_=None     ,	UpperCamelCase_=None     ,	UpperCamelCase_=None     ,	UpperCamelCase_=768     ,	UpperCamelCase_=12     ,	UpperCamelCase_=12     ,	UpperCamelCase_=3_072     ,	UpperCamelCase_=0.1     ,	UpperCamelCase_=0.1     ,	UpperCamelCase_=1_026     ,	UpperCamelCase_=0.02     ,	UpperCamelCase_=1E-12     ,	UpperCamelCase_="absolute"     ,	UpperCamelCase_=True     ,	UpperCamelCase_=None     ,	UpperCamelCase_=False     ,	UpperCamelCase_=False     ,	UpperCamelCase_=None     ,	UpperCamelCase_=None     ,	**UpperCamelCase_     ,	):
          super().__init__(pad_token_id=UpperCamelCase_     ,	mask_token_id=UpperCamelCase_     ,	**UpperCamelCase_      )

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



      def  __snake_case							(   self      ):
          UpperCAmelCase__	:      Optional[int]     							=					super().to_dict()
          if isinstance(self.esmfold_config     ,	UpperCamelCase_      ):
              UpperCAmelCase__	:      Optional[int]     							=					self.esmfold_config.to_dict()
          return output





@dataclass
class 				a			:
      UpperCamelCase							:   str           =     None
      UpperCamelCase							:   bool           =     True
      UpperCamelCase							:   bool           =     False
      UpperCamelCase							:   bool           =     False
      UpperCamelCase							:   bool           =     False
      UpperCamelCase							:   float           =     0

      UpperCamelCase							:   bool           =     True
      UpperCamelCase							:   bool           =     False

      UpperCamelCase							:   int           =     1_2_8
      UpperCamelCase							:   "TrunkConfig"           =     None



      def  __snake_case							(   self      ):
          if self.trunk is None:
              UpperCAmelCase__	:      Dict     							=					TrunkConfig()
          elif isinstance(self.trunk     ,	UpperCamelCase_      ):
              UpperCAmelCase__	:      Any     							=					TrunkConfig(**self.trunk      )



      def  __snake_case							(   self      ):
          UpperCAmelCase__	:      Dict     							=					asdict(self      )
          UpperCAmelCase__	:      Union[str, Any]     							=					self.trunk.to_dict()
          return output





@dataclass
class 				a			:
      UpperCamelCase							:   int           =     4_8
      UpperCamelCase							:   int           =     1_0_2_4
      UpperCamelCase							:   int           =     1_2_8
      UpperCamelCase							:   int           =     3_2
      UpperCamelCase							:   int           =     3_2
      UpperCamelCase							:   int           =     3_2
      UpperCamelCase							:   float           =     0
      UpperCamelCase							:   float           =     0
      UpperCamelCase							:   bool           =     False
      UpperCamelCase							:   int           =     4
      UpperCamelCase							:   Optional[int]           =     1_2_8
      UpperCamelCase							:   "StructureModuleConfig"           =     None



      def  __snake_case							(   self      ):
          if self.structure_module is None:
              UpperCAmelCase__	:      Optional[Any]     							=					StructureModuleConfig()
          elif isinstance(self.structure_module     ,	UpperCamelCase_      ):
              UpperCAmelCase__	:      Optional[Any]     							=					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}.'''      )

          UpperCAmelCase__	:      Optional[int]     							=					self.sequence_state_dim // self.sequence_head_width
          UpperCAmelCase__	:      List[str]     							=					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  __snake_case							(   self      ):
          UpperCAmelCase__	:      str     							=					asdict(self      )
          UpperCAmelCase__	:      Union[str, Any]     							=					self.structure_module.to_dict()
          return output





@dataclass
class 				a			:
      UpperCamelCase							:   int           =     3_8_4
      UpperCamelCase							:   int           =     1_2_8
      UpperCamelCase							:   int           =     1_6
      UpperCamelCase							:   int           =     1_2_8
      UpperCamelCase							:   int           =     1_2
      UpperCamelCase							:   int           =     4
      UpperCamelCase							:   int           =     8
      UpperCamelCase							:   float           =     0.1
      UpperCamelCase							:   int           =     8
      UpperCamelCase							:   int           =     1
      UpperCamelCase							:   int           =     2
      UpperCamelCase							:   int           =     7
      UpperCamelCase							:   int           =     1_0
      UpperCamelCase							:   float           =     1E-8
      UpperCamelCase							:   float           =     1E5



      def  __snake_case							(   self      ):
          return asdict(self      )




def 					lowerCamelCase   (     ):
    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>",
    )


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

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







							def  UpperCamelCase_						(   self      :     Optional[int]		):
												_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=_A ,			projection_dim=_A ,			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=_A ,			num_layers=1 ,			)

												torch.manual_seed(0		)
												_UpperCamelCase			     =     DDPMScheduler(
												    variance_type='''fixed_small_log''' ,			prediction_type='''sample''' ,			num_train_timesteps=1000 ,			clip_sample=_A ,			clip_sample_range=5.0 ,			beta_schedule='''squaredcos_cap_v2''' ,			)

												# regular denoising components

												torch.manual_seed(0		)
												_UpperCamelCase			     =     StableUnCLIPImageNormalizer(embedding_dim=_A		)
												_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=_A ,			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=_A ,			layers_per_block=1 ,			upcast_attention=_A ,			use_linear_projection=_A ,			)

												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=_A ,			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  UpperCamelCase_						(   self      :     Dict ,			_A      :     Tuple ,			_A      :     Dict=0		):
												if str(_A		).startswith('''mps'''		):
																	_UpperCamelCase			     =     torch.manual_seed(_A		)
												else:
																	_UpperCamelCase			     =     torch.Generator(device=_A		).manual_seed(_A		)
												_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  UpperCamelCase_						(   self      :     Dict		):
												_UpperCamelCase			     =     torch_device == '''cpu'''

												self._test_attention_slicing_forward_pass(test_max_difference=_A		)







							def  UpperCamelCase_						(   self      :     List[Any]		):
												_UpperCamelCase			     =     torch_device in ['''cpu''', '''mps''']

												self._test_inference_batch_single_identical(test_max_difference=_A		)




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







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







							def  UpperCamelCase_						(   self      :     List[str]		):
												_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(_A		)
												pipe.set_progress_bar_config(disable=_A		)
												# 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=_A ,			output_type='''np'''		)

												_UpperCamelCase			     =     output.images[0]

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

												assert_mean_pixel_difference(_A ,			_A		)







							def  UpperCamelCase_						(   self      :     Optional[Any]		):
												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(_A		)
												pipe.set_progress_bar_config(disable=_A		)
												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
