
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        lowerCAmelCase__      :

						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       ,							)					->      Optional[Any]:


								'''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  A_				(			self				)					->      Union[str, 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  A_				(			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  A_				(			self       ,							a       ,							a       ,							a       ,							a       ,							a       ,							a				)					->      List[str]:


								'''simple docstring'''

								_UpperCamelCase						    =	EsmModel(config=a				)
								model.to(a				)
								model.eval()
								_UpperCamelCase						    =	model(a       ,							attention_mask=a				)
								_UpperCamelCase						    =	model(a				)
								_UpperCamelCase						    =	model(a				)

								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  A_				(			self       ,							a       ,							a       ,							a       ,							a       ,							a       ,							a				)					->      Optional[Any]:


								'''simple docstring'''

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

						def  A_				(			self       ,							a       ,							a       ,							a       ,							a       ,							a       ,							a				)					->      Dict:


								'''simple docstring'''

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







						def  A_				(			self				)					->      Optional[int]:


								'''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__      (   __lowercase		,	__lowercase		,	unittest.TestCase	):
						UpperCamelCase_							: str	=		False

						UpperCamelCase_							: str	=		(
						    (
						        EsmForMaskedLM,
						        EsmModel,
						        EsmForSequenceClassification,
						        EsmForTokenClassification,
						    )
						    if is_torch_available()
						    else ()
						)
						UpperCamelCase_							: Optional[int]	=		()
						UpperCamelCase_							: List[Any]	=		(
						    {
						        "feature-extraction": EsmModel,
						        "fill-mask": EsmForMaskedLM,
						        "text-classification": EsmForSequenceClassification,
						        "token-classification": EsmForTokenClassification,
						        "zero-shot": EsmForSequenceClassification,
						    }
						    if is_torch_available()
						    else {}
						)
						UpperCamelCase_							: Union[str, Any]	=		True

						def  A_				(			self				)					->      Dict:


								'''simple docstring'''

								_UpperCamelCase						    =	EsmModelTester(self				)
								_UpperCamelCase						    =	ConfigTester(self       ,							config_class=a       ,							hidden_size=37				)

						def  A_				(			self				)					->      List[Any]:


								'''simple docstring'''

								self.config_tester.run_common_tests()

						def  A_				(			self				)					->      Optional[int]:


								'''simple docstring'''

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

						def  A_				(			self				)					->      str:


								'''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(*a				)

						def  A_				(			self				)					->      str:


								'''simple docstring'''

								_UpperCamelCase						    =	self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_masked_lm(*a				)

						def  A_				(			self				)					->      Dict:


								'''simple docstring'''

								_UpperCamelCase						    =	self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_token_classification(*a				)

						@slow
						def  A_				(			self				)					->      Tuple:


								'''simple docstring'''

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

						def  A_				(			self				)					->      Dict:


								'''simple docstring'''

								_UpperCamelCase						    =	self.model_tester.prepare_config_and_inputs()[0]
								_UpperCamelCase						    =	EsmEmbeddings(config=a				)

								_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(a       ,							model.padding_idx				)
								self.assertEqual(position_ids.shape       ,							expected_positions.shape				)
								self.assertTrue(torch.all(torch.eq(a       ,							a				)				)				)

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


								'''simple docstring'''

								_UpperCamelCase						    =	self.model_tester.prepare_config_and_inputs()[0]
								_UpperCamelCase						    =	EsmEmbeddings(config=a				)

								_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(a				)
								self.assertEqual(position_ids.shape       ,							expected_positions.shape				)
								self.assertTrue(torch.all(torch.eq(a       ,							a				)				)				)

						@unittest.skip("""Esm does not support embedding resizing"""				)
						def  A_				(			self				)					->      int:


								'''simple docstring'''

								pass

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


								'''simple docstring'''

								pass







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


								'''simple docstring'''

								pass







@require_torch
class        lowerCAmelCase__      (   __lowercase	):

						@slow
						def  A_				(			self				)					->      Tuple:


								'''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(a				)[0]

										_UpperCamelCase						    =	33

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

										_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]       ,							a       ,							atol=1e-4				)				)







						@slow
						def  A_				(			self				)					->      str:


								'''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(a				)[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]       ,							a       ,							atol=1e-4				)				)





from typing import TYPE_CHECKING

from ....utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


lowerCamelCase__	=							{
    "configuration_mctct": ["MCTCT_PRETRAINED_CONFIG_ARCHIVE_MAP", "MCTCTConfig"],
    "feature_extraction_mctct": ["MCTCTFeatureExtractor"],
    "processing_mctct": ["MCTCTProcessor"],
}


try:
		if not is_torch_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		lowerCamelCase__	=							[
		    "MCTCT_PRETRAINED_MODEL_ARCHIVE_LIST",
		    "MCTCTForCTC",
		    "MCTCTModel",
		    "MCTCTPreTrainedModel",
		]


if TYPE_CHECKING:
		from .configuration_mctct import MCTCT_PRETRAINED_CONFIG_ARCHIVE_MAP, MCTCTConfig
		from .feature_extraction_mctct import MCTCTFeatureExtractor
		from .processing_mctct import MCTCTProcessor

		try:
				if not is_torch_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_mctct import MCTCT_PRETRAINED_MODEL_ARCHIVE_LIST, MCTCTForCTC, MCTCTModel, MCTCTPreTrainedModel

else:
		import sys

		lowerCamelCase__	=							_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)



