import unittest

from transformers import EsmConfig, is_torch_available
from transformers.testing_utils import TestCasePlus, require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
      import torch

      from transformers.models.esm.modeling_esmfold import EsmForProteinFolding






class 		_lowerCamelCase		:
    def __init__(  self , lowerCAmelCase , lowerCAmelCase=13 , lowerCAmelCase=7 , lowerCAmelCase=False , lowerCAmelCase=True , lowerCAmelCase=False , lowerCAmelCase=False , lowerCAmelCase=19 , lowerCAmelCase=32 , lowerCAmelCase=5 , lowerCAmelCase=4 , lowerCAmelCase=37 , lowerCAmelCase="gelu" , lowerCAmelCase=0.1 , lowerCAmelCase=0.1 , lowerCAmelCase=512 , lowerCAmelCase=16 , lowerCAmelCase=2 , lowerCAmelCase=0.02 , lowerCAmelCase=3 , lowerCAmelCase=4 , lowerCAmelCase=None , )       ->					str:
     SCREAMING_SNAKE_CASE__:   str=      parent
     SCREAMING_SNAKE_CASE__:   Tuple=      batch_size
     SCREAMING_SNAKE_CASE__:   Optional[int]=      seq_length
     SCREAMING_SNAKE_CASE__:   Any=      is_training
     SCREAMING_SNAKE_CASE__:   Any=      use_input_mask
     SCREAMING_SNAKE_CASE__:   Any=      use_token_type_ids
     SCREAMING_SNAKE_CASE__:   Dict=      use_labels
     SCREAMING_SNAKE_CASE__:   List[Any]=      vocab_size
     SCREAMING_SNAKE_CASE__:   int=      hidden_size
     SCREAMING_SNAKE_CASE__:   int=      num_hidden_layers
     SCREAMING_SNAKE_CASE__:   Optional[int]=      num_attention_heads
     SCREAMING_SNAKE_CASE__:   str=      intermediate_size
     SCREAMING_SNAKE_CASE__:   int=      hidden_act
     SCREAMING_SNAKE_CASE__:   Tuple=      hidden_dropout_prob
     SCREAMING_SNAKE_CASE__:   List[str]=      attention_probs_dropout_prob
     SCREAMING_SNAKE_CASE__:   Optional[int]=      max_position_embeddings
     SCREAMING_SNAKE_CASE__:   Tuple=      type_vocab_size
     SCREAMING_SNAKE_CASE__:   Optional[Any]=      type_sequence_label_size
     SCREAMING_SNAKE_CASE__:   str=      initializer_range
     SCREAMING_SNAKE_CASE__:   Tuple=      num_labels
     SCREAMING_SNAKE_CASE__:   Tuple=      num_choices
     SCREAMING_SNAKE_CASE__:   List[Any]=      scope
    def 						UpperCamelCase_				(  self   )       ->					Tuple:
     SCREAMING_SNAKE_CASE__:   Tuple=      ids_tensor([self.batch_size, self.seq_length] , self.vocab_size   )

     SCREAMING_SNAKE_CASE__:   List[Any]=      None
     if self.use_input_mask:
      SCREAMING_SNAKE_CASE__:   str=      random_attention_mask([self.batch_size, self.seq_length]   )

     SCREAMING_SNAKE_CASE__:   str=      None
     SCREAMING_SNAKE_CASE__:   List[str]=      None
     SCREAMING_SNAKE_CASE__:   str=      None
     if self.use_labels:
      SCREAMING_SNAKE_CASE__:   Any=      ids_tensor([self.batch_size] , self.type_sequence_label_size   )
      SCREAMING_SNAKE_CASE__:   Dict=      ids_tensor([self.batch_size, self.seq_length] , self.num_labels   )
      SCREAMING_SNAKE_CASE__:   Any=      ids_tensor([self.batch_size] , self.num_choices   )

     SCREAMING_SNAKE_CASE__:   int=      self.get_config()

     return config, input_ids, input_mask, sequence_labels, token_labels, choice_labels
    def 						UpperCamelCase_				(  self   )       ->					str:
     SCREAMING_SNAKE_CASE__:   Optional[Any]=      EsmConfig(
         vocab_size=33 , hidden_size=self.hidden_size , pad_token_id=1 , num_hidden_layers=self.num_hidden_layers , num_attention_heads=self.num_attention_heads , intermediate_size=self.intermediate_size , hidden_act=self.hidden_act , hidden_dropout_prob=self.hidden_dropout_prob , attention_probs_dropout_prob=self.attention_probs_dropout_prob , max_position_embeddings=self.max_position_embeddings , type_vocab_size=self.type_vocab_size , initializer_range=self.initializer_range , is_folding_model=lowerCAmelCase , esmfold_config={'''trunk''': {'''num_blocks''': 2}, '''fp16_esm''': False} , )
     return config
    def 						UpperCamelCase_				(  self , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase   )       ->					Optional[Any]:
     SCREAMING_SNAKE_CASE__:   List[str]=      EsmForProteinFolding(config=lowerCAmelCase   ).float()
     model.to(lowerCAmelCase   )
     model.eval()
     SCREAMING_SNAKE_CASE__:   List[Any]=      model(lowerCAmelCase , attention_mask=lowerCAmelCase   )
     SCREAMING_SNAKE_CASE__:   int=      model(lowerCAmelCase   )
     SCREAMING_SNAKE_CASE__:   Tuple=      model(lowerCAmelCase   )

     self.parent.assertEqual(result.positions.shape , (8, self.batch_size, self.seq_length, 14, 3)   )
     self.parent.assertEqual(result.angles.shape , (8, self.batch_size, self.seq_length, 7, 2)   )



    def 						UpperCamelCase_				(  self   )       ->					Tuple:
     SCREAMING_SNAKE_CASE__:   Union[str, Any]=      self.prepare_config_and_inputs()
     (
         (
         SCREAMING_SNAKE_CASE__
     ),	(
         SCREAMING_SNAKE_CASE__
     ),	(
         SCREAMING_SNAKE_CASE__
     ),	(
         SCREAMING_SNAKE_CASE__
     ),	(
         SCREAMING_SNAKE_CASE__
     ),	(
         SCREAMING_SNAKE_CASE__
     ),	
     ):   Any=      config_and_inputs
     SCREAMING_SNAKE_CASE__:   int=      {'''input_ids''': input_ids, '''attention_mask''': input_mask}
     return config, inputs_dict






