





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

            '''simple docstring'''




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





       def snake_case__						(							self       :		Optional[Any]					)   ->					List[Any]:

            '''simple docstring'''




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

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

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

            _UpperCamelCase       =	self.get_config()

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





       def snake_case__						(							self       :		str					)   ->					Dict:

            '''simple docstring'''




            _UpperCamelCase       =	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 snake_case__						(							self       :		Union[str, Any]	,			lowerCAmelCase__       :		List[Any]	,			lowerCAmelCase__       :		Any	,			lowerCAmelCase__       :		List[str]	,			lowerCAmelCase__       :		Optional[int]	,			lowerCAmelCase__       :		str	,			lowerCAmelCase__       :		Optional[int]					)   ->					Optional[Any]:

            '''simple docstring'''




            _UpperCamelCase       =	EsmForProteinFolding(config=lowerCAmelCase__					).float()
            model.to(lowerCAmelCase__					)
            model.eval()
            _UpperCamelCase       =	model(lowerCAmelCase__	,			attention_mask=lowerCAmelCase__					)
            _UpperCamelCase       =	model(lowerCAmelCase__					)
            _UpperCamelCase       =	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 snake_case__						(							self       :		Dict					)   ->					Tuple:

            '''simple docstring'''




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

@require_torch
class     __lowerCAmelCase					(   __magic_name__						,						__magic_name__						,						unittest.TestCase			):






       """simple docstring"""
       _snake_case     :					Tuple						    =   False

       _snake_case     :					Optional[Any]						    =   (EsmForProteinFolding,) if is_torch_available() else ()
       _snake_case     :					List[str]						    =   ()
       _snake_case     :					List[str]						    =   {} if is_torch_available() else {}
       _snake_case     :					Dict						    =   False





       def snake_case__						(							self       :		List[str]					)   ->					Dict:

            '''simple docstring'''




            _UpperCamelCase       =	EsmFoldModelTester(self					)
            _UpperCamelCase       =	ConfigTester(self	,			config_class=lowerCAmelCase__	,			hidden_size=37					)





       def snake_case__						(							self       :		str					)   ->					int:

            '''simple docstring'''




            self.config_tester.run_common_tests()





       def snake_case__						(							self       :		List[Any]					)   ->					str:

            '''simple docstring'''




            _UpperCamelCase       =	self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_model(*lowerCAmelCase__					)





       @unittest.skip('''Does not support attention outputs'''					)
       def snake_case__						(							self       :		Dict					)   ->					str:

            '''simple docstring'''




            pass





       @unittest.skip
       def snake_case__						(							self       :		List[Any]					)   ->					str:

            '''simple docstring'''




            pass





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

            '''simple docstring'''




            pass





       @unittest.skip('''Esm does not support embedding resizing'''					)
       def snake_case__						(							self       :		Union[str, Any]					)   ->					Dict:

            '''simple docstring'''




            pass





       @unittest.skip('''ESMFold does not support passing input embeds!'''					)
       def snake_case__						(							self       :		Dict					)   ->					Optional[int]:

            '''simple docstring'''




            pass





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

            '''simple docstring'''




            pass





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

            '''simple docstring'''




            pass





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

            '''simple docstring'''




            pass





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

            '''simple docstring'''




            pass





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

            '''simple docstring'''




            pass





       @unittest.skip('''ESMFold does not output hidden states in the normal way.'''					)
       def snake_case__						(							self       :		Optional[int]					)   ->					List[str]:

            '''simple docstring'''




            pass





       @unittest.skip('''ESMfold does not output hidden states in the normal way.'''					)
       def snake_case__						(							self       :		Tuple					)   ->					Union[str, Any]:

            '''simple docstring'''




            pass





       @unittest.skip('''ESMFold only has one output format.'''					)
       def snake_case__						(							self       :		List[str]					)   ->					List[str]:

            '''simple docstring'''




            pass





       @unittest.skip('''This test doesn\'t work for ESMFold and doesn\'t test core functionality'''					)
       def snake_case__						(							self       :		Optional[int]					)   ->					Dict:

            '''simple docstring'''




            pass





       @unittest.skip('''ESMFold does not support input chunking.'''					)
       def snake_case__						(							self       :		List[str]					)   ->					Dict:

            '''simple docstring'''




            pass





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

            '''simple docstring'''




            pass





       @unittest.skip('''ESMFold doesn\'t support torchscript compilation.'''					)
       def snake_case__						(							self       :		Union[str, Any]					)   ->					Dict:

            '''simple docstring'''




            pass





       @unittest.skip('''ESMFold doesn\'t support torchscript compilation.'''					)
       def snake_case__						(							self       :		Union[str, Any]					)   ->					Optional[Any]:

            '''simple docstring'''




            pass





       @unittest.skip('''ESMFold doesn\'t support torchscript compilation.'''					)
       def snake_case__						(							self       :		Optional[int]					)   ->					Union[str, Any]:

            '''simple docstring'''




            pass





       @unittest.skip('''ESMFold doesn\'t support data parallel.'''					)
       def snake_case__						(							self       :		Optional[Any]					)   ->					Optional[Any]:

            '''simple docstring'''




            pass







       @unittest.skip('''Will be fixed soon by reducing the size of the model used for common tests.'''					)
       def snake_case__						(							self       :		Any					)   ->					str:

            '''simple docstring'''




            pass

