



"""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				,     _lowercase				,     _lowercase=1_3				,     _lowercase=7				,     _lowercase=False				,     _lowercase=True				,     _lowercase=False				,     _lowercase=False				,     _lowercase=1_9				,     _lowercase=3_2				,     _lowercase=5				,     _lowercase=4				,     _lowercase=3_7				,     _lowercase="gelu"				,     _lowercase=0.1				,     _lowercase=0.1				,     _lowercase=5_1_2				,     _lowercase=1_6				,     _lowercase=2				,     _lowercase=0.02				,     _lowercase=3				,     _lowercase=4				,     _lowercase=None				,     )			->    Dict:







								'''simple docstring'''

								snake_case_ :			Any            =      parent
								snake_case_ :			str            =      batch_size
								snake_case_ :			Dict            =      seq_length
								snake_case_ :			List[str]            =      is_training
								snake_case_ :			Tuple            =      use_input_mask
								snake_case_ :			str            =      use_token_type_ids
								snake_case_ :			Any            =      use_labels
								snake_case_ :			Any            =      vocab_size
								snake_case_ :			Union[str, Any]            =      hidden_size
								snake_case_ :			Any            =      num_hidden_layers
								snake_case_ :			Dict            =      num_attention_heads
								snake_case_ :			Dict            =      intermediate_size
								snake_case_ :			List[str]            =      hidden_act
								snake_case_ :			Any            =      hidden_dropout_prob
								snake_case_ :			Optional[int]            =      attention_probs_dropout_prob
								snake_case_ :			List[Any]            =      max_position_embeddings
								snake_case_ :			Optional[Any]            =      type_vocab_size
								snake_case_ :			List[str]            =      type_sequence_label_size
								snake_case_ :			str            =      initializer_range
								snake_case_ :			List[str]            =      num_labels
								snake_case_ :			Optional[Any]            =      num_choices
								snake_case_ :			str            =      scope





		def  UpperCAmelCase__				(       self )			->    Optional[Any]:







								'''simple docstring'''

								snake_case_ :			List[Any]            =      ids_tensor([self.batch_size, self.seq_length]				,     self.vocab_size )

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

								snake_case_ :			List[Any]            =      None
								snake_case_ :			Optional[Any]            =      None
								snake_case_ :			Optional[int]            =      None
								if self.use_labels:
														snake_case_ :			List[str]            =      ids_tensor([self.batch_size]				,     self.type_sequence_label_size )
														snake_case_ :			Union[str, Any]            =      ids_tensor([self.batch_size, self.seq_length]				,     self.num_labels )
														snake_case_ :			str            =      ids_tensor([self.batch_size]				,     self.num_choices )

								snake_case_ :			str            =      self.get_config()

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





		def  UpperCAmelCase__				(       self )			->    Any:







								'''simple docstring'''

								snake_case_ :			Dict            =      EsmConfig(
								    vocab_size=3_3				,     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  UpperCAmelCase__				(       self				,     _lowercase				,     _lowercase				,     _lowercase				,     _lowercase				,     _lowercase				,     _lowercase )			->    Union[str, Any]:







								'''simple docstring'''

								snake_case_ :			Optional[int]            =      EsmForProteinFolding(config=_lowercase ).float()
								model.to(_lowercase )
								model.eval()
								snake_case_ :			Tuple            =      model(_lowercase				,     attention_mask=_lowercase )
								snake_case_ :			int            =      model(_lowercase )
								snake_case_ :			Any            =      model(_lowercase )

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





		def  UpperCAmelCase__				(       self )			->    Tuple:







								'''simple docstring'''

								snake_case_ :			List[Any]            =      self.prepare_config_and_inputs()
								(
								    (
								    snake_case_
								)      ,		(
								    snake_case_
								)      ,		(
								    snake_case_
								)      ,		(
								    snake_case_
								)      ,		(
								    snake_case_
								)      ,		(
								    snake_case_
								)      ,		
								) :			Dict            =      config_and_inputs
								snake_case_ :			str            =      {"""input_ids""": input_ids, """attention_mask""": input_mask}
								return config, inputs_dict




@require_torch
class  _lowerCAmelCase     (					SCREAMING_SNAKE_CASE__	,					SCREAMING_SNAKE_CASE__	,					unittest.TestCase		):





		"""simple docstring"""






		_lowerCamelCase      	=							False

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





		def  UpperCAmelCase__				(       self )			->    Any:







								'''simple docstring'''

								snake_case_ :			str            =      EsmFoldModelTester(self )
								snake_case_ :			Union[str, Any]            =      ConfigTester(self				,     config_class=_lowercase				,     hidden_size=3_7 )





		def  UpperCAmelCase__				(       self )			->    int:







								'''simple docstring'''

								self.config_tester.run_common_tests()





		def  UpperCAmelCase__				(       self )			->    Optional[Any]:







								'''simple docstring'''

								snake_case_ :			str            =      self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*_lowercase )





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







								'''simple docstring'''

								pass





		@unittest.skip
		def  UpperCAmelCase__				(       self )			->    Dict:







								'''simple docstring'''

								pass





		@unittest.skip("""Esm does not support embedding resizing""" )
		def  UpperCAmelCase__				(       self )			->    Dict:







								'''simple docstring'''

								pass





		@unittest.skip("""Esm does not support embedding resizing""" )
		def  UpperCAmelCase__				(       self )			->    str:







								'''simple docstring'''

								pass





		@unittest.skip("""ESMFold does not support passing input embeds!""" )
		def  UpperCAmelCase__				(       self )			->    List[Any]:







								'''simple docstring'''

								pass





		@unittest.skip("""ESMFold does not support head pruning.""" )
		def  UpperCAmelCase__				(       self )			->    Tuple:







								'''simple docstring'''

								pass





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







								'''simple docstring'''

								pass





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







								'''simple docstring'''

								pass





		@unittest.skip("""ESMFold does not support head pruning.""" )
		def  UpperCAmelCase__				(       self )			->    Any:







								'''simple docstring'''

								pass





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







								'''simple docstring'''

								pass





		@unittest.skip("""ESMFold does not output hidden states in the normal way.""" )
		def  UpperCAmelCase__				(       self )			->    int:







								'''simple docstring'''

								pass





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







								'''simple docstring'''

								pass





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







								'''simple docstring'''

								pass





		@unittest.skip("""This test doesn't work for ESMFold and doesn't test core functionality""" )
		def  UpperCAmelCase__				(       self )			->    Tuple:







								'''simple docstring'''

								pass





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







								'''simple docstring'''

								pass





		@unittest.skip("""ESMFold doesn't respect you and it certainly doesn't respect your initialization arguments.""" )
		def  UpperCAmelCase__				(       self )			->    Union[str, Any]:







								'''simple docstring'''

								pass





		@unittest.skip("""ESMFold doesn't support torchscript compilation.""" )
		def  UpperCAmelCase__				(       self )			->    List[str]:







								'''simple docstring'''

								pass





		@unittest.skip("""ESMFold doesn't support torchscript compilation.""" )
		def  UpperCAmelCase__				(       self )			->    int:







								'''simple docstring'''

								pass





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







								'''simple docstring'''

								pass





		@unittest.skip("""ESMFold doesn't support data parallel.""" )
		def  UpperCAmelCase__				(       self )			->    Union[str, Any]:







								'''simple docstring'''

								pass





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







								'''simple docstring'''

								pass




