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 __snake_case       :




   def __init__(					self    :       List[Any] ,			_lowercase    :       str ,			_lowercase    :       List[str]=13 ,			_lowercase    :       Optional[Any]=7 ,			_lowercase    :       str=False ,			_lowercase    :       Union[str, Any]=True ,			_lowercase    :       List[Any]=False ,			_lowercase    :       Dict=False ,			_lowercase    :       Dict=19 ,			_lowercase    :       Dict=32 ,			_lowercase    :       Dict=5 ,			_lowercase    :       List[str]=4 ,			_lowercase    :       Any=37 ,			_lowercase    :       List[Any]="gelu" ,			_lowercase    :       Tuple=0.1 ,			_lowercase    :       str=0.1 ,			_lowercase    :       List[str]=5_12 ,			_lowercase    :       List[Any]=16 ,			_lowercase    :       List[Any]=2 ,			_lowercase    :       Dict=0.02 ,			_lowercase    :       int=3 ,			_lowercase    :       Optional[int]=4 ,			_lowercase    :       Optional[int]=None ,			):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__    							=   parent
     SCREAMING_SNAKE_CASE__    							=   batch_size
     SCREAMING_SNAKE_CASE__    							=   seq_length
     SCREAMING_SNAKE_CASE__    							=   is_training
     SCREAMING_SNAKE_CASE__    							=   use_input_mask
     SCREAMING_SNAKE_CASE__    							=   use_token_type_ids
     SCREAMING_SNAKE_CASE__    							=   use_labels
     SCREAMING_SNAKE_CASE__    							=   vocab_size
     SCREAMING_SNAKE_CASE__    							=   hidden_size
     SCREAMING_SNAKE_CASE__    							=   num_hidden_layers
     SCREAMING_SNAKE_CASE__    							=   num_attention_heads
     SCREAMING_SNAKE_CASE__    							=   intermediate_size
     SCREAMING_SNAKE_CASE__    							=   hidden_act
     SCREAMING_SNAKE_CASE__    							=   hidden_dropout_prob
     SCREAMING_SNAKE_CASE__    							=   attention_probs_dropout_prob
     SCREAMING_SNAKE_CASE__    							=   max_position_embeddings
     SCREAMING_SNAKE_CASE__    							=   type_vocab_size
     SCREAMING_SNAKE_CASE__    							=   type_sequence_label_size
     SCREAMING_SNAKE_CASE__    							=   initializer_range
     SCREAMING_SNAKE_CASE__    							=   num_labels
     SCREAMING_SNAKE_CASE__    							=   num_choices
     SCREAMING_SNAKE_CASE__    							=   scope




   def 			__a		(					self    :       int   ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__    							=   ids_tensor([self.batch_size, self.seq_length] ,			self.vocab_size   )

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

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

     SCREAMING_SNAKE_CASE__    							=   self.get_config()

     return config, input_ids, input_mask, sequence_labels, token_labels, choice_labels




   def 			__a		(					self    :       Union[str, Any]   ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__    							=   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=_lowercase ,			esmfold_config={"""trunk""": {"""num_blocks""": 2}, """fp16_esm""": False} ,			)
     return config




   def 			__a		(					self    :       Union[str, Any] ,			_lowercase    :       Any ,			_lowercase    :       Tuple ,			_lowercase    :       str ,			_lowercase    :       Any ,			_lowercase    :       Union[str, Any] ,			_lowercase    :       List[Any]   ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__    							=   EsmForProteinFolding(config=_lowercase   ).float()
     model.to(_lowercase   )
     model.eval()
     SCREAMING_SNAKE_CASE__    							=   model(_lowercase ,			attention_mask=_lowercase   )
     SCREAMING_SNAKE_CASE__    							=   model(_lowercase   )
     SCREAMING_SNAKE_CASE__    							=   model(_lowercase   )

     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 			__a		(					self    :       List[str]   ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__    							=   self.prepare_config_and_inputs()
     (
         SCREAMING_SNAKE_CASE__		
     )    							=   config_and_inputs
     SCREAMING_SNAKE_CASE__    							=   {"""input_ids""": input_ids, """attention_mask""": input_mask}
     return config, inputs_dict







@require_torch
class __snake_case       (		UpperCAmelCase__     ,	UpperCAmelCase__     ,	unittest.TestCase	):
   lowerCAmelCase_														=							False

   lowerCAmelCase_														=							(EsmForProteinFolding,) if is_torch_available() else ()
   lowerCAmelCase_														=							()
   lowerCAmelCase_														=							{} if is_torch_available() else {}
   lowerCAmelCase_														=							False




   def 			__a		(					self    :       List[Any]   ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__    							=   EsmFoldModelTester(self   )
     SCREAMING_SNAKE_CASE__    							=   ConfigTester(self ,			config_class=_lowercase ,			hidden_size=37   )




   def 			__a		(					self    :       Optional[Any]   ):



     """simple docstring"""






     self.config_tester.run_common_tests()




   def 			__a		(					self    :       str   ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__    							=   self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_model(*_lowercase   )




   @unittest.skip("""Does not support attention outputs"""   )
   def 			__a		(					self    :       Any   ):



     """simple docstring"""






     pass




   @unittest.skip
   def 			__a		(					self    :       Tuple   ):



     """simple docstring"""






     pass




   @unittest.skip("""Esm does not support embedding resizing"""   )
   def 			__a		(					self    :       Optional[Any]   ):



     """simple docstring"""






     pass




   @unittest.skip("""Esm does not support embedding resizing"""   )
   def 			__a		(					self    :       Optional[int]   ):



     """simple docstring"""






     pass




   @unittest.skip("""ESMFold does not support passing input embeds!"""   )
   def 			__a		(					self    :       Dict   ):



     """simple docstring"""






     pass




   @unittest.skip("""ESMFold does not support head pruning."""   )
   def 			__a		(					self    :       str   ):



     """simple docstring"""






     pass




   @unittest.skip("""ESMFold does not support head pruning."""   )
   def 			__a		(					self    :       List[Any]   ):



     """simple docstring"""






     pass




   @unittest.skip("""ESMFold does not support head pruning."""   )
   def 			__a		(					self    :       int   ):



     """simple docstring"""






     pass




   @unittest.skip("""ESMFold does not support head pruning."""   )
   def 			__a		(					self    :       List[str]   ):



     """simple docstring"""






     pass




   @unittest.skip("""ESMFold does not support head pruning."""   )
   def 			__a		(					self    :       Optional[Any]   ):



     """simple docstring"""






     pass




   @unittest.skip("""ESMFold does not output hidden states in the normal way."""   )
   def 			__a		(					self    :       Any   ):



     """simple docstring"""






     pass




   @unittest.skip("""ESMfold does not output hidden states in the normal way."""   )
   def 			__a		(					self    :       List[Any]   ):



     """simple docstring"""






     pass




   @unittest.skip("""ESMFold only has one output format."""   )
   def 			__a		(					self    :       Dict   ):



     """simple docstring"""






     pass




   @unittest.skip("""This test doesn't work for ESMFold and doesn't test core functionality"""   )
   def 			__a		(					self    :       Any   ):



     """simple docstring"""






     pass




   @unittest.skip("""ESMFold does not support input chunking."""   )
   def 			__a		(					self    :       Optional[int]   ):



     """simple docstring"""






     pass




   @unittest.skip("""ESMFold doesn't respect you and it certainly doesn't respect your initialization arguments."""   )
   def 			__a		(					self    :       List[Any]   ):



     """simple docstring"""






     pass




   @unittest.skip("""ESMFold doesn't support torchscript compilation."""   )
   def 			__a		(					self    :       str   ):



     """simple docstring"""






     pass




   @unittest.skip("""ESMFold doesn't support torchscript compilation."""   )
   def 			__a		(					self    :       Any   ):



     """simple docstring"""






     pass




   @unittest.skip("""ESMFold doesn't support torchscript compilation."""   )
   def 			__a		(					self    :       Optional[int]   ):



     """simple docstring"""






     pass




   @unittest.skip("""ESMFold doesn't support data parallel."""   )
   def 			__a		(					self    :       Any   ):



     """simple docstring"""






     pass




   @unittest.skip("""Will be fixed soon by reducing the size of the model used for common tests."""   )
   def 			__a		(					self    :       str   ):



     """simple docstring"""






     pass







@require_torch
class __snake_case       (		UpperCAmelCase__	):




   @slow
   def 			__a		(					self    :       List[Any]   ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__    							=   EsmForProteinFolding.from_pretrained("""facebook/esmfold_v1"""   ).float()
     model.eval()
     SCREAMING_SNAKE_CASE__    							=   torch.tensor([[0, 6, 4, 13, 5, 4, 16, 12, 11, 7, 2]]   )
     SCREAMING_SNAKE_CASE__    							=   model(_lowercase   )["""positions"""]
     SCREAMING_SNAKE_CASE__    							=   torch.tensor([2.58_28, 0.79_93, -10.93_34] ,			dtype=torch.floataa   )
     self.assertTrue(torch.allclose(position_outputs[0, 0, 0, 0] ,			_lowercase ,			atol=1E-4   )   )

from __future__ import annotations



def 			__SCREAMING_SNAKE_CASE						(      __UpperCamelCase					: list			)							->      float:







  """simple docstring"""





  if not nums:
    raise ValueError("""List is empty"""			)
  return sum(__UpperCamelCase			) / len(__UpperCamelCase			)


if __name__ == "__main__":
   import doctest

   doctest.testmod()