@require_torch
class     __lowerCAmelCase					(   __magic_name__			):






       """simple docstring"""





       @slow
       def snake_case__						(							self       :		Dict					)   ->					int:

            '''simple docstring'''




            _UpperCamelCase       =	EsmForProteinFolding.from_pretrained('''facebook/esmfold_v1'''					).float()
            model.eval()
            _UpperCamelCase       =	torch.tensor([[0, 6, 4, 13, 5, 4, 16, 12, 11, 7, 2]]					)
            _UpperCamelCase       =	model(lowerCAmelCase__					)['''positions''']
            _UpperCamelCase       =	torch.tensor([2.5828, 0.7993, -10.9334]	,			dtype=torch.floataa					)
            self.assertTrue(torch.allclose(position_outputs[0, 0, 0, 0]	,			lowerCAmelCase__	,			atol=1e-4					)					)










'''simple docstring'''

import unittest

from transformers import CamembertTokenizer, CamembertTokenizerFast
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, slow
from transformers.utils import is_torch_available

from ...test_tokenization_common import TokenizerTesterMixin


lowercase__						:      Optional[Any]	=    get_tests_dir('fixtures/test_sentencepiece.model')
lowercase__						:      Any	=    get_tests_dir('fixtures/test_sentencepiece_bpe.model')