@require_torch
class 		_lowerCamelCase		(   UpperCamelCase_    ,     UpperCamelCase_    ,     unittest.TestCase    ):
    __a  =      False

    __a  =      (EsmForProteinFolding,) if is_torch_available() else ()
    __a  =      ()
    __a  =      {} if is_torch_available() else {}
    __a  =      False
    def 						UpperCamelCase_				(  self   )       ->					Optional[int]:
     SCREAMING_SNAKE_CASE__:   Union[str, Any]=      EsmFoldModelTester(self   )
     SCREAMING_SNAKE_CASE__:   Any=      ConfigTester(self , config_class=lowerCAmelCase , hidden_size=37   )
    def 						UpperCamelCase_				(  self   )       ->					List[Any]:
     self.config_tester.run_common_tests()
    def 						UpperCamelCase_				(  self   )       ->					Optional[Any]:
     SCREAMING_SNAKE_CASE__:   int=      self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_model(*lowerCAmelCase   )
    @unittest.skip('''Does not support attention outputs'''   )
    def 						UpperCamelCase_				(  self   )       ->					List[Any]:
     pass
    @unittest.skip
    def 						UpperCamelCase_				(  self   )       ->					Dict:
     pass
    @unittest.skip('''Esm does not support embedding resizing'''   )
    def 						UpperCamelCase_				(  self   )       ->					Optional[int]:
     pass
    @unittest.skip('''Esm does not support embedding resizing'''   )
    def 						UpperCamelCase_				(  self   )       ->					str:
     pass
    @unittest.skip('''ESMFold does not support passing input embeds!'''   )
    def 						UpperCamelCase_				(  self   )       ->					Any:
     pass
    @unittest.skip('''ESMFold does not support head pruning.'''   )
    def 						UpperCamelCase_				(  self   )       ->					Optional[Any]:
     pass
    @unittest.skip('''ESMFold does not support head pruning.'''   )
    def 						UpperCamelCase_				(  self   )       ->					Tuple:
     pass
    @unittest.skip('''ESMFold does not support head pruning.'''   )
    def 						UpperCamelCase_				(  self   )       ->					Union[str, Any]:
     pass
    @unittest.skip('''ESMFold does not support head pruning.'''   )
    def 						UpperCamelCase_				(  self   )       ->					int:
     pass
    @unittest.skip('''ESMFold does not support head pruning.'''   )
    def 						UpperCamelCase_				(  self   )       ->					Dict:
     pass
    @unittest.skip('''ESMFold does not output hidden states in the normal way.'''   )
    def 						UpperCamelCase_				(  self   )       ->					List[Any]:
     pass
    @unittest.skip('''ESMfold does not output hidden states in the normal way.'''   )
    def 						UpperCamelCase_				(  self   )       ->					List[str]:
     pass
    @unittest.skip('''ESMFold only has one output format.'''   )
    def 						UpperCamelCase_				(  self   )       ->					Tuple:
     pass
    @unittest.skip('''This test doesn\'t work for ESMFold and doesn\'t test core functionality'''   )
    def 						UpperCamelCase_				(  self   )       ->					int:
     pass
    @unittest.skip('''ESMFold does not support input chunking.'''   )
    def 						UpperCamelCase_				(  self   )       ->					List[str]:
     pass
    @unittest.skip('''ESMFold doesn\'t respect you and it certainly doesn\'t respect your initialization arguments.'''   )
    def 						UpperCamelCase_				(  self   )       ->					Any:
     pass
    @unittest.skip('''ESMFold doesn\'t support torchscript compilation.'''   )
    def 						UpperCamelCase_				(  self   )       ->					Any:
     pass
    @unittest.skip('''ESMFold doesn\'t support torchscript compilation.'''   )
    def 						UpperCamelCase_				(  self   )       ->					int:
     pass
    @unittest.skip('''ESMFold doesn\'t support torchscript compilation.'''   )
    def 						UpperCamelCase_				(  self   )       ->					List[Any]:
     pass
    @unittest.skip('''ESMFold doesn\'t support data parallel.'''   )
    def 						UpperCamelCase_				(  self   )       ->					Tuple:
     pass



    @unittest.skip('''Will be fixed soon by reducing the size of the model used for common tests.'''   )
    def 						UpperCamelCase_				(  self   )       ->					Tuple:
     pass






