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=13			,			__lowercase=7			,			__lowercase=False			,			__lowercase=True			,			__lowercase=False			,			__lowercase=False			,			__lowercase=19			,			__lowercase=32			,			__lowercase=5			,			__lowercase=4			,			__lowercase=37			,			__lowercase="gelu"			,			__lowercase=0.1			,			__lowercase=0.1			,			__lowercase=512			,			__lowercase=16			,			__lowercase=2			,			__lowercase=0.02			,			__lowercase=3			,			__lowercase=4			,			__lowercase=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       UpperCamelCase__       (     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       UpperCamelCase__       (     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       UpperCamelCase__       (     self			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase			,			__lowercase)	->     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       UpperCamelCase__       (     self)	->     Optional[int]:
        __UpperCamelCase					:Union[str, Any]        =		self.prepare_config_and_inputs()
        (
            __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			):






    '''simple docstring'''






    a__     :						Dict      =				False

    a__     :						Optional[int]      =				(EsmForProteinFolding,) if is_torch_available() else ()
    a__     :						int      =				()
    a__     :						List[str]      =				{} if is_torch_available() else {}
    a__     :						Optional[int]      =				False







    def       UpperCamelCase__       (     self)	->     Dict:
        __UpperCamelCase					:Tuple        =		EsmFoldModelTester(self)
        __UpperCamelCase					:List[str]        =		ConfigTester(self			,			config_class=SCREAMING_SNAKE_CASE_			,			hidden_size=37)







    def       UpperCamelCase__       (     self)	->     int:
        self.config_tester.run_common_tests()







    def       UpperCamelCase__       (     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       UpperCamelCase__       (     self)	->     Tuple:
        pass







    @unittest.skip
    def       UpperCamelCase__       (     self)	->     List[Any]:
        pass







    @unittest.skip('''Esm does not support embedding resizing''')
    def       UpperCamelCase__       (     self)	->     Any:
        pass







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







    @unittest.skip('''ESMFold does not support passing input embeds!''')
    def       UpperCamelCase__       (     self)	->     Optional[Any]:
        pass







    @unittest.skip('''ESMFold does not support head pruning.''')
    def       UpperCamelCase__       (     self)	->     Any:
        pass







    @unittest.skip('''ESMFold does not support head pruning.''')
    def       UpperCamelCase__       (     self)	->     int:
        pass







    @unittest.skip('''ESMFold does not support head pruning.''')
    def       UpperCamelCase__       (     self)	->     Dict:
        pass







    @unittest.skip('''ESMFold does not support head pruning.''')
    def       UpperCamelCase__       (     self)	->     Union[str, Any]:
        pass







    @unittest.skip('''ESMFold does not support head pruning.''')
    def       UpperCamelCase__       (     self)	->     Any:
        pass







    @unittest.skip('''ESMFold does not output hidden states in the normal way.''')
    def       UpperCamelCase__       (     self)	->     str:
        pass







    @unittest.skip('''ESMfold does not output hidden states in the normal way.''')
    def       UpperCamelCase__       (     self)	->     List[str]:
        pass







    @unittest.skip('''ESMFold only has one output format.''')
    def       UpperCamelCase__       (     self)	->     int:
        pass







    @unittest.skip('''This test doesn\'t work for ESMFold and doesn\'t test core functionality''')
    def       UpperCamelCase__       (     self)	->     Any:
        pass







    @unittest.skip('''ESMFold does not support input chunking.''')
    def       UpperCamelCase__       (     self)	->     Any:
        pass







    @unittest.skip('''ESMFold doesn\'t respect you and it certainly doesn\'t respect your initialization arguments.''')
    def       UpperCamelCase__       (     self)	->     Tuple:
        pass







    @unittest.skip('''ESMFold doesn\'t support torchscript compilation.''')
    def       UpperCamelCase__       (     self)	->     Any:
        pass







    @unittest.skip('''ESMFold doesn\'t support torchscript compilation.''')
    def       UpperCamelCase__       (     self)	->     str:
        pass







    @unittest.skip('''ESMFold doesn\'t support torchscript compilation.''')
    def       UpperCamelCase__       (     self)	->     List[Any]:
        pass







    @unittest.skip('''ESMFold doesn\'t support data parallel.''')
    def       UpperCamelCase__       (     self)	->     List[str]:
        pass







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


@require_torch
class      lowerCamelCase_					(       a__			):






    '''simple docstring'''






    @slow
    def       UpperCamelCase__       (     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))



import unittest

from transformers import BertGenerationTokenizer
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_torch, slow
from transformers.utils import cached_property

from ...test_tokenization_common import TokenizerTesterMixin


__lowercase										= '''▁'''

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


@require_sentencepiece
class      lowerCamelCase_					(       UpperCAmelCase_						,     unittest.TestCase			):






    '''simple docstring'''






    a__     :						int      =				BertGenerationTokenizer
    a__     :						Dict      =				False
    a__     :						str      =				True







    def       UpperCamelCase__       (     self)	->     List[str]:
        super().setUp()

        __UpperCamelCase					:Optional[Any]        =		BertGenerationTokenizer(__lowercase			,			keep_accents=__lowercase)
        tokenizer.save_pretrained(self.tmpdirname)







    def       UpperCamelCase__       (     self)	->     int:
        __UpperCamelCase					:Dict        =		'''<s>'''
        __UpperCamelCase					:Dict        =		1

        self.assertEqual(self.get_tokenizer()._convert_token_to_id(__lowercase)			,			__lowercase)
        self.assertEqual(self.get_tokenizer()._convert_id_to_token(__lowercase)			,			__lowercase)







    def       UpperCamelCase__       (     self)	->     Optional[int]:
        __UpperCamelCase					:Optional[Any]        =		list(self.get_tokenizer().get_vocab().keys())

        self.assertEqual(vocab_keys[0]			,			'''<unk>''')
        self.assertEqual(vocab_keys[1]			,			'''<s>''')
        self.assertEqual(vocab_keys[-1]			,			'''<pad>''')
        self.assertEqual(len(__lowercase)			,			1_002)







    def       UpperCamelCase__       (     self)	->     Dict:
        self.assertEqual(self.get_tokenizer().vocab_size			,			1_000)







    def       UpperCamelCase__       (     self)	->     Optional[Any]:
        __UpperCamelCase					:str        =		BertGenerationTokenizer(__lowercase			,			keep_accents=__lowercase)

        __UpperCamelCase					:Optional[Any]        =		tokenizer.tokenize('''This is a test''')
        self.assertListEqual(__lowercase			,			['''▁This''', '''▁is''', '''▁a''', '''▁t''', '''est'''])

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

        __UpperCamelCase					:List[Any]        =		tokenizer.tokenize('''I was born in 92000, and this is falsé.''')
        self.assertListEqual(
            __lowercase			,			[
                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					:Any        =		tokenizer.convert_tokens_to_ids(__lowercase)
        self.assertListEqual(
            __lowercase			,			[8, 21, 84, 55, 24, 19, 7, 0, 602, 347, 347, 347, 3, 12, 66, 46, 72, 80, 6, 0, 4]			,			)

        __UpperCamelCase					:Tuple        =		tokenizer.convert_ids_to_tokens(__lowercase)
        self.assertListEqual(
            __lowercase			,			[
                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>''',
                '''.''',
            ]			,			)







    @cached_property
    def       UpperCamelCase__       (     self)	->     int:
        return BertGenerationTokenizer.from_pretrained('''google/bert_for_seq_generation_L-24_bbc_encoder''')







    @slow
    def       UpperCamelCase__       (     self)	->     List[str]:
        __UpperCamelCase					:Optional[Any]        =		'''Hello World!'''
        __UpperCamelCase					:Optional[int]        =		[18_536, 2_260, 101]

        self.assertListEqual(__lowercase			,			self.big_tokenizer.encode(__lowercase))







    @slow
    def       UpperCamelCase__       (     self)	->     List[str]:
        __UpperCamelCase					:Optional[Any]        =		(
            '''This is a very long text with a lot of weird characters, such as: . , ~ ? ( ) " [ ] ! : - . Also we will'''
            ''' add words that should not exsist and be tokenized to <unk>, such as saoneuhaoesuth'''
        )
        __UpperCamelCase					:Union[str, Any]        =		[
            871,
            419,
            358,
            946,
            991,
            2_521,
            452,
            358,
            1_357,
            387,
            7_751,
            3_536,
            112,
            985,
            456,
            126,
            865,
            938,
            5_400,
            5_734,
            458,
            1_368,
            467,
            786,
            2_462,
            5_246,
            1_159,
            633,
            865,
            4_519,
            457,
            582,
            852,
            2_557,
            427,
            916,
            508,
            405,
            34_324,
            497,
            391,
            408,
            11_342,
            1_244,
            385,
            100,
            938,
            985,
            456,
            574,
            362,
            12_597,
            3_200,
            3_129,
            1_172,
        ]

        self.assertListEqual(__lowercase			,			self.big_tokenizer.encode(__lowercase))







    @require_torch
    @slow
    def       UpperCamelCase__       (     self)	->     Optional[int]:
        import torch

        from transformers import BertGenerationConfig, BertGenerationEncoder

        # Build sequence
        __UpperCamelCase					:Optional[Any]        =		list(self.big_tokenizer.get_vocab().keys())[:10]
        __UpperCamelCase					:Optional[int]        =		''' '''.join(__lowercase)
        __UpperCamelCase					:Optional[int]        =		self.big_tokenizer.encode_plus(__lowercase			,			return_tensors='''pt'''			,			return_token_type_ids=__lowercase)
        __UpperCamelCase					:List[str]        =		self.big_tokenizer.batch_encode_plus(
            [sequence + ''' ''' + sequence]			,			return_tensors='''pt'''			,			return_token_type_ids=__lowercase)

        __UpperCamelCase					:List[Any]        =		BertGenerationConfig()
        __UpperCamelCase					:Optional[Any]        =		BertGenerationEncoder(__lowercase)

        assert model.get_input_embeddings().weight.shape[0] >= self.big_tokenizer.vocab_size

        with torch.no_grad():
            model(**__lowercase)
            model(**__lowercase)







    @slow
    def       UpperCamelCase__       (     self)	->     Dict:
        # fmt: off
        __UpperCamelCase					:List[str]        =		{'''input_ids''': [[39_286, 458, 36_335, 2_001, 456, 13_073, 13_266, 455, 113, 7_746, 1_741, 11_157, 391, 13_073, 13_266, 455, 113, 3_967, 35_412, 113, 4_936, 109, 3_870, 2_377, 113, 30_084, 45_720, 458, 134, 17_496, 112, 503, 11_672, 113, 118, 112, 5_665, 13_347, 38_687, 112, 1_496, 31_389, 112, 3_268, 47_264, 134, 962, 112, 16_377, 8_035, 23_130, 430, 12_169, 15_518, 28_592, 458, 146, 41_697, 109, 391, 12_169, 15_518, 16_689, 458, 146, 41_358, 109, 452, 726, 4_034, 111, 763, 35_412, 5_082, 388, 1_903, 111, 9_051, 391, 2_870, 48_918, 1_900, 1_123, 550, 998, 112, 9_586, 15_985, 455, 391, 410, 22_955, 37_636, 114], [448, 17_496, 419, 3_663, 385, 763, 113, 27_533, 2_870, 3_283, 13_043, 1_639, 24_713, 523, 656, 24_013, 18_550, 2_521, 517, 27_014, 21_244, 420, 1_212, 1_465, 391, 927, 4_833, 388, 578, 11_786, 114, 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], [484, 2_169, 7_687, 21_932, 18_146, 726, 363, 17_032, 3_391, 114, 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]], '''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, 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], [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]]}  # noqa: E501
        # fmt: on

        self.tokenizer_integration_test_util(
            expected_encoding=__lowercase			,			model_name='''google/bert_for_seq_generation_L-24_bbc_encoder'''			,			revision='''c817d1fd1be2ffa69431227a1fe320544943d4db'''			,			)