lowercase__						:      Tuple	=    'pt' if is_torch_available() else 'tf'
@require_sentencepiece
@require_tokenizers
class     __lowerCAmelCase					(   __magic_name__						,						unittest.TestCase			):






       """simple docstring"""
       _snake_case     :					Union[str, Any]						    =   CamembertTokenizer
       _snake_case     :					str						    =   CamembertTokenizerFast
       _snake_case     :					int						    =   True
       _snake_case     :					List[str]						    =   True





       def snake_case__						(							self       :		Dict					)   ->					Any:

            '''simple docstring'''




            super().setUp()

            # We have a SentencePiece fixture for testing
            _UpperCamelCase       =	CamembertTokenizer(lowerCAmelCase__					)
            tokenizer.save_pretrained(self.tmpdirname					)





       def snake_case__						(							self       :		Optional[int]					)   ->					List[Any]:

            '''simple docstring'''




            _UpperCamelCase       =	'''<pad>'''
            _UpperCamelCase       =	1

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





       def snake_case__						(							self       :		Dict					)   ->					List[Any]:

            '''simple docstring'''




            _UpperCamelCase       =	list(self.get_tokenizer().get_vocab().keys()					)

            self.assertEqual(vocab_keys[0]	,			'''<s>NOTUSED'''					)
            self.assertEqual(vocab_keys[1]	,			'''<pad>'''					)
            self.assertEqual(vocab_keys[-1]	,			'''<mask>'''					)
            self.assertEqual(len(lowerCAmelCase__					)	,			1004					)





       def snake_case__						(							self       :		Optional[Any]					)   ->					List[str]:

            '''simple docstring'''




            self.assertEqual(self.get_tokenizer().vocab_size	,			1005					)





       def snake_case__						(							self       :		int					)   ->					Tuple:

            '''simple docstring'''




            _UpperCamelCase       =	CamembertTokenizer(lowerCAmelCase__					)
            tokenizer.save_pretrained(self.tmpdirname					)
            _UpperCamelCase       =	CamembertTokenizerFast.from_pretrained(self.tmpdirname					)

            _UpperCamelCase       =	'''I was born in 92000, and this is falsé.'''

            _UpperCamelCase       =	tokenizer.encode(lowerCAmelCase__					)
            _UpperCamelCase       =	rust_tokenizer.encode(lowerCAmelCase__					)
            self.assertListEqual(lowerCAmelCase__	,			lowerCAmelCase__					)

            _UpperCamelCase       =	tokenizer.encode(lowerCAmelCase__	,			add_special_tokens=lowerCAmelCase__					)
            _UpperCamelCase       =	rust_tokenizer.encode(lowerCAmelCase__	,			add_special_tokens=lowerCAmelCase__					)
            self.assertListEqual(lowerCAmelCase__	,			lowerCAmelCase__					)

            # <unk> tokens are not the same for `rust` than for `slow`.
            # Because spm gives back raw token instead of `unk` in EncodeAsPieces
            # tokens = tokenizer.tokenize(sequence)
            _UpperCamelCase       =	tokenizer.convert_ids_to_tokens(lowerCAmelCase__					)
            _UpperCamelCase       =	rust_tokenizer.tokenize(lowerCAmelCase__					)
            self.assertListEqual(lowerCAmelCase__	,			lowerCAmelCase__					)





       def snake_case__						(							self       :		Optional[int]					)   ->					List[Any]:

            '''simple docstring'''




            if not self.test_rust_tokenizer:
                 return

            _UpperCamelCase       =	self.get_tokenizer()
            _UpperCamelCase       =	self.get_rust_tokenizer()

            _UpperCamelCase       =	'''I was born in 92000, and this is falsé.'''

            _UpperCamelCase       =	tokenizer.tokenize(lowerCAmelCase__					)
            _UpperCamelCase       =	rust_tokenizer.tokenize(lowerCAmelCase__					)
            self.assertListEqual(lowerCAmelCase__	,			lowerCAmelCase__					)

            _UpperCamelCase       =	tokenizer.encode(lowerCAmelCase__	,			add_special_tokens=lowerCAmelCase__					)
            _UpperCamelCase       =	rust_tokenizer.encode(lowerCAmelCase__	,			add_special_tokens=lowerCAmelCase__					)
            self.assertListEqual(lowerCAmelCase__	,			lowerCAmelCase__					)

            _UpperCamelCase       =	self.get_rust_tokenizer()
            _UpperCamelCase       =	tokenizer.encode(lowerCAmelCase__					)
            _UpperCamelCase       =	rust_tokenizer.encode(lowerCAmelCase__					)
            self.assertListEqual(lowerCAmelCase__	,			lowerCAmelCase__					)







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

            '''simple docstring'''




            _UpperCamelCase       =	{'''input_ids''': [[5, 54, 7196, 297, 30, 23, 776, 18, 11, 3215, 3705, 8252, 22, 3164, 1181, 2116, 29, 16, 813, 25, 791, 3314, 20, 3446, 38, 27575, 120, 6, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [5, 468, 17, 11, 9088, 20, 1517, 8, 22804, 18818, 10, 38, 629, 607, 607, 142, 19, 7196, 867, 56, 10326, 24, 2267, 20, 416, 5072, 15612, 233, 734, 7, 2399, 27, 16, 3015, 1649, 7, 24, 20, 4338, 2399, 27, 13, 3400, 14, 13, 6189, 8, 930, 9, 6]], '''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, 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, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]}  # noqa: E501
            # fmt: on

            # camembert is a french model. So we also use french texts.
            _UpperCamelCase       =	[
                '''Le transformeur est un modèle d\'apprentissage profond introduit en 2017, '''
                '''utilisé principalement dans le domaine du traitement automatique des langues (TAL).''',
                '''À l\'instar des réseaux de neurones récurrents (RNN), les transformeurs sont conçus '''
                '''pour gérer des données séquentielles, telles que le langage naturel, pour des tâches '''
                '''telles que la traduction et la synthèse de texte.''',
            ]

            self.tokenizer_integration_test_util(
                expected_encoding=lowerCAmelCase__	,			model_name='''camembert-base'''	,			revision='''3a0641d9a1aeb7e848a74299e7e4c4bca216b4cf'''	,			sequences=lowerCAmelCase__	,			)