@require_torch
class  _lowerCAmelCase     (					SCREAMING_SNAKE_CASE__		):





		"""simple docstring"""






		@slow
		def  UpperCAmelCase__				(       self )			->    Union[str, Any]:







								'''simple docstring'''

								snake_case_ :			List[str]            =      EsmForProteinFolding.from_pretrained("""facebook/esmfold_v1""" ).float()
								model.eval()
								snake_case_ :			Any            =      torch.tensor([[0, 6, 4, 1_3, 5, 4, 1_6, 1_2, 1_1, 7, 2]] )
								snake_case_ :			Tuple            =      model(_lowercase )["""positions"""]
								snake_case_ :			Any            =      torch.tensor([2.5828, 0.7993, -10.9334]				,     dtype=torch.floataa )
								self.assertTrue(torch.allclose(position_outputs[0, 0, 0, 0]				,     _lowercase				,     atol=1E-4 ) )







'''simple docstring'''



def   lowercase__(			__UpperCamelCase:					int = 1_00_00_00    ):

      """simple docstring"""






      SCREAMING_SNAKE_CASE   :      Tuple    					=						[i - 1 for i in range(limit + 1    )]

      for i in range(2      ,limit + 1    ):
            if phi[i] == i - 1:
                  for j in range(2 * i      ,limit + 1      ,__UpperCamelCase    ):
                        phi[j] -= phi[j] // i

      return sum(phi[2 : limit + 1]    )


if __name__ == "__main__":
      print(solution())