@require_torch
class 		_lowerCamelCase		(   UpperCamelCase_    ):
    @slow
    def 						UpperCamelCase_				(  self   )       ->					List[Any]:
     SCREAMING_SNAKE_CASE__:   Optional[Any]=      EsmForProteinFolding.from_pretrained('''facebook/esmfold_v1'''   ).float()
     model.eval()
     SCREAMING_SNAKE_CASE__:   Dict=      torch.tensor([[0, 6, 4, 13, 5, 4, 16, 12, 11, 7, 2]]   )
     SCREAMING_SNAKE_CASE__:   Any=      model(lowerCAmelCase   )['''positions''']
     SCREAMING_SNAKE_CASE__:   Optional[Any]=      torch.tensor([2.5828, 0.7993, -10.9334] , dtype=torch.floataa   )
     self.assertTrue(torch.allclose(position_outputs[0, 0, 0, 0] , lowerCAmelCase , atol=1e-4   )   )


import gc
import unittest

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

from diffusers import AltDiffusionPipeline, AutoencoderKL, DDIMScheduler, PNDMScheduler, UNetaDConditionModel
from diffusers.pipelines.alt_diffusion.modeling_roberta_series import (
    RobertaSeriesConfig,
    RobertaSeriesModelWithTransformation,
)
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

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


