



import unittest

from transformers import SPIECE_UNDERLINE, XLNetTokenizer, XLNetTokenizerFast
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin


__UpperCAmelCase	       =	get_tests_dir('''fixtures/test_sentencepiece.model''')



@require_sentencepiece
@require_tokenizers
class     lowerCAmelCase_		(  a__	,   unittest.TestCase							):
       UpperCAmelCase__    : List[str]       					=  XLNetTokenizer
       UpperCAmelCase__    : Any       					=  XLNetTokenizerFast
       UpperCAmelCase__    : Optional[Any]       					=  True
       UpperCAmelCase__    : Union[str, Any]       					=  True
       def  snake_case_	(      self	)					->		Dict:
          super().setUp()

          # We have a SentencePiece fixture for testing
          UpperCamelCase   :  List[str]						     =     XLNetTokenizer(__a,      keep_accents=__a	)
          tokenizer.sanitize_special_tokens()
          tokenizer.save_pretrained(self.tmpdirname	)
       def  snake_case_	(      self	)					->		int:
          UpperCamelCase   :  Union[str, Any]						     =     '<s>'
          UpperCamelCase   :  str						     =     1

          self.assertEqual(self.get_tokenizer()._convert_token_to_id(__a	),      __a	)
          self.assertEqual(self.get_tokenizer()._convert_id_to_token(__a	),      __a	)
       def  snake_case_	(      self	)					->		int:
          UpperCamelCase   :  Tuple						     =     list(self.get_tokenizer().get_vocab().keys()	)

          self.assertEqual(vocab_keys[0],      '<unk>'	)
          self.assertEqual(vocab_keys[1],      '<s>'	)
          self.assertEqual(vocab_keys[-1],      '<eod>'	)
          self.assertEqual(len(__a	),      1006	)
       def  snake_case_	(      self	)					->		int:
          self.assertEqual(self.get_tokenizer().vocab_size,      1000	)
       def  snake_case_	(      self	)					->		List[Any]:
          UpperCamelCase   :  Optional[int]						     =     XLNetTokenizer(__a,      keep_accents=__a	)

          UpperCamelCase   :  List[Any]						     =     tokenizer.tokenize('This is a test'	)
          self.assertListEqual(__a,      ['▁This', '▁is', '▁a', '▁t', 'est']	)

          self.assertListEqual(tokenizer.convert_tokens_to_ids(__a	),      [285, 46, 10, 170, 382]	)

          UpperCamelCase   :  Union[str, Any]						     =     tokenizer.tokenize('I was born in 92000, and this is falsé.'	)
          self.assertListEqual(
              __a,      [
                  SPIECE_UNDERLINE + 'I',
                  SPIECE_UNDERLINE + 'was',
                  SPIECE_UNDERLINE + 'b',
                  'or',
                  'n',
                  SPIECE_UNDERLINE + 'in',
                  SPIECE_UNDERLINE + '',
                  '9',
                  '2',
                  '0',
                  '0',
                  '0',
                  ',',
                  SPIECE_UNDERLINE + 'and',
                  SPIECE_UNDERLINE + 'this',
                  SPIECE_UNDERLINE + 'is',
                  SPIECE_UNDERLINE + 'f',
                  'al',
                  's',
                  'é',
                  '.',
              ],      )
          UpperCamelCase   :  List[Any]						     =     tokenizer.convert_tokens_to_ids(__a	)
          self.assertListEqual(__a,      [8, 21, 84, 55, 24, 19, 7, 0, 602, 347, 347, 347, 3, 12, 66, 46, 72, 80, 6, 0, 4]	)

          UpperCamelCase   :  Union[str, Any]						     =     tokenizer.convert_ids_to_tokens(__a	)
          self.assertListEqual(
              __a,      [
                  SPIECE_UNDERLINE + 'I',
                  SPIECE_UNDERLINE + 'was',
                  SPIECE_UNDERLINE + 'b',
                  'or',
                  'n',
                  SPIECE_UNDERLINE + 'in',
                  SPIECE_UNDERLINE + '',
                  '<unk>',
                  '2',
                  '0',
                  '0',
                  '0',
                  ',',
                  SPIECE_UNDERLINE + 'and',
                  SPIECE_UNDERLINE + 'this',
                  SPIECE_UNDERLINE + 'is',
                  SPIECE_UNDERLINE + 'f',
                  'al',
                  's',
                  '<unk>',
                  '.',
              ],      )
       def  snake_case_	(      self	)					->		List[str]:
          UpperCamelCase   :  List[Any]						     =     XLNetTokenizer(__a,      do_lower_case=__a	)
          UpperCamelCase   :  List[str]						     =     tokenizer.tokenize('I was born in 92000, and this is falsé.'	)
          self.assertListEqual(
              __a,      [
                  SPIECE_UNDERLINE + '',
                  'i',
                  SPIECE_UNDERLINE + 'was',
                  SPIECE_UNDERLINE + 'b',
                  'or',
                  'n',
                  SPIECE_UNDERLINE + 'in',
                  SPIECE_UNDERLINE + '',
                  '9',
                  '2',
                  '0',
                  '0',
                  '0',
                  ',',
                  SPIECE_UNDERLINE + 'and',
                  SPIECE_UNDERLINE + 'this',
                  SPIECE_UNDERLINE + 'is',
                  SPIECE_UNDERLINE + 'f',
                  'al',
                  'se',
                  '.',
              ],      )
          self.assertListEqual(tokenizer.tokenize('H\u00E9llo'	),      ['▁he', 'll', 'o']	)
       def  snake_case_	(      self	)					->		Any:
          UpperCamelCase   :  Tuple						     =     XLNetTokenizer(__a,      do_lower_case=__a	)
          UpperCamelCase   :  Optional[int]						     =     tokenizer.tokenize('I was born in 92000, and this is falsé.'	)
          self.assertListEqual(
              __a,      [
                  SPIECE_UNDERLINE + 'I',
                  SPIECE_UNDERLINE + 'was',
                  SPIECE_UNDERLINE + 'b',
                  'or',
                  'n',
                  SPIECE_UNDERLINE + 'in',
                  SPIECE_UNDERLINE + '',
                  '9',
                  '2',
                  '0',
                  '0',
                  '0',
                  ',',
                  SPIECE_UNDERLINE + 'and',
                  SPIECE_UNDERLINE + 'this',
                  SPIECE_UNDERLINE + 'is',
                  SPIECE_UNDERLINE + 'f',
                  'al',
                  'se',
                  '.',
              ],      )
       @slow
       def  snake_case_	(      self	)					->		Tuple:
          UpperCamelCase   :  Optional[int]						     =     XLNetTokenizer.from_pretrained('xlnet-base-cased'	)

          UpperCamelCase   :  Union[str, Any]						     =     tokenizer.encode('sequence builders',      add_special_tokens=__a	)
          UpperCamelCase   :  Optional[Any]						     =     tokenizer.encode('multi-sequence build',      add_special_tokens=__a	)

          UpperCamelCase   :  Tuple						     =     tokenizer.build_inputs_with_special_tokens(__a	)
          UpperCamelCase   :  List[Any]						     =     tokenizer.build_inputs_with_special_tokens(__a,      __a	)

          assert encoded_sentence == text + [4, 3]
          assert encoded_pair == text + [4] + text_a + [4, 3]






       @slow
       def  snake_case_	(      self	)					->		Any:
          UpperCamelCase   :  Optional[Any]						     =     {'input_ids': [[17, 2_1442, 270, 17, 10, 1_4645, 318, 34, 17, 4546, 3145, 787, 13, 7752, 2_2018, 23, 21, 17, 4546, 3145, 787, 13, 3352, 1_4431, 13, 5500, 11, 1176, 580, 13, 1_6819, 4797, 23, 17, 10, 1_7135, 658, 19, 457, 7932, 13, 184, 19, 3154, 1_7135, 6468, 19, 1404, 1_2269, 19, 4229, 5356, 1_6264, 46, 19, 17, 2_0545, 1_0395, 9, 9, 9, 11, 28, 6421, 9531, 2_0729, 17, 10, 353, 1_7022, 11, 21, 6421, 9531, 1_6949, 17, 10, 1_1509, 753, 11, 33, 95, 2421, 7385, 956, 1_4431, 2626, 25, 842, 7385, 4836, 21, 1429, 2272, 9855, 3120, 161, 2_4738, 19, 1_3203, 658, 218, 787, 21, 430, 1_8482, 847, 2637, 9, 4, 3], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 322, 2_2178, 27, 1064, 22, 956, 13, 1_1101, 1429, 5854, 2_4313, 1_8953, 40, 422, 2_4366, 68, 1758, 37, 1_0483, 1_4257, 31, 207, 263, 21, 203, 3773, 25, 71, 9735, 9, 4, 3], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 32, 2049, 3442, 17, 1_3894, 3380, 23, 95, 18, 1_7634, 2288, 9, 4, 3]], 'token_type_ids': [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2]], 'attention_mask': [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]}  # noqa: E501
          # fmt: on

          self.tokenizer_integration_test_util(
              expected_encoding=__a,      model_name='xlnet-base-cased',      revision='c841166438c31ec7ca9a106dee7bb312b73ae511',      )





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,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_=13,      SCREAMING_SNAKE_CASE_=7,      SCREAMING_SNAKE_CASE_=False,      SCREAMING_SNAKE_CASE_=True,      SCREAMING_SNAKE_CASE_=False,      SCREAMING_SNAKE_CASE_=False,      SCREAMING_SNAKE_CASE_=19,      SCREAMING_SNAKE_CASE_=32,      SCREAMING_SNAKE_CASE_=5,      SCREAMING_SNAKE_CASE_=4,      SCREAMING_SNAKE_CASE_=37,      SCREAMING_SNAKE_CASE_="gelu",      SCREAMING_SNAKE_CASE_=0.1,      SCREAMING_SNAKE_CASE_=0.1,      SCREAMING_SNAKE_CASE_=512,      SCREAMING_SNAKE_CASE_=16,      SCREAMING_SNAKE_CASE_=2,      SCREAMING_SNAKE_CASE_=0.02,      SCREAMING_SNAKE_CASE_=3,      SCREAMING_SNAKE_CASE_=4,      SCREAMING_SNAKE_CASE_=None,      )					->		Optional[int]:
          UpperCamelCase   :  Any						     =     parent
          UpperCamelCase   :  Optional[Any]						     =     batch_size
          UpperCamelCase   :  Optional[Any]						     =     seq_length
          UpperCamelCase   :  Tuple						     =     is_training
          UpperCamelCase   :  List[str]						     =     use_input_mask
          UpperCamelCase   :  Optional[int]						     =     use_token_type_ids
          UpperCamelCase   :  Any						     =     use_labels
          UpperCamelCase   :  Union[str, Any]						     =     vocab_size
          UpperCamelCase   :  int						     =     hidden_size
          UpperCamelCase   :  List[Any]						     =     num_hidden_layers
          UpperCamelCase   :  Dict						     =     num_attention_heads
          UpperCamelCase   :  List[Any]						     =     intermediate_size
          UpperCamelCase   :  str						     =     hidden_act
          UpperCamelCase   :  List[Any]						     =     hidden_dropout_prob
          UpperCamelCase   :  List[str]						     =     attention_probs_dropout_prob
          UpperCamelCase   :  List[str]						     =     max_position_embeddings
          UpperCamelCase   :  Union[str, Any]						     =     type_vocab_size
          UpperCamelCase   :  str						     =     type_sequence_label_size
          UpperCamelCase   :  List[str]						     =     initializer_range
          UpperCamelCase   :  List[Any]						     =     num_labels
          UpperCamelCase   :  Any						     =     num_choices
          UpperCamelCase   :  Tuple						     =     scope
       def  snake_case_	(      self	)					->		Optional[int]:
          UpperCamelCase   :  str						     =     ids_tensor([self.batch_size, self.seq_length],      self.vocab_size	)

          UpperCamelCase   :  Optional[Any]						     =     None
          if self.use_input_mask:
             UpperCamelCase   :  Dict						     =     random_attention_mask([self.batch_size, self.seq_length]	)

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

          UpperCamelCase   :  Union[str, Any]						     =     self.get_config()

          return config, input_ids, input_mask, sequence_labels, token_labels, choice_labels
       def  snake_case_	(      self	)					->		Optional[int]:
          UpperCamelCase   :  List[str]						     =     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=SCREAMING_SNAKE_CASE_,      esmfold_config={'trunk': {'num_blocks': 2}, 'fp16_esm': False},      )
          return config
       def  snake_case_	(      self,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_	)					->		Tuple:
          UpperCamelCase   :  Union[str, Any]						     =     EsmForProteinFolding(config=SCREAMING_SNAKE_CASE_	).float()
          model.to(SCREAMING_SNAKE_CASE_	)
          model.eval()
          UpperCamelCase   :  int						     =     model(SCREAMING_SNAKE_CASE_,      attention_mask=SCREAMING_SNAKE_CASE_	)
          UpperCamelCase   :  List[Any]						     =     model(SCREAMING_SNAKE_CASE_	)
          UpperCamelCase   :  List[Any]						     =     model(SCREAMING_SNAKE_CASE_	)

          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	)					->		Optional[int]:
          UpperCamelCase   :  Union[str, Any]						     =     self.prepare_config_and_inputs()
          (
              (
              UpperCamelCase
          )     ,					(
              UpperCamelCase
          )     ,					(
              UpperCamelCase
          )     ,					(
              UpperCamelCase
          )     ,					(
              UpperCamelCase
          )     ,					(
              UpperCamelCase
          )     ,					
          )   :  Tuple						     =     config_and_inputs
          UpperCamelCase   :  Optional[Any]						     =     {'input_ids': input_ids, 'attention_mask': input_mask}
          return config, inputs_dict






