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      :    Optional[Any]	,     _lowercase      :    Union[str, Any]	,     _lowercase      :    Tuple=13	,     _lowercase      :    Optional[Any]=7	,     _lowercase      :    List[str]=False	,     _lowercase      :    Dict=True	,     _lowercase      :    List[str]=False	,     _lowercase      :    List[Any]=False	,     _lowercase      :    str=19	,     _lowercase      :    Dict=32	,     _lowercase      :    str=5	,     _lowercase      :    Optional[int]=4	,     _lowercase      :    List[Any]=37	,     _lowercase      :    List[str]="gelu"	,     _lowercase      :    Optional[int]=0.1	,     _lowercase      :    List[Any]=0.1	,     _lowercase      :    List[Any]=5_12	,     _lowercase      :    List[str]=16	,     _lowercase      :    Union[str, Any]=2	,     _lowercase      :    Dict=0.02	,     _lowercase      :    str=3	,     _lowercase      :    Optional[int]=4	,     _lowercase      :    str=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      :    List[Any]				):



     """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      :    Tuple				):



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




   def      __a						(   self      :    Optional[Any]	,     _lowercase      :    List[Any]	,     _lowercase      :    Dict	,     _lowercase      :    Optional[Any]	,     _lowercase      :    Optional[int]	,     _lowercase      :    Optional[int]	,     _lowercase      :    Union[str, Any]				):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				EsmForProteinFolding(config=_lowerCamelCase				).float()
     model.to(_lowerCamelCase				)
     model.eval()
     SCREAMING_SNAKE_CASE__      							=				model(_lowerCamelCase	,     attention_mask=_lowerCamelCase				)
     SCREAMING_SNAKE_CASE__      							=				model(_lowerCamelCase				)
     SCREAMING_SNAKE_CASE__      							=				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      __a						(   self      :    Optional[Any]				):



     """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    (						a__       ,		a__       ,		unittest.TestCase		):
   lowerCAmelCase_   							=							False

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




   def      __a						(   self      :    Tuple				):



     """simple docstring"""






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




   def      __a						(   self      :    Optional[int]				):



     """simple docstring"""






     self.config_tester.run_common_tests()




   def      __a						(   self      :    int				):



     """simple docstring"""






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




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



     """simple docstring"""






     pass




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



     """simple docstring"""






     pass




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



     """simple docstring"""






     pass




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



     """simple docstring"""






     pass




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



     """simple docstring"""






     pass




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



     """simple docstring"""






     pass




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



     """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 support head pruning."""				)
   def      __a						(   self      :    int				):



     """simple docstring"""






     pass




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



     """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      :    Any				):



     """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      :    Any				):



     """simple docstring"""






     pass




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



     """simple docstring"""






     pass




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



     """simple docstring"""






     pass




   @unittest.skip("""ESMFold doesn\'t support data parallel."""				)
   def      __a						(   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      __a						(   self      :    Optional[int]				):



     """simple docstring"""






     pass







@require_torch
class __snake_case    (						a__		):




   @slow
   def      __a						(   self      :    Union[str, 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(_lowerCamelCase				)['''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]	,     _lowerCamelCase	,     atol=1E-4				)				)

from math import isqrt



def      __SCREAMING_SNAKE_CASE  ( __UpperCamelCase   :	int     )							-> list[int]:







  """simple docstring"""





  SCREAMING_SNAKE_CASE__      							=				[True] * max_number
  for i in range(2			,					isqrt(max_number - 1     ) + 1     ):
    if is_prime[i]:
      for j in range(i**2			,					__UpperCamelCase			,					__UpperCamelCase     ):
        SCREAMING_SNAKE_CASE__      							=				False

  return [i for i in range(2			,					__UpperCamelCase     ) if is_prime[i]]



def      __SCREAMING_SNAKE_CASE  ( __UpperCamelCase   :	int = 10**8     )							-> int:







  """simple docstring"""





  SCREAMING_SNAKE_CASE__      							=				calculate_prime_numbers(max_number // 2     )

  SCREAMING_SNAKE_CASE__      							=				0
  SCREAMING_SNAKE_CASE__      							=				0
  SCREAMING_SNAKE_CASE__      							=				len(__UpperCamelCase     ) - 1
  while left <= right:
    while prime_numbers[left] * prime_numbers[right] >= max_number:
      right -= 1
    semiprimes_count += right - left + 1
    left += 1

  return semiprimes_count


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