
"""simple docstring"""





import unittest

from transformers import EsmConfig, is_torch_available
from transformers.testing_utils import TestCasePlus, require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
				import torch

				from transformers import EsmForMaskedLM, EsmForSequenceClassification, EsmForTokenClassification, EsmModel
				from transformers.models.esm.modeling_esm import (
				    ESM_PRETRAINED_MODEL_ARCHIVE_LIST,
				    EsmEmbeddings,
				    create_position_ids_from_input_ids,
				)






class     _UpperCAmelCase:



		def __init__(					self				,		__a				,		__a=13				,		__a=7				,		__a=False				,		__a=True				,		__a=False				,		__a=True				,		__a=33				,		__a=32				,		__a=5				,		__a=4				,		__a=37				,		__a="gelu"				,		__a=0.1				,		__a=0.1				,		__a=5_12				,		__a=16				,		__a=2				,		__a=0.02				,		__a=3				,		__a=4				,		__a=None				,		)       ->       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 						UpperCAmelCase							(					self)       ->       Optional[int]:






							'''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 						UpperCAmelCase							(					self)       ->       Dict:






							'''simple docstring'''
							return EsmConfig(
							    vocab_size=self.vocab_size				,		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				,		)



		def 						UpperCAmelCase							(					self				,		__a				,		__a				,		__a				,		__a				,		__a				,		__a)       ->       Union[str, Any]:






							'''simple docstring'''
							_UpperCamelCase							 =  EsmModel(config=lowercase_)
							model.to(lowercase_)
							model.eval()
							_UpperCamelCase							 =  model(lowercase_				,		attention_mask=lowercase_)
							_UpperCamelCase							 =  model(lowercase_)
							_UpperCamelCase							 =  model(lowercase_)

							self.parent.assertEqual(result.last_hidden_state.shape				,		(self.batch_size, self.seq_length, self.hidden_size))
							self.parent.assertEqual(result.pooler_output.shape				,		(self.batch_size, self.hidden_size))



		def 						UpperCAmelCase							(					self				,		__a				,		__a				,		__a				,		__a				,		__a				,		__a)       ->       Dict:






							'''simple docstring'''
							_UpperCamelCase							 =  EsmForMaskedLM(config=lowercase_)
							model.to(lowercase_)
							model.eval()
							_UpperCamelCase							 =  model(lowercase_				,		attention_mask=lowercase_				,		labels=lowercase_)
							self.parent.assertEqual(result.logits.shape				,		(self.batch_size, self.seq_length, self.vocab_size))



		def 						UpperCAmelCase							(					self				,		__a				,		__a				,		__a				,		__a				,		__a				,		__a)       ->       Dict:






							'''simple docstring'''
							_UpperCamelCase							 =  self.num_labels
							_UpperCamelCase							 =  EsmForTokenClassification(config=lowercase_)
							model.to(lowercase_)
							model.eval()
							_UpperCamelCase							 =  model(lowercase_				,		attention_mask=lowercase_				,		labels=lowercase_)
							self.parent.assertEqual(result.logits.shape				,		(self.batch_size, self.seq_length, self.num_labels))




		def 						UpperCAmelCase							(					self)       ->       Union[str, Any]:






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






@require_torch
class     _UpperCAmelCase(    UpperCamelCase_      ,     UpperCamelCase_      ,     unittest.TestCase	):
		lowercase__						=      False

		lowercase__						=      (
		    (
		        EsmForMaskedLM,
		        EsmModel,
		        EsmForSequenceClassification,
		        EsmForTokenClassification,
		    )
		    if is_torch_available()
		    else ()
		)
		lowercase__						=      ()
		lowercase__						=      (
		    {
		        'feature-extraction': EsmModel,
		        'fill-mask': EsmForMaskedLM,
		        'text-classification': EsmForSequenceClassification,
		        'token-classification': EsmForTokenClassification,
		        'zero-shot': EsmForSequenceClassification,
		    }
		    if is_torch_available()
		    else {}
		)
		lowercase__						=      True



		def 						UpperCAmelCase							(					self)       ->       Any:






							'''simple docstring'''
							_UpperCamelCase							 =  EsmModelTester(self)
							_UpperCamelCase							 =  ConfigTester(self				,		config_class=lowercase_				,		hidden_size=37)



		def 						UpperCAmelCase							(					self)       ->       Union[str, Any]:






							'''simple docstring'''
							self.config_tester.run_common_tests()



		def 						UpperCAmelCase							(					self)       ->       Dict:






							'''simple docstring'''
							_UpperCamelCase							 =  self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*lowercase_)



		def 						UpperCAmelCase							(					self)       ->       Tuple:






							'''simple docstring'''
							_UpperCamelCase							 =  self.model_tester.prepare_config_and_inputs()
							for type in ["absolute", "relative_key", "relative_key_query"]:
												_UpperCamelCase							 =  type
												self.model_tester.create_and_check_model(*lowercase_)



		def 						UpperCAmelCase							(					self)       ->       Tuple:






							'''simple docstring'''
							_UpperCamelCase							 =  self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_masked_lm(*lowercase_)



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






							'''simple docstring'''
							_UpperCamelCase							 =  self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_token_classification(*lowercase_)



		@slow
		def 						UpperCAmelCase							(					self)       ->       str:






							'''simple docstring'''




							for model_name in ESM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
												_UpperCamelCase							 =  EsmModel.from_pretrained(lowercase_)
												self.assertIsNotNone(lowercase_)



		def 						UpperCAmelCase							(					self)       ->       str:






							'''simple docstring'''
							_UpperCamelCase							 =  self.model_tester.prepare_config_and_inputs()[0]
							_UpperCamelCase							 =  EsmEmbeddings(config=lowercase_)

							_UpperCamelCase							 =  torch.as_tensor([[12, 31, 13, model.padding_idx]])
							_UpperCamelCase							 =  torch.as_tensor(
							    [
							        [
							            0 + model.padding_idx + 1,
							            1 + model.padding_idx + 1,
							            2 + model.padding_idx + 1,
							            model.padding_idx,
							        ]
							    ])
							_UpperCamelCase							 =  create_position_ids_from_input_ids(lowercase_				,		model.padding_idx)
							self.assertEqual(position_ids.shape				,		expected_positions.shape)
							self.assertTrue(torch.all(torch.eq(lowercase_				,		lowercase_)))



		def 						UpperCAmelCase							(					self)       ->       Any:






							'''simple docstring'''
							_UpperCamelCase							 =  self.model_tester.prepare_config_and_inputs()[0]
							_UpperCamelCase							 =  EsmEmbeddings(config=lowercase_)

							_UpperCamelCase							 =  torch.empty(2				,		4				,		30)
							_UpperCamelCase							 =  [
							    0 + embeddings.padding_idx + 1,
							    1 + embeddings.padding_idx + 1,
							    2 + embeddings.padding_idx + 1,
							    3 + embeddings.padding_idx + 1,
							]
							_UpperCamelCase							 =  torch.as_tensor([expected_single_positions, expected_single_positions])
							_UpperCamelCase							 =  embeddings.create_position_ids_from_inputs_embeds(lowercase_)
							self.assertEqual(position_ids.shape				,		expected_positions.shape)
							self.assertTrue(torch.all(torch.eq(lowercase_				,		lowercase_)))



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






							'''simple docstring'''
							pass



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






							'''simple docstring'''
							pass




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






							'''simple docstring'''
							pass






@require_torch
class     _UpperCAmelCase(    UpperCamelCase_	):



		@slow
		def 						UpperCAmelCase							(					self)       ->       List[str]:






							'''simple docstring'''




							with torch.no_grad():
												_UpperCamelCase							 =  EsmForMaskedLM.from_pretrained('''facebook/esm2_t6_8M_UR50D''')
												model.eval()
												_UpperCamelCase							 =  torch.tensor([[0, 1, 2, 3, 4, 5]])
												_UpperCamelCase							 =  model(lowercase_)[0]

												_UpperCamelCase							 =  33

												_UpperCamelCase							 =  torch.Size((1, 6, vocab_size))
												self.assertEqual(output.shape				,		lowercase_)

												_UpperCamelCase							 =  torch.tensor(
												    [[[8.9215, -10.5898, -6.4671], [-6.3967, -13.9114, -1.1212], [-7.7812, -13.9516, -3.7406]]])
												self.assertTrue(torch.allclose(output[:, :3, :3]				,		lowercase_				,		atol=1e-4))




		@slow
		def 						UpperCAmelCase							(					self)       ->       Dict:






							'''simple docstring'''




							with torch.no_grad():
												_UpperCamelCase							 =  EsmModel.from_pretrained('''facebook/esm2_t6_8M_UR50D''')
												model.eval()

												_UpperCamelCase							 =  torch.tensor([[0, 6, 4, 13, 5, 4, 16, 12, 11, 7, 2]])
												_UpperCamelCase							 =  model(lowercase_)[0]
												# compare the actual values for a slice.
												_UpperCamelCase							 =  torch.tensor(
												    [[[0.1444, 0.5413, 0.3248], [0.3034, 0.0053, 0.3108], [0.3228, -0.2499, 0.3415]]])
												self.assertTrue(torch.allclose(output[:, :3, :3]				,		lowercase_				,		atol=1e-4))










import os
import sys
from contextlib import contextmanager


# Windows only
if os.name == "nt":
 import ctypes
 import msvcrt  # noqa




 class A  (   ctypes.Structure     ):
       # _fields is a specific attr expected by ctypes
       UpperCamelCase__							:  List[Any]      =[('size', ctypes.c_int), ('visible', ctypes.c_byte)]




def 	a_      (    ):
       '''simple docstring'''





       if os.name == "nt":
              _lowerCamelCase       :		Optional[Any]		=CursorInfo()
              _lowerCamelCase       :		Dict		=ctypes.windll.kernelaa.GetStdHandle(-11     )
              ctypes.windll.kernelaa.GetConsoleCursorInfo(SCREAMING_SNAKE_CASE__		,			ctypes.byref(SCREAMING_SNAKE_CASE__     )     )
              _lowerCamelCase       :		Any		=False
              ctypes.windll.kernelaa.SetConsoleCursorInfo(SCREAMING_SNAKE_CASE__		,			ctypes.byref(SCREAMING_SNAKE_CASE__     )     )
       elif os.name == "posix":
              sys.stdout.write('\033[?25l'     )
              sys.stdout.flush()




def 	a_      (    ):
       '''simple docstring'''





       if os.name == "nt":
              _lowerCamelCase       :		Any		=CursorInfo()
              _lowerCamelCase       :		Optional[Any]		=ctypes.windll.kernelaa.GetStdHandle(-11     )
              ctypes.windll.kernelaa.GetConsoleCursorInfo(SCREAMING_SNAKE_CASE__		,			ctypes.byref(SCREAMING_SNAKE_CASE__     )     )
              _lowerCamelCase       :		Union[str, Any]		=True
              ctypes.windll.kernelaa.SetConsoleCursorInfo(SCREAMING_SNAKE_CASE__		,			ctypes.byref(SCREAMING_SNAKE_CASE__     )     )
       elif os.name == "posix":
              sys.stdout.write('\033[?25h'     )
              sys.stdout.flush()




@contextmanager
def 	a_      (    ):
       '''simple docstring'''





       try:
              hide_cursor()
              yield
       finally:
              show_cursor()


