



import os
import unittest

from transformers import BertTokenizerFast
from transformers.models.bert.tokenization_bert import (
    VOCAB_FILES_NAMES,
    BasicTokenizer,
    BertTokenizer,
    WordpieceTokenizer,
    _is_control,
    _is_punctuation,
    _is_whitespace,
)
from transformers.testing_utils import require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin, filter_non_english



@require_tokenizers
class     lowerCAmelCase_		(  a__	,   unittest.TestCase							):
       UpperCAmelCase__    : Tuple       					=  BertTokenizer
       UpperCAmelCase__    : Tuple       					=  BertTokenizerFast
       UpperCAmelCase__    : Union[str, Any]       					=  True
       UpperCAmelCase__    : int       					=  True
       UpperCAmelCase__    : Union[str, Any]       					=  filter_non_english
       def  snake_case_	(      self	)					->		Dict:
          super().setUp()

          UpperCamelCase   :  List[Any]						     =     [
              '[UNK]',
              '[CLS]',
              '[SEP]',
              '[PAD]',
              '[MASK]',
              'want',
              '##want',
              '##ed',
              'wa',
              'un',
              'runn',
              '##ing',
              ',',
              'low',
              'lowest',
          ]
          UpperCamelCase   :  int						     =     os.path.join(self.tmpdirname,      VOCAB_FILES_NAMES['vocab_file']	)
          with open(self.vocab_file,      'w',      encoding='utf-8'	) as vocab_writer:
             vocab_writer.write(''.join([x + '\n' for x in vocab_tokens]	)	)
       def  snake_case_	(      self,      SCREAMING_SNAKE_CASE_	)					->		List[Any]:
          UpperCamelCase   :  List[Any]						     =     'UNwant\u00E9d,running'
          UpperCamelCase   :  List[Any]						     =     'unwanted, running'
          return input_text, output_text
       def  snake_case_	(      self	)					->		Any:
          UpperCamelCase   :  str						     =     self.tokenizer_class(self.vocab_file	)

          UpperCamelCase   :  List[str]						     =     tokenizer.tokenize('UNwant\u00E9d,running'	)
          self.assertListEqual(SCREAMING_SNAKE_CASE_,      ['un', '##want', '##ed', ',', 'runn', '##ing']	)
          self.assertListEqual(tokenizer.convert_tokens_to_ids(SCREAMING_SNAKE_CASE_	),      [9, 6, 7, 12, 10, 11]	)
       def  snake_case_	(      self	)					->		List[str]:
          if not self.test_rust_tokenizer:
             return

          UpperCamelCase   :  List[Any]						     =     self.get_tokenizer()
          UpperCamelCase   :  Any						     =     self.get_rust_tokenizer()

          UpperCamelCase   :  Any						     =     'UNwant\u00E9d,running'

          UpperCamelCase   :  Optional[int]						     =     tokenizer.tokenize(SCREAMING_SNAKE_CASE_	)
          UpperCamelCase   :  Tuple						     =     rust_tokenizer.tokenize(SCREAMING_SNAKE_CASE_	)
          self.assertListEqual(SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_	)

          UpperCamelCase   :  Dict						     =     tokenizer.encode(SCREAMING_SNAKE_CASE_,      add_special_tokens=SCREAMING_SNAKE_CASE_	)
          UpperCamelCase   :  Any						     =     rust_tokenizer.encode(SCREAMING_SNAKE_CASE_,      add_special_tokens=SCREAMING_SNAKE_CASE_	)
          self.assertListEqual(SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_	)

          UpperCamelCase   :  Union[str, Any]						     =     self.get_rust_tokenizer()
          UpperCamelCase   :  Tuple						     =     tokenizer.encode(SCREAMING_SNAKE_CASE_	)
          UpperCamelCase   :  Union[str, Any]						     =     rust_tokenizer.encode(SCREAMING_SNAKE_CASE_	)
          self.assertListEqual(SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_	)

          # With lower casing
          UpperCamelCase   :  Optional[Any]						     =     self.get_tokenizer(do_lower_case=SCREAMING_SNAKE_CASE_	)
          UpperCamelCase   :  int						     =     self.get_rust_tokenizer(do_lower_case=SCREAMING_SNAKE_CASE_	)

          UpperCamelCase   :  List[str]						     =     'UNwant\u00E9d,running'

          UpperCamelCase   :  Union[str, Any]						     =     tokenizer.tokenize(SCREAMING_SNAKE_CASE_	)
          UpperCamelCase   :  Any						     =     rust_tokenizer.tokenize(SCREAMING_SNAKE_CASE_	)
          self.assertListEqual(SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_	)

          UpperCamelCase   :  Union[str, Any]						     =     tokenizer.encode(SCREAMING_SNAKE_CASE_,      add_special_tokens=SCREAMING_SNAKE_CASE_	)
          UpperCamelCase   :  Any						     =     rust_tokenizer.encode(SCREAMING_SNAKE_CASE_,      add_special_tokens=SCREAMING_SNAKE_CASE_	)
          self.assertListEqual(SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_	)

          UpperCamelCase   :  int						     =     self.get_rust_tokenizer()
          UpperCamelCase   :  Union[str, Any]						     =     tokenizer.encode(SCREAMING_SNAKE_CASE_	)
          UpperCamelCase   :  Any						     =     rust_tokenizer.encode(SCREAMING_SNAKE_CASE_	)
          self.assertListEqual(SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_	)
       def  snake_case_	(      self	)					->		Optional[int]:
          UpperCamelCase   :  Optional[int]						     =     BasicTokenizer()

          self.assertListEqual(tokenizer.tokenize('ah\u535A\u63A8zz'	),      ['ah', '\u535A', '\u63A8', 'zz']	)
       def  snake_case_	(      self	)					->		List[str]:
          UpperCamelCase   :  Union[str, Any]						     =     BasicTokenizer(do_lower_case=SCREAMING_SNAKE_CASE_	)

          self.assertListEqual(
              tokenizer.tokenize(' \tHeLLo!how  \n Are yoU?  '	),      ['hello', '!', 'how', 'are', 'you', '?']	)
          self.assertListEqual(tokenizer.tokenize('H\u00E9llo'	),      ['hello']	)
       def  snake_case_	(      self	)					->		Optional[int]:
          UpperCamelCase   :  Optional[Any]						     =     BasicTokenizer(do_lower_case=SCREAMING_SNAKE_CASE_,      strip_accents=SCREAMING_SNAKE_CASE_	)

          self.assertListEqual(
              tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '	),      ['hällo', '!', 'how', 'are', 'you', '?']	)
          self.assertListEqual(tokenizer.tokenize('H\u00E9llo'	),      ['h\u00E9llo']	)
       def  snake_case_	(      self	)					->		Tuple:
          UpperCamelCase   :  Dict						     =     BasicTokenizer(do_lower_case=SCREAMING_SNAKE_CASE_,      strip_accents=SCREAMING_SNAKE_CASE_	)

          self.assertListEqual(
              tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '	),      ['hallo', '!', 'how', 'are', 'you', '?']	)
          self.assertListEqual(tokenizer.tokenize('H\u00E9llo'	),      ['hello']	)
       def  snake_case_	(      self	)					->		Optional[int]:
          UpperCamelCase   :  Union[str, Any]						     =     BasicTokenizer(do_lower_case=SCREAMING_SNAKE_CASE_	)

          self.assertListEqual(
              tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '	),      ['hallo', '!', 'how', 'are', 'you', '?']	)
          self.assertListEqual(tokenizer.tokenize('H\u00E9llo'	),      ['hello']	)
       def  snake_case_	(      self	)					->		List[str]:
          UpperCamelCase   :  List[str]						     =     BasicTokenizer(do_lower_case=SCREAMING_SNAKE_CASE_	)

          self.assertListEqual(
              tokenizer.tokenize(' \tHeLLo!how  \n Are yoU?  '	),      ['HeLLo', '!', 'how', 'Are', 'yoU', '?']	)
       def  snake_case_	(      self	)					->		Tuple:
          UpperCamelCase   :  List[str]						     =     BasicTokenizer(do_lower_case=SCREAMING_SNAKE_CASE_,      strip_accents=SCREAMING_SNAKE_CASE_	)

          self.assertListEqual(
              tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '	),      ['HäLLo', '!', 'how', 'Are', 'yoU', '?']	)
       def  snake_case_	(      self	)					->		Optional[int]:
          UpperCamelCase   :  Union[str, Any]						     =     BasicTokenizer(do_lower_case=SCREAMING_SNAKE_CASE_,      strip_accents=SCREAMING_SNAKE_CASE_	)

          self.assertListEqual(
              tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '	),      ['HaLLo', '!', 'how', 'Are', 'yoU', '?']	)
       def  snake_case_	(      self	)					->		Optional[Any]:
          UpperCamelCase   :  Optional[Any]						     =     BasicTokenizer(do_lower_case=SCREAMING_SNAKE_CASE_,      never_split=['[UNK]']	)

          self.assertListEqual(
              tokenizer.tokenize(' \tHeLLo!how  \n Are yoU? [UNK]'	),      ['HeLLo', '!', 'how', 'Are', 'yoU', '?', '[UNK]']	)
       def  snake_case_	(      self	)					->		Optional[Any]:
          UpperCamelCase   :  str						     =     BasicTokenizer()
          UpperCamelCase   :  Optional[int]						     =     'a\n\'ll !!to?\'d of, can\'t.'
          UpperCamelCase   :  List[str]						     =     ['a', '\'', 'll', '!', '!', 'to', '?', '\'', 'd', 'of', ',', 'can', '\'', 't', '.']
          self.assertListEqual(tokenizer.tokenize(SCREAMING_SNAKE_CASE_	),      SCREAMING_SNAKE_CASE_	)
       def  snake_case_	(      self	)					->		Union[str, Any]:
          UpperCamelCase   :  Optional[Any]						     =     ['[UNK]', '[CLS]', '[SEP]', 'want', '##want', '##ed', 'wa', 'un', 'runn', '##ing']

          UpperCamelCase   :  str						     =     {}
          for i, token in enumerate(SCREAMING_SNAKE_CASE_	):
             UpperCamelCase   :  List[str]						     =     i
          UpperCamelCase   :  Tuple						     =     WordpieceTokenizer(vocab=SCREAMING_SNAKE_CASE_,      unk_token='[UNK]'	)

          self.assertListEqual(tokenizer.tokenize(''	),      []	)

          self.assertListEqual(tokenizer.tokenize('unwanted running'	),      ['un', '##want', '##ed', 'runn', '##ing']	)

          self.assertListEqual(tokenizer.tokenize('unwantedX running'	),      ['[UNK]', 'runn', '##ing']	)
       def  snake_case_	(      self	)					->		Dict:
          self.assertTrue(_is_whitespace(' '	)	)
          self.assertTrue(_is_whitespace('\t'	)	)
          self.assertTrue(_is_whitespace('\r'	)	)
          self.assertTrue(_is_whitespace('\n'	)	)
          self.assertTrue(_is_whitespace('\u00A0'	)	)

          self.assertFalse(_is_whitespace('A'	)	)
          self.assertFalse(_is_whitespace('-'	)	)
       def  snake_case_	(      self	)					->		Tuple:
          self.assertTrue(_is_control('\u0005'	)	)

          self.assertFalse(_is_control('A'	)	)
          self.assertFalse(_is_control(' '	)	)
          self.assertFalse(_is_control('\t'	)	)
          self.assertFalse(_is_control('\r'	)	)
       def  snake_case_	(      self	)					->		Optional[int]:
          self.assertTrue(_is_punctuation('-'	)	)
          self.assertTrue(_is_punctuation('$'	)	)
          self.assertTrue(_is_punctuation('`'	)	)
          self.assertTrue(_is_punctuation('.'	)	)

          self.assertFalse(_is_punctuation('A'	)	)
          self.assertFalse(_is_punctuation(' '	)	)
       def  snake_case_	(      self	)					->		Optional[int]:
          UpperCamelCase   :  Dict						     =     self.get_tokenizer()
          UpperCamelCase   :  Optional[Any]						     =     self.get_rust_tokenizer()

          # Example taken from the issue https://github.com/huggingface/tokenizers/issues/340
          self.assertListEqual([tokenizer.tokenize(SCREAMING_SNAKE_CASE_	) for t in ['Test', '\xad', 'test']],      [['[UNK]'], [], ['[UNK]']]	)

          self.assertListEqual(
              [rust_tokenizer.tokenize(SCREAMING_SNAKE_CASE_	) for t in ['Test', '\xad', 'test']],      [['[UNK]'], [], ['[UNK]']]	)
       @slow
       def  snake_case_	(      self	)					->		Union[str, Any]:
          UpperCamelCase   :  Tuple						     =     self.tokenizer_class.from_pretrained('bert-base-uncased'	)

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

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

          assert encoded_sentence == [101] + text + [102]
          assert encoded_pair == [101] + text + [102] + text_a + [102]
       def  snake_case_	(      self	)					->		Tuple:
          for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
             with self.subTest(F"""{tokenizer.__class__.__name__} ({pretrained_name})"""	):
                UpperCamelCase   :  Dict						     =     self.rust_tokenizer_class.from_pretrained(SCREAMING_SNAKE_CASE_,      **SCREAMING_SNAKE_CASE_	)

                UpperCamelCase   :  str						     =     F"""A, naïve {tokenizer_r.mask_token} AllenNLP sentence."""
                UpperCamelCase   :  int						     =     tokenizer_r.encode_plus(
                    SCREAMING_SNAKE_CASE_,      return_attention_mask=SCREAMING_SNAKE_CASE_,      return_token_type_ids=SCREAMING_SNAKE_CASE_,      return_offsets_mapping=SCREAMING_SNAKE_CASE_,      add_special_tokens=SCREAMING_SNAKE_CASE_,      )

                UpperCamelCase   :  Dict						     =     tokenizer_r.do_lower_case if hasattr(SCREAMING_SNAKE_CASE_,      'do_lower_case'	) else False
                UpperCamelCase   :  List[Any]						     =     (
                    [
                        ((0, 0), tokenizer_r.cls_token),
                        ((0, 1), 'A'),
                        ((1, 2), ','),
                        ((3, 5), 'na'),
                        ((5, 6), '##ï'),
                        ((6, 8), '##ve'),
                        ((9, 15), tokenizer_r.mask_token),
                        ((16, 21), 'Allen'),
                        ((21, 23), '##NL'),
                        ((23, 24), '##P'),
                        ((25, 33), 'sentence'),
                        ((33, 34), '.'),
                        ((0, 0), tokenizer_r.sep_token),
                    ]
                    if not do_lower_case
                    else [
                        ((0, 0), tokenizer_r.cls_token),
                        ((0, 1), 'a'),
                        ((1, 2), ','),
                        ((3, 8), 'naive'),
                        ((9, 15), tokenizer_r.mask_token),
                        ((16, 21), 'allen'),
                        ((21, 23), '##nl'),
                        ((23, 24), '##p'),
                        ((25, 33), 'sentence'),
                        ((33, 34), '.'),
                        ((0, 0), tokenizer_r.sep_token),
                    ]
                )

                self.assertEqual(
                    [e[1] for e in expected_results],      tokenizer_r.convert_ids_to_tokens(tokens['input_ids']	)	)
                self.assertEqual([e[0] for e in expected_results],      tokens['offset_mapping']	)






       def  snake_case_	(      self	)					->		Tuple:
          UpperCamelCase   :  Optional[Any]						     =     ['的', '人', '有']
          UpperCamelCase   :  str						     =     ''.join(SCREAMING_SNAKE_CASE_	)
          for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
             with self.subTest(F"""{tokenizer.__class__.__name__} ({pretrained_name})"""	):
                UpperCamelCase   :  str						     =     True
                UpperCamelCase   :  Optional[Any]						     =     self.tokenizer_class.from_pretrained(SCREAMING_SNAKE_CASE_,      **SCREAMING_SNAKE_CASE_	)
                UpperCamelCase   :  str						     =     self.rust_tokenizer_class.from_pretrained(SCREAMING_SNAKE_CASE_,      **SCREAMING_SNAKE_CASE_	)

                UpperCamelCase   :  str						     =     tokenizer_p.encode(SCREAMING_SNAKE_CASE_,      add_special_tokens=SCREAMING_SNAKE_CASE_	)
                UpperCamelCase   :  List[Any]						     =     tokenizer_r.encode(SCREAMING_SNAKE_CASE_,      add_special_tokens=SCREAMING_SNAKE_CASE_	)

                UpperCamelCase   :  int						     =     tokenizer_r.convert_ids_to_tokens(SCREAMING_SNAKE_CASE_	)
                UpperCamelCase   :  Union[str, Any]						     =     tokenizer_p.convert_ids_to_tokens(SCREAMING_SNAKE_CASE_	)

                # it is expected that each Chinese character is not preceded by "##"
                self.assertListEqual(SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_	)
                self.assertListEqual(SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_	)

                UpperCamelCase   :  List[Any]						     =     False
                UpperCamelCase   :  int						     =     self.rust_tokenizer_class.from_pretrained(SCREAMING_SNAKE_CASE_,      **SCREAMING_SNAKE_CASE_	)
                UpperCamelCase   :  Union[str, Any]						     =     self.tokenizer_class.from_pretrained(SCREAMING_SNAKE_CASE_,      **SCREAMING_SNAKE_CASE_	)

                UpperCamelCase   :  Union[str, Any]						     =     tokenizer_r.encode(SCREAMING_SNAKE_CASE_,      add_special_tokens=SCREAMING_SNAKE_CASE_	)
                UpperCamelCase   :  Any						     =     tokenizer_p.encode(SCREAMING_SNAKE_CASE_,      add_special_tokens=SCREAMING_SNAKE_CASE_	)

                UpperCamelCase   :  Tuple						     =     tokenizer_r.convert_ids_to_tokens(SCREAMING_SNAKE_CASE_	)
                UpperCamelCase   :  Dict						     =     tokenizer_p.convert_ids_to_tokens(SCREAMING_SNAKE_CASE_	)

                # it is expected that only the first Chinese character is not preceded by "##".
                UpperCamelCase   :  int						     =     [
                    F"""##{token}""" if idx != 0 else token for idx, token in enumerate(SCREAMING_SNAKE_CASE_	)
                ]
                self.assertListEqual(SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_	)
                self.assertListEqual(SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_	)








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	)	)



