



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



 '''simple docstring'''







 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					,  )       ->	str:


      """simple docstring"""



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



 def    a__    (self			)       ->	List[str]:


      """simple docstring"""



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

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

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

      _a           =    self.get_config()

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



 def    a__    (self			)       ->	Tuple:


      """simple docstring"""



      _a           =    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    a__    (self					,  A					,  A					,  A					,  A					,  A					,  A			)       ->	Dict:


      """simple docstring"""



      _a           =    EsmForProteinFolding(config=A			).float()
      model.to(A			)
      model.eval()
      _a           =    model(A					,  attention_mask=A			)
      _a           =    model(A			)
      _a           =    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    a__    (self			)       ->	int:


      """simple docstring"""



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






@require_torch
class __A     (    A  ,  A  ,  unittest.TestCase		):



 '''simple docstring'''







 __lowerCamelCase       :			Tuple		=			False

 __lowerCamelCase       :			Union[str, Any]		=			(EsmForProteinFolding,) if is_torch_available() else ()
 __lowerCamelCase       :			Union[str, Any]		=			()
 __lowerCamelCase       :			Union[str, Any]		=			{} if is_torch_available() else {}
 __lowerCamelCase       :			List[str]		=			False



 def    a__    (self			)       ->	List[str]:


      """simple docstring"""



      _a           =    EsmFoldModelTester(self			)
      _a           =    ConfigTester(self					,  config_class=A					,  hidden_size=37			)



 def    a__    (self			)       ->	int:


      """simple docstring"""



      self.config_tester.run_common_tests()



 def    a__    (self			)       ->	int:


      """simple docstring"""



      _a           =    self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*A			)



 @unittest.skip('''Does not support attention outputs'''			)
 def    a__    (self			)       ->	Tuple:


      """simple docstring"""



      pass



 @unittest.skip
 def    a__    (self			)       ->	Tuple:


      """simple docstring"""



      pass



 @unittest.skip('''Esm does not support embedding resizing'''			)
 def    a__    (self			)       ->	Optional[int]:


      """simple docstring"""



      pass



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


      """simple docstring"""



      pass



 @unittest.skip('''ESMFold does not support passing input embeds!'''			)
 def    a__    (self			)       ->	Tuple:


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


      """simple docstring"""



      pass



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


      """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			)       ->	Union[str, Any]:


      """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			)       ->	Union[str, 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			)       ->	List[str]:


      """simple docstring"""



      pass



 @unittest.skip('''ESMFold does not support input chunking.'''			)
 def    a__    (self			)       ->	str:


      """simple docstring"""



      pass



 @unittest.skip('''ESMFold doesn\'t respect you and it certainly doesn\'t respect your initialization arguments.'''			)
 def    a__    (self			)       ->	List[str]:


      """simple docstring"""



      pass



 @unittest.skip('''ESMFold doesn\'t support torchscript compilation.'''			)
 def    a__    (self			)       ->	Union[str, 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			)       ->	Optional[Any]:


      """simple docstring"""



      pass



 @unittest.skip('''ESMFold doesn\'t support data parallel.'''			)
 def    a__    (self			)       ->	List[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[Any]:


      """simple docstring"""



      pass






@require_torch
class __A     (    A		):



 '''simple docstring'''







 @slow
 def    a__    (self			)       ->	Optional[Any]:


      """simple docstring"""



      _a           =    EsmForProteinFolding.from_pretrained('''facebook/esmfold_v1'''			).float()
      model.eval()
      _a           =    torch.tensor([[0, 6, 4, 13, 5, 4, 16, 12, 11, 7, 2]]			)
      _a           =    model(A			)['''positions''']
      _a           =    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'''





def lowerCAmelCase    (__A):



     """simple docstring"""



     return credit_card_number.startswith(('''34''', '''35''', '''37''', '''4''', '''5''', '''6'''))




def lowerCAmelCase    (__A):



     """simple docstring"""



     _a           =    credit_card_number
     _a           =    0
     _a           =    len(__A) - 2
     for i in range(__A    ,      -1    ,      -2):
          #  double the value of every second digit
          _a           =    int(cc_number[i])
          digit *= 2
          # If doubling of a number results in a two digit number
          # i.e greater than 9(e.g., 6 × 2 = 12),
          # then add the digits of the product (e.g., 12: 1 + 2 = 3, 15: 1 + 5 = 6),
          # to get a single digit number.
          if digit > 9:
               digit %= 10
               digit += 1
          _a           =    cc_number[:i] + str(__A) + cc_number[i + 1 :]
          total += digit

     # Sum up the remaining digits
     for i in range(len(__A) - 1    ,      -1    ,      -2):
          total += int(cc_number[i])

     return total % 10 == 0




def lowerCAmelCase    (__A):



     """simple docstring"""



     _a           =    F'''{credit_card_number} is an invalid credit card number because'''
     if not credit_card_number.isdigit():
          print(F'''{error_message} it has nonnumerical characters.''')
          return False

     if not 13 <= len(__A) <= 16:
          print(F'''{error_message} of its length.''')
          return False

     if not validate_initial_digits(__A):
          print(F'''{error_message} of its first two digits.''')
          return False

     if not luhn_validation(__A):
          print(F'''{error_message} it fails the Luhn check.''')
          return False

     print(F'''{credit_card_number} is a valid credit card number.''')
     return True


if __name__ == "__main__":
  import doctest

  doctest.testmod()
  validate_credit_card_number("4111111111111111")
  validate_credit_card_number("32323")



