





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






       """simple docstring"""





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

            '''simple docstring'''




            _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 snake_case__						(							self       :		Optional[Any]					)   ->					List[Any]:

            '''simple docstring'''




            _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 snake_case__						(							self       :		str					)   ->					Dict:

            '''simple docstring'''




            _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=lowerCAmelCase__	,			esmfold_config={'''trunk''': {'''num_blocks''': 2}, '''fp16_esm''': False}	,			)
            return config





       def snake_case__						(							self       :		Union[str, Any]	,			lowerCAmelCase__       :		List[Any]	,			lowerCAmelCase__       :		Any	,			lowerCAmelCase__       :		List[str]	,			lowerCAmelCase__       :		Optional[int]	,			lowerCAmelCase__       :		str	,			lowerCAmelCase__       :		Optional[int]					)   ->					Optional[Any]:

            '''simple docstring'''




            _UpperCamelCase       =	EsmForProteinFolding(config=lowerCAmelCase__					).float()
            model.to(lowerCAmelCase__					)
            model.eval()
            _UpperCamelCase       =	model(lowerCAmelCase__	,			attention_mask=lowerCAmelCase__					)
            _UpperCamelCase       =	model(lowerCAmelCase__					)
            _UpperCamelCase       =	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 snake_case__						(							self       :		Dict					)   ->					Tuple:

            '''simple docstring'''




            _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					(   __magic_name__						,						__magic_name__						,						unittest.TestCase			):






       """simple docstring"""
       _snake_case     :					Tuple						    =   False

       _snake_case     :					Optional[Any]						    =   (EsmForProteinFolding,) if is_torch_available() else ()
       _snake_case     :					List[str]						    =   ()
       _snake_case     :					List[str]						    =   {} if is_torch_available() else {}
       _snake_case     :					Dict						    =   False





       def snake_case__						(							self       :		List[str]					)   ->					Dict:

            '''simple docstring'''




            _UpperCamelCase       =	EsmFoldModelTester(self					)
            _UpperCamelCase       =	ConfigTester(self	,			config_class=lowerCAmelCase__	,			hidden_size=37					)





       def snake_case__						(							self       :		str					)   ->					int:

            '''simple docstring'''




            self.config_tester.run_common_tests()





       def snake_case__						(							self       :		List[Any]					)   ->					str:

            '''simple docstring'''




            _UpperCamelCase       =	self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_model(*lowerCAmelCase__					)





       @unittest.skip('''Does not support attention outputs'''					)
       def snake_case__						(							self       :		Dict					)   ->					str:

            '''simple docstring'''




            pass





       @unittest.skip
       def snake_case__						(							self       :		List[Any]					)   ->					str:

            '''simple docstring'''




            pass





       @unittest.skip('''Esm does not support embedding resizing'''					)
       def snake_case__						(							self       :		List[str]					)   ->					str:

            '''simple docstring'''




            pass





       @unittest.skip('''Esm does not support embedding resizing'''					)
       def snake_case__						(							self       :		Union[str, Any]					)   ->					Dict:

            '''simple docstring'''




            pass





       @unittest.skip('''ESMFold does not support passing input embeds!'''					)
       def snake_case__						(							self       :		Dict					)   ->					Optional[int]:

            '''simple docstring'''




            pass





       @unittest.skip('''ESMFold does not support head pruning.'''					)
       def snake_case__						(							self       :		Tuple					)   ->					Optional[Any]:

            '''simple docstring'''




            pass





       @unittest.skip('''ESMFold does not support head pruning.'''					)
       def snake_case__						(							self       :		Optional[int]					)   ->					Union[str, Any]:

            '''simple docstring'''




            pass





       @unittest.skip('''ESMFold does not support head pruning.'''					)
       def snake_case__						(							self       :		int					)   ->					Any:

            '''simple docstring'''




            pass





       @unittest.skip('''ESMFold does not support head pruning.'''					)
       def snake_case__						(							self       :		Optional[int]					)   ->					Any:

            '''simple docstring'''




            pass





       @unittest.skip('''ESMFold does not support head pruning.'''					)
       def snake_case__						(							self       :		Optional[Any]					)   ->					Tuple:

            '''simple docstring'''




            pass





       @unittest.skip('''ESMFold does not output hidden states in the normal way.'''					)
       def snake_case__						(							self       :		Optional[int]					)   ->					List[str]:

            '''simple docstring'''




            pass





       @unittest.skip('''ESMfold does not output hidden states in the normal way.'''					)
       def snake_case__						(							self       :		Tuple					)   ->					Union[str, Any]:

            '''simple docstring'''




            pass





       @unittest.skip('''ESMFold only has one output format.'''					)
       def snake_case__						(							self       :		List[str]					)   ->					List[str]:

            '''simple docstring'''




            pass





       @unittest.skip('''This test doesn\'t work for ESMFold and doesn\'t test core functionality'''					)
       def snake_case__						(							self       :		Optional[int]					)   ->					Dict:

            '''simple docstring'''




            pass





       @unittest.skip('''ESMFold does not support input chunking.'''					)
       def snake_case__						(							self       :		List[str]					)   ->					Dict:

            '''simple docstring'''




            pass





       @unittest.skip('''ESMFold doesn\'t respect you and it certainly doesn\'t respect your initialization arguments.'''					)
       def snake_case__						(							self       :		Dict					)   ->					int:

            '''simple docstring'''




            pass





       @unittest.skip('''ESMFold doesn\'t support torchscript compilation.'''					)
       def snake_case__						(							self       :		Union[str, Any]					)   ->					Dict:

            '''simple docstring'''




            pass





       @unittest.skip('''ESMFold doesn\'t support torchscript compilation.'''					)
       def snake_case__						(							self       :		Union[str, Any]					)   ->					Optional[Any]:

            '''simple docstring'''




            pass





       @unittest.skip('''ESMFold doesn\'t support torchscript compilation.'''					)
       def snake_case__						(							self       :		Optional[int]					)   ->					Union[str, Any]:

            '''simple docstring'''




            pass





       @unittest.skip('''ESMFold doesn\'t support data parallel.'''					)
       def snake_case__						(							self       :		Optional[Any]					)   ->					Optional[Any]:

            '''simple docstring'''




            pass







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

            '''simple docstring'''




            pass

@require_torch
class     __lowerCAmelCase					(   __magic_name__			):






       """simple docstring"""





       @slow
       def snake_case__						(							self       :		Dict					)   ->					int:

            '''simple docstring'''




            _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(lowerCAmelCase__					)['''positions''']
            _UpperCamelCase       =	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					)					)










'''simple docstring'''

from math import isclose, sqrt







def  a__    (    lowercase :					float, lowercase :					float, lowercase :					float				)		->		tuple[float, float, float]:





     """simple docstring"""

     _UpperCamelCase       =	point_y / 4 / point_x
     _UpperCamelCase       =	2 * normal_gradient / (1 + normal_gradient * normal_gradient)
     _UpperCamelCase       =	(1 - normal_gradient * normal_gradient) / (
         1 + normal_gradient * normal_gradient
     )
     _UpperCamelCase       =	(sa - ca * incoming_gradient) / (ca + sa * incoming_gradient)

     # to find the next point, solve the simultaeneous equations:
     # y^2 + 4x^2 = 100
     # y - b = m * (x - a)
     # ==> A x^2 + B x + C = 0
     _UpperCamelCase       =	outgoing_gradient**2 + 4
     _UpperCamelCase       =	2 * outgoing_gradient * (point_y - outgoing_gradient * point_x)
     _UpperCamelCase       =	(point_y - outgoing_gradient * point_x) ** 2 - 100

     _UpperCamelCase       =	(
         -linear_term - sqrt(linear_term**2 - 4 * quadratic_term * constant_term				)
     ) / (2 * quadratic_term)
     _UpperCamelCase       =	(
         -linear_term + sqrt(linear_term**2 - 4 * quadratic_term * constant_term				)
     ) / (2 * quadratic_term)

     # two solutions, one of which is our input point
     _UpperCamelCase       =	x_minus if isclose(lowercase, lowercase				) else x_plus
     _UpperCamelCase       =	point_y + outgoing_gradient * (next_x - point_x)

     return next_x, next_y, outgoing_gradient







def  a__    (    lowercase :					float = 1.4, lowercase :					float = -9.6				)		->		int:





     """simple docstring"""

     _UpperCamelCase       =	0
     _UpperCamelCase       =	first_x_coord
     _UpperCamelCase       =	first_y_coord
     _UpperCamelCase       =	(1_0.1 - point_y) / (0.0 - point_x)

     while not (-0.0_1 <= point_x <= 0.0_1 and point_y > 0):
          _UpperCamelCase   ,    _UpperCamelCase   ,    _UpperCamelCase       =	next_point(lowercase, lowercase, lowercase				)
          num_reflections += 1

     return num_reflections


if __name__ == "__main__":
   print(F"""{solution() = }""")