enable_full_determinism()






class 		_lowerCamelCase		(   UpperCamelCase_    ,     UpperCamelCase_    ,     UpperCamelCase_    ,     unittest.TestCase    ):
    __a  =      AltDiffusionPipeline
    __a  =      TEXT_TO_IMAGE_PARAMS
    __a  =      TEXT_TO_IMAGE_BATCH_PARAMS
    __a  =      TEXT_TO_IMAGE_IMAGE_PARAMS
    __a  =      TEXT_TO_IMAGE_IMAGE_PARAMS
    def 						UpperCamelCase_				(  self   )       ->					Optional[Any]:
     torch.manual_seed(0   )
     SCREAMING_SNAKE_CASE__:   List[Any]=      UNetaDConditionModel(
         block_out_channels=(32, 64) , layers_per_block=2 , sample_size=32 , in_channels=4 , out_channels=4 , down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''') , up_block_types=('''CrossAttnUpBlock2D''', '''UpBlock2D''') , cross_attention_dim=32 , )
     SCREAMING_SNAKE_CASE__:   Tuple=      DDIMScheduler(
         beta_start=0.00085 , beta_end=0.012 , beta_schedule='''scaled_linear''' , clip_sample=lowerCAmelCase , set_alpha_to_one=lowerCAmelCase , )
     torch.manual_seed(0   )
     SCREAMING_SNAKE_CASE__:   Optional[Any]=      AutoencoderKL(
         block_out_channels=[32, 64] , in_channels=3 , out_channels=3 , down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D'''] , up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D'''] , latent_channels=4 , )

     # TODO: address the non-deterministic text encoder (fails for save-load tests)
     # torch.manual_seed(0)
     # text_encoder_config = RobertaSeriesConfig(
     #     hidden_size=32,
     #     project_dim=32,
     #     intermediate_size=37,
     #     layer_norm_eps=1e-05,
     #     num_attention_heads=4,
     #     num_hidden_layers=5,
     #     vocab_size=5002,
     # )
     # text_encoder = RobertaSeriesModelWithTransformation(text_encoder_config)

     torch.manual_seed(0   )
     SCREAMING_SNAKE_CASE__:   Tuple=      CLIPTextConfig(
         bos_token_id=0 , eos_token_id=2 , hidden_size=32 , 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=5002 , )
     SCREAMING_SNAKE_CASE__:   List[Any]=      CLIPTextModel(lowerCAmelCase   )

     SCREAMING_SNAKE_CASE__:   List[Any]=      XLMRobertaTokenizer.from_pretrained('''hf-internal-testing/tiny-xlm-roberta'''   )
     SCREAMING_SNAKE_CASE__:   List[Any]=      77

     SCREAMING_SNAKE_CASE__:   Union[str, Any]=      {
         '''unet''': unet,
         '''scheduler''': scheduler,
         '''vae''': vae,
         '''text_encoder''': text_encoder,
         '''tokenizer''': tokenizer,
         '''safety_checker''': None,
         '''feature_extractor''': None,
     }
     return components
    def 						UpperCamelCase_				(  self , lowerCAmelCase , lowerCAmelCase=0   )       ->					List[Any]:
     if str(lowerCAmelCase   ).startswith('''mps'''   ):
      SCREAMING_SNAKE_CASE__:   Any=      torch.manual_seed(lowerCAmelCase   )
     else:
      SCREAMING_SNAKE_CASE__:   Union[str, Any]=      torch.Generator(device=lowerCAmelCase   ).manual_seed(lowerCAmelCase   )
     SCREAMING_SNAKE_CASE__:   Any=      {
         '''prompt''': '''A painting of a squirrel eating a burger''',
         '''generator''': generator,
         '''num_inference_steps''': 2,
         '''guidance_scale''': 6.0,
         '''output_type''': '''numpy''',
     }
     return inputs
    def 						UpperCamelCase_				(  self   )       ->					List[str]:
     super().test_attention_slicing_forward_pass(expected_max_diff=3e-3   )
    def 						UpperCamelCase_				(  self   )       ->					Tuple:
     super().test_inference_batch_single_identical(expected_max_diff=3e-3   )
    def 						UpperCamelCase_				(  self   )       ->					Optional[Any]:
     SCREAMING_SNAKE_CASE__:   Optional[int]=      '''cpu'''  # ensure determinism for the device-dependent torch.Generator

     SCREAMING_SNAKE_CASE__:   Tuple=      self.get_dummy_components()
     torch.manual_seed(0   )
     SCREAMING_SNAKE_CASE__:   List[Any]=      RobertaSeriesConfig(
         hidden_size=32 , project_dim=32 , intermediate_size=37 , layer_norm_eps=1e-05 , num_attention_heads=4 , num_hidden_layers=5 , vocab_size=5002 , )
     # TODO: remove after fixing the non-deterministic text encoder
     SCREAMING_SNAKE_CASE__:   List[str]=      RobertaSeriesModelWithTransformation(lowerCAmelCase   )
     SCREAMING_SNAKE_CASE__:   List[str]=      text_encoder

     SCREAMING_SNAKE_CASE__:   List[Any]=      AltDiffusionPipeline(**lowerCAmelCase   )
     SCREAMING_SNAKE_CASE__:   Optional[Any]=      alt_pipe.to(lowerCAmelCase   )
     alt_pipe.set_progress_bar_config(disable=lowerCAmelCase   )

     SCREAMING_SNAKE_CASE__:   str=      self.get_dummy_inputs(lowerCAmelCase   )
     SCREAMING_SNAKE_CASE__:   Dict=      '''A photo of an astronaut'''
     SCREAMING_SNAKE_CASE__:   Any=      alt_pipe(**lowerCAmelCase   )
     SCREAMING_SNAKE_CASE__:   Optional[int]=      output.images
     SCREAMING_SNAKE_CASE__:   Tuple=      image[0, -3:, -3:, -1]

     assert image.shape == (1, 64, 64, 3)
     SCREAMING_SNAKE_CASE__:   Any=      np.array(
         [0.5748162, 0.60447145, 0.48821217, 0.50100636, 0.5431185, 0.45763683, 0.49657696, 0.48132733, 0.47573093]   )

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



    def 						UpperCamelCase_				(  self   )       ->					Optional[int]:
     SCREAMING_SNAKE_CASE__:   List[str]=      '''cpu'''  # ensure determinism for the device-dependent torch.Generator

     SCREAMING_SNAKE_CASE__:   Any=      self.get_dummy_components()
     SCREAMING_SNAKE_CASE__:   List[str]=      PNDMScheduler(skip_prk_steps=lowerCAmelCase   )
     torch.manual_seed(0   )
     SCREAMING_SNAKE_CASE__:   Tuple=      RobertaSeriesConfig(
         hidden_size=32 , project_dim=32 , intermediate_size=37 , layer_norm_eps=1e-05 , num_attention_heads=4 , num_hidden_layers=5 , vocab_size=5002 , )
     # TODO: remove after fixing the non-deterministic text encoder
     SCREAMING_SNAKE_CASE__:   str=      RobertaSeriesModelWithTransformation(lowerCAmelCase   )
     SCREAMING_SNAKE_CASE__:   List[str]=      text_encoder
     SCREAMING_SNAKE_CASE__:   Any=      AltDiffusionPipeline(**lowerCAmelCase   )
     SCREAMING_SNAKE_CASE__:   List[str]=      alt_pipe.to(lowerCAmelCase   )
     alt_pipe.set_progress_bar_config(disable=lowerCAmelCase   )

     SCREAMING_SNAKE_CASE__:   List[Any]=      self.get_dummy_inputs(lowerCAmelCase   )
     SCREAMING_SNAKE_CASE__:   Optional[int]=      alt_pipe(**lowerCAmelCase   )
     SCREAMING_SNAKE_CASE__:   Optional[Any]=      output.images
     SCREAMING_SNAKE_CASE__:   Tuple=      image[0, -3:, -3:, -1]

     assert image.shape == (1, 64, 64, 3)
     SCREAMING_SNAKE_CASE__:   List[Any]=      np.array(
         [0.51605093, 0.5707241, 0.47365507, 0.50578886, 0.5633877, 0.4642503, 0.5182081, 0.48763484, 0.49084237]   )

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






@slow
@require_torch_gpu
class 		_lowerCamelCase		(   unittest.TestCase    ):
    def 						UpperCamelCase_				(  self   )       ->					Union[str, Any]:
     # clean up the VRAM after each test
     super().tearDown()
     gc.collect()
     torch.cuda.empty_cache()
    def 						UpperCamelCase_				(  self   )       ->					Optional[int]:
     # make sure here that pndm scheduler skips prk
     SCREAMING_SNAKE_CASE__:   Any=      AltDiffusionPipeline.from_pretrained('''BAAI/AltDiffusion''' , safety_checker=lowerCAmelCase   )
     SCREAMING_SNAKE_CASE__:   Union[str, Any]=      alt_pipe.to(lowerCAmelCase   )
     alt_pipe.set_progress_bar_config(disable=lowerCAmelCase   )

     SCREAMING_SNAKE_CASE__:   Dict=      '''A painting of a squirrel eating a burger'''
     SCREAMING_SNAKE_CASE__:   Union[str, Any]=      torch.manual_seed(0   )
     SCREAMING_SNAKE_CASE__:   Tuple=      alt_pipe([prompt] , generator=lowerCAmelCase , guidance_scale=6.0 , num_inference_steps=20 , output_type='''np'''   )

     SCREAMING_SNAKE_CASE__:   List[Any]=      output.images

     SCREAMING_SNAKE_CASE__:   Dict=      image[0, -3:, -3:, -1]

     assert image.shape == (1, 512, 512, 3)
     SCREAMING_SNAKE_CASE__:   Optional[int]=      np.array([0.1010, 0.0800, 0.0794, 0.0885, 0.0843, 0.0762, 0.0769, 0.0729, 0.0586]   )

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



    def 						UpperCamelCase_				(  self   )       ->					Union[str, Any]:
     SCREAMING_SNAKE_CASE__:   List[Any]=      DDIMScheduler.from_pretrained('''BAAI/AltDiffusion''' , subfolder='''scheduler'''   )

     SCREAMING_SNAKE_CASE__:   List[str]=      AltDiffusionPipeline.from_pretrained('''BAAI/AltDiffusion''' , scheduler=lowerCAmelCase , safety_checker=lowerCAmelCase   )
     SCREAMING_SNAKE_CASE__:   Optional[int]=      alt_pipe.to(lowerCAmelCase   )
     alt_pipe.set_progress_bar_config(disable=lowerCAmelCase   )

     SCREAMING_SNAKE_CASE__:   Optional[Any]=      '''A painting of a squirrel eating a burger'''
     SCREAMING_SNAKE_CASE__:   Any=      torch.manual_seed(0   )

     SCREAMING_SNAKE_CASE__:   str=      alt_pipe([prompt] , generator=lowerCAmelCase , num_inference_steps=2 , output_type='''numpy'''   )
     SCREAMING_SNAKE_CASE__:   List[str]=      output.images

     SCREAMING_SNAKE_CASE__:   Dict=      image[0, -3:, -3:, -1]

     assert image.shape == (1, 512, 512, 3)
     SCREAMING_SNAKE_CASE__:   Optional[Any]=      np.array([0.4019, 0.4052, 0.3810, 0.4119, 0.3916, 0.3982, 0.4651, 0.4195, 0.5323]   )

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