@require_torch
class     lowerCAmelCase_		(  a__	,   a__	,   unittest.TestCase							):
       UpperCAmelCase__    : Dict       					=  False

       UpperCAmelCase__    : Optional[int]       					=  (EsmForProteinFolding,) if is_torch_available() else ()
       UpperCAmelCase__    : int       					=  ()
       UpperCAmelCase__    : List[str]       					=  {} if is_torch_available() else {}
       UpperCAmelCase__    : Optional[int]       					=  False
       def  snake_case_	(      self	)					->		Dict:
          UpperCamelCase   :  Tuple						     =     EsmFoldModelTester(self	)
          UpperCamelCase   :  List[str]						     =     ConfigTester(self,      config_class=SCREAMING_SNAKE_CASE_,      hidden_size=37	)
       def  snake_case_	(      self	)					->		int:
          self.config_tester.run_common_tests()
       def  snake_case_	(      self	)					->		Union[str, Any]:
          UpperCamelCase   :  int						     =     self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE_	)
       @unittest.skip('Does not support attention outputs'	)
       def  snake_case_	(      self	)					->		Tuple:
          pass
       @unittest.skip
       def  snake_case_	(      self	)					->		List[Any]:
          pass
       @unittest.skip('Esm does not support embedding resizing'	)
       def  snake_case_	(      self	)					->		Any:
          pass
       @unittest.skip('Esm does not support embedding resizing'	)
       def  snake_case_	(      self	)					->		Optional[Any]:
          pass
       @unittest.skip('ESMFold does not support passing input embeds!'	)
       def  snake_case_	(      self	)					->		Optional[Any]:
          pass
       @unittest.skip('ESMFold does not support head pruning.'	)
       def  snake_case_	(      self	)					->		Any:
          pass
       @unittest.skip('ESMFold does not support head pruning.'	)
       def  snake_case_	(      self	)					->		int:
          pass
       @unittest.skip('ESMFold does not support head pruning.'	)
       def  snake_case_	(      self	)					->		Dict:
          pass
       @unittest.skip('ESMFold does not support head pruning.'	)
       def  snake_case_	(      self	)					->		Union[str, Any]:
          pass
       @unittest.skip('ESMFold does not support head pruning.'	)
       def  snake_case_	(      self	)					->		Any:
          pass
       @unittest.skip('ESMFold does not output hidden states in the normal way.'	)
       def  snake_case_	(      self	)					->		str:
          pass
       @unittest.skip('ESMfold does not output hidden states in the normal way.'	)
       def  snake_case_	(      self	)					->		List[str]:
          pass
       @unittest.skip('ESMFold only has one output format.'	)
       def  snake_case_	(      self	)					->		int:
          pass
       @unittest.skip('This test doesn\'t work for ESMFold and doesn\'t test core functionality'	)
       def  snake_case_	(      self	)					->		Any:
          pass
       @unittest.skip('ESMFold does not support input chunking.'	)
       def  snake_case_	(      self	)					->		Any:
          pass
       @unittest.skip('ESMFold doesn\'t respect you and it certainly doesn\'t respect your initialization arguments.'	)
       def  snake_case_	(      self	)					->		Tuple:
          pass
       @unittest.skip('ESMFold doesn\'t support torchscript compilation.'	)
       def  snake_case_	(      self	)					->		Any:
          pass
       @unittest.skip('ESMFold doesn\'t support torchscript compilation.'	)
       def  snake_case_	(      self	)					->		str:
          pass
       @unittest.skip('ESMFold doesn\'t support torchscript compilation.'	)
       def  snake_case_	(      self	)					->		List[Any]:
          pass
       @unittest.skip('ESMFold doesn\'t support data parallel.'	)
       def  snake_case_	(      self	)					->		List[str]:
          pass






       @unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.'	)
       def  snake_case_	(      self	)					->		Optional[Any]:
          pass






@require_torch
class     lowerCAmelCase_		(  a__							):
       @slow
       def  snake_case_	(      self	)					->		str:
          UpperCamelCase   :  Union[str, Any]						     =     EsmForProteinFolding.from_pretrained('facebook/esmfold_v1'	).float()
          model.eval()
          UpperCamelCase   :  Tuple						     =     torch.tensor([[0, 6, 4, 13, 5, 4, 16, 12, 11, 7, 2]]	)
          UpperCamelCase   :  List[str]						     =     model(SCREAMING_SNAKE_CASE_	)['positions']
          UpperCamelCase   :  int						     =     torch.tensor([2.58_28, 0.79_93, -10.93_34],      dtype=torch.floataa	)
          self.assertTrue(torch.allclose(position_outputs[0, 0, 0, 0],      SCREAMING_SNAKE_CASE_,      atol=1e-4	)	)



