






"""simple docstring"""







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     ,A     ,A=13     ,A=7     ,A=False     ,A=True     ,A=False     ,A=False     ,A=19     ,A=32     ,A=5     ,A=4     ,A=37     ,A="gelu"     ,A=0.1     ,A=0.1     ,A=512     ,A=16     ,A=2     ,A=0.02     ,A=3     ,A=4     ,A=None     ,):
          UpperCAmelCase          =	parent
          UpperCAmelCase          =	batch_size
          UpperCAmelCase          =	seq_length
          UpperCAmelCase          =	is_training
          UpperCAmelCase          =	use_input_mask
          UpperCAmelCase          =	use_token_type_ids
          UpperCAmelCase          =	use_labels
          UpperCAmelCase          =	vocab_size
          UpperCAmelCase          =	hidden_size
          UpperCAmelCase          =	num_hidden_layers
          UpperCAmelCase          =	num_attention_heads
          UpperCAmelCase          =	intermediate_size
          UpperCAmelCase          =	hidden_act
          UpperCAmelCase          =	hidden_dropout_prob
          UpperCAmelCase          =	attention_probs_dropout_prob
          UpperCAmelCase          =	max_position_embeddings
          UpperCAmelCase          =	type_vocab_size
          UpperCAmelCase          =	type_sequence_label_size
          UpperCAmelCase          =	initializer_range
          UpperCAmelCase          =	num_labels
          UpperCAmelCase          =	num_choices
          UpperCAmelCase          =	scope






    def     _UpperCamelCase							(			self ):
          UpperCAmelCase          =	ids_tensor([self.batch_size, self.seq_length]     ,self.vocab_size )

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

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

          UpperCAmelCase          =	self.get_config()

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






    def     _UpperCamelCase							(			self ):
          UpperCAmelCase          =	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=A     ,esmfold_config={"""trunk""": {"""num_blocks""": 2}, """fp16_esm""": False}     ,)
          return config






    def     _UpperCamelCase							(			self     ,A     ,A     ,A     ,A     ,A     ,A ):
          UpperCAmelCase          =	EsmForProteinFolding(config=A ).float()
          model.to(A )
          model.eval()
          UpperCAmelCase          =	model(A     ,attention_mask=A )
          UpperCAmelCase          =	model(A )
          UpperCAmelCase          =	model(A )

          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 ):
          UpperCAmelCase          =	self.prepare_config_and_inputs()
          (
              (
              UpperCAmelCase
          )      , (
              UpperCAmelCase
          )      , (
              UpperCAmelCase
          )      , (
              UpperCAmelCase
          )      , (
              UpperCAmelCase
          )      , (
              UpperCAmelCase
          )      , 
          )          =	config_and_inputs
          UpperCAmelCase          =	{"""input_ids""": input_ids, """attention_mask""": input_mask}
          return config, inputs_dict







@require_torch
class  lowerCamelCase__ (	snake_case   ,					snake_case   ,					unittest.TestCase			):
    SCREAMING_SNAKE_CASE		=      False

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






    def     _UpperCamelCase							(			self ):
          UpperCAmelCase          =	EsmFoldModelTester(self )
          UpperCAmelCase          =	ConfigTester(self     ,config_class=A     ,hidden_size=37 )






    def     _UpperCamelCase							(			self ):
          self.config_tester.run_common_tests()






    def     _UpperCamelCase							(			self ):
          UpperCAmelCase          =	self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*A )






    @unittest.skip("""Does not support attention outputs""" )
    def     _UpperCamelCase							(			self ):
          pass






    @unittest.skip
    def     _UpperCamelCase							(			self ):
          pass






    @unittest.skip("""Esm does not support embedding resizing""" )
    def     _UpperCamelCase							(			self ):
          pass






    @unittest.skip("""Esm does not support embedding resizing""" )
    def     _UpperCamelCase							(			self ):
          pass






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






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






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






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






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






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






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






    @unittest.skip("""ESMfold does not output hidden states in the normal way.""" )
    def     _UpperCamelCase							(			self ):
          pass






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






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






    @unittest.skip("""ESMFold does not support input chunking.""" )
    def     _UpperCamelCase							(			self ):
          pass






    @unittest.skip("""ESMFold doesn't respect you and it certainly doesn't respect your initialization arguments.""" )
    def     _UpperCamelCase							(			self ):
          pass






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






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






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






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






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







@require_torch
class  lowerCamelCase__ (	snake_case			):






    @slow
    def     _UpperCamelCase							(			self ):
          UpperCAmelCase          =	EsmForProteinFolding.from_pretrained("""facebook/esmfold_v1""" ).float()
          model.eval()
          UpperCAmelCase          =	torch.tensor([[0, 6, 4, 13, 5, 4, 16, 12, 11, 7, 2]] )
          UpperCAmelCase          =	model(A )["""positions"""]
          UpperCAmelCase          =	torch.tensor([2.5828, 0.7993, -10.9334]     ,dtype=torch.floataa )
          self.assertTrue(torch.allclose(position_outputs[0, 0, 0, 0]     ,A     ,atol=1e-4 ) )











"""simple docstring"""







from __future__ import annotations

def _a			(		_snake_case				,	_snake_case				,	_snake_case							):







      """simple docstring"""






      if (voltage, current, resistance).count(0							) != 1:
            raise ValueError("""One and only one argument must be 0"""							)
      if resistance < 0:
            raise ValueError("""Resistance cannot be negative"""							)
      if voltage == 0:
            return {"voltage": float(current * resistance							)}
      elif current == 0:
            return {"current": voltage / resistance}
      elif resistance == 0:
            return {"resistance": voltage / current}
      else:
            raise ValueError("""Exactly one argument must be 0"""							)


if __name__ == "__main__":
  import doctest

  doctest.testmod()



