from __future__ import annotations

import unittest

from transformers import EsmConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
	import numpy
	import tensorflow as tf

	from transformers.models.esm.modeling_tf_esm import (
	    TF_ESM_PRETRAINED_MODEL_ARCHIVE_LIST,
	    TFEsmForMaskedLM,
	    TFEsmForSequenceClassification,
	    TFEsmForTokenClassification,
	    TFEsmModel,
	)


class 						a__							:



			def __init__(						self				,						UpperCAmelCase				,						)			->   List[str]:
								__a		 =       parent
								__a		 =       1_3
								__a		 =       7
								__a		 =       True
								__a		 =       True
								__a		 =       True
								__a		 =       9_9
								__a		 =       3_2
								__a		 =       2
								__a		 =       4
								__a		 =       3_7
								__a		 =       'gelu'
								__a		 =       0.1
								__a		 =       0.1
								__a		 =       5_1_2
								__a		 =       1_6
								__a		 =       2
								__a		 =       0.02
								__a		 =       3
								__a		 =       4
								__a		 =       None



			def __SCREAMING_SNAKE_CASE							(						self   )			->   Optional[int]:
								__a		 =       ids_tensor([self.batch_size, self.seq_length]				,						self.vocab_size   )

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

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

								__a		 =       EsmConfig(
								    vocab_size=self.vocab_size				,						hidden_size=self.hidden_size				,						num_hidden_layers=self.num_hidden_layers				,						pad_token_id=1				,						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				,						)

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



			def __SCREAMING_SNAKE_CASE							(						self   )			->   Tuple:
								(
								    (
								    __a
								) ,				(
								    __a
								) ,				(
								    __a
								) ,				(
								    __a
								) ,				(
								    __a
								) ,				(
								    __a
								) ,				
								)		 =       self.prepare_config_and_inputs()

								__a		 =       True
								__a		 =       floats_tensor([self.batch_size, self.seq_length, self.hidden_size]   )
								__a		 =       ids_tensor([self.batch_size, self.seq_length]				,						vocab_size=2   )

								return (
								    config,
								    input_ids,
								    input_mask,
								    sequence_labels,
								    token_labels,
								    choice_labels,
								    encoder_hidden_states,
								    encoder_attention_mask,
								)



			def __SCREAMING_SNAKE_CASE							(						self				,						UpperCAmelCase				,						UpperCAmelCase				,						UpperCAmelCase				,						UpperCAmelCase				,						UpperCAmelCase				,						UpperCAmelCase   )			->   Tuple:
								__a		 =       TFEsmModel(config=UpperCAmelCase   )
								__a		 =       {'input_ids': input_ids, 'attention_mask': input_mask}
								__a		 =       model(UpperCAmelCase   )

								__a		 =       [input_ids, input_mask]
								__a		 =       model(UpperCAmelCase   )

								__a		 =       model(UpperCAmelCase   )

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



			def __SCREAMING_SNAKE_CASE							(						self				,						UpperCAmelCase				,						UpperCAmelCase				,						UpperCAmelCase				,						UpperCAmelCase				,						UpperCAmelCase				,						UpperCAmelCase				,						UpperCAmelCase				,						UpperCAmelCase				,						)			->   Tuple:
								__a		 =       True

								__a		 =       TFEsmModel(config=UpperCAmelCase   )
								__a		 =       {
								    'input_ids': input_ids,
								    'attention_mask': input_mask,
								    'encoder_hidden_states': encoder_hidden_states,
								    'encoder_attention_mask': encoder_attention_mask,
								}
								__a		 =       model(UpperCAmelCase   )

								__a		 =       [input_ids, input_mask]
								__a		 =       model(UpperCAmelCase				,						encoder_hidden_states=UpperCAmelCase   )

								# Also check the case where encoder outputs are not passed
								__a		 =       model(UpperCAmelCase				,						attention_mask=UpperCAmelCase   )

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



			def __SCREAMING_SNAKE_CASE							(						self				,						UpperCAmelCase				,						UpperCAmelCase				,						UpperCAmelCase				,						UpperCAmelCase				,						UpperCAmelCase				,						UpperCAmelCase   )			->   Optional[Any]:
								__a		 =       TFEsmForMaskedLM(config=UpperCAmelCase   )
								__a		 =       model([input_ids, input_mask]   )
								self.parent.assertEqual(result.logits.shape				,						(self.batch_size, self.seq_length, self.vocab_size)   )



			def __SCREAMING_SNAKE_CASE							(						self				,						UpperCAmelCase				,						UpperCAmelCase				,						UpperCAmelCase				,						UpperCAmelCase				,						UpperCAmelCase				,						UpperCAmelCase   )			->   Union[str, Any]:
								__a		 =       self.num_labels
								__a		 =       TFEsmForTokenClassification(config=UpperCAmelCase   )
								__a		 =       {'input_ids': input_ids, 'attention_mask': input_mask}
								__a		 =       model(UpperCAmelCase   )
								self.parent.assertEqual(result.logits.shape				,						(self.batch_size, self.seq_length, self.num_labels)   )







			def __SCREAMING_SNAKE_CASE							(						self   )			->   int:
								__a		 =       self.prepare_config_and_inputs()
								(
								    (
								    __a
								) ,				(
								    __a
								) ,				(
								    __a
								) ,				(
								    __a
								) ,				(
								    __a
								) ,				(
								    __a
								) ,				
								)		 =       config_and_inputs
								__a		 =       {'input_ids': input_ids, 'attention_mask': input_mask}
								return config, inputs_dict






@require_tf
class 						a__							(       __snake_case				,						__snake_case				,						unittest.TestCase		):
			A__    :       Optional[Any]        =      (
			    (
			        TFEsmModel,
			        TFEsmForMaskedLM,
			        TFEsmForSequenceClassification,
			        TFEsmForTokenClassification,
			    )
			    if is_tf_available()
			    else ()
			)
			A__    :       Tuple        =      (
			    {
			        'feature-extraction': TFEsmModel,
			        'fill-mask': TFEsmForMaskedLM,
			        'text-classification': TFEsmForSequenceClassification,
			        'token-classification': TFEsmForTokenClassification,
			        'zero-shot': TFEsmForSequenceClassification,
			    }
			    if is_tf_available()
			    else {}
			)
			A__    :       Union[str, Any]        =      False
			A__    :       List[str]        =      False



			def __SCREAMING_SNAKE_CASE							(						self   )			->   Union[str, Any]:
								__a		 =       TFEsmModelTester(self   )
								__a		 =       ConfigTester(self				,						config_class=UpperCAmelCase				,						hidden_size=3_7   )



			def __SCREAMING_SNAKE_CASE							(						self   )			->   Dict:
								self.config_tester.run_common_tests()



			def __SCREAMING_SNAKE_CASE							(						self   )			->   Union[str, Any]:
								__a		 =       self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*UpperCAmelCase   )



			def __SCREAMING_SNAKE_CASE							(						self   )			->   List[Any]:
								__a		 =       self.model_tester.prepare_config_and_inputs_for_decoder()
								self.model_tester.create_and_check_model_as_decoder(*UpperCAmelCase   )



			def __SCREAMING_SNAKE_CASE							(						self   )			->   Optional[Any]:
								__a		 =       self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_masked_lm(*UpperCAmelCase   )



			def __SCREAMING_SNAKE_CASE							(						self   )			->   Optional[Any]:
								__a		 =       self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_token_classification(*UpperCAmelCase   )



			@slow
			def __SCREAMING_SNAKE_CASE							(						self   )			->   Union[str, Any]:
								for model_name in TF_ESM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
													__a		 =       TFEsmModel.from_pretrained(UpperCAmelCase   )
													self.assertIsNotNone(UpperCAmelCase   )



			@unittest.skip('Protein models do not support embedding resizing.'   )
			def __SCREAMING_SNAKE_CASE							(						self   )			->   int:
								pass



			@unittest.skip('Protein models do not support embedding resizing.'   )
			def __SCREAMING_SNAKE_CASE							(						self   )			->   Dict:
								pass







			def __SCREAMING_SNAKE_CASE							(						self   )			->   List[Any]:
								__a ,				__a		 =       self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
													__a		 =       model_class(UpperCAmelCase   )
													assert isinstance(model.get_input_embeddings()				,						tf.keras.layers.Layer   )
													if model_class is TFEsmForMaskedLM:
																		# Output embedding test differs from the main test because they're a matrix, not a layer
																		__a		 =       model.get_bias()
																		assert isinstance(UpperCAmelCase				,						UpperCAmelCase   )
																		for k, v in name.items():
																							assert isinstance(UpperCAmelCase				,						tf.Variable   )
													else:
																		__a		 =       model.get_output_embeddings()
																		assert x is None
																		__a		 =       model.get_bias()
																		assert name is None






@require_tf
class 						a__							(       unittest.TestCase		):



			@slow
			def __SCREAMING_SNAKE_CASE							(						self   )			->   List[str]:
								__a		 =       TFEsmForMaskedLM.from_pretrained('facebook/esm2_t6_8M_UR50D'   )

								__a		 =       tf.constant([[0, 1, 2, 3, 4, 5]]   )
								__a		 =       model(UpperCAmelCase   )[0]
								__a		 =       [1, 6, 3_3]
								self.assertEqual(list(output.numpy().shape   )				,						UpperCAmelCase   )
								# compare the actual values for a slice.
								__a		 =       tf.constant(
								    [
								        [
								            [8.921_518, -10.589_814, -6.4_671_307],
								            [-6.3_967_156, -13.911_377, -1.1_211_915],
								            [-7.781_247, -13.951_557, -3.740_592],
								        ]
								    ]   )
								self.assertTrue(numpy.allclose(output[:, :3, :3].numpy()				,						expected_slice.numpy()				,						atol=1e-2   )   )







			@slow
			def __SCREAMING_SNAKE_CASE							(						self   )			->   Optional[int]:
								__a		 =       TFEsmModel.from_pretrained('facebook/esm2_t6_8M_UR50D'   )

								__a		 =       tf.constant([[0, 6, 4, 1_3, 5, 4, 1_6, 1_2, 1_1, 7, 2]]   )
								__a		 =       model(UpperCAmelCase   )[0]
								# compare the actual values for a slice.
								__a		 =       tf.constant(
								    [
								        [
								            [0.14_443_092, 0.54_125_327, 0.3_247_739],
								            [0.30_340_484, 0.00_526_676, 0.31_077_722],
								            [0.32_278_043, -0.24_987_096, 0.3_414_628],
								        ]
								    ]   )
								self.assertTrue(numpy.allclose(output[:, :3, :3].numpy()				,						expected_slice.numpy()				,						atol=1e-4   )   )





from typing import TYPE_CHECKING

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


lowerCamelCase_    :		Union[str, Any]							=	{"""configuration_gpt_neox""": ["""GPT_NEOX_PRETRAINED_CONFIG_ARCHIVE_MAP""", """GPTNeoXConfig"""]}

try:
	if not is_tokenizers_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	lowerCamelCase_    :		Union[str, Any]							=	["""GPTNeoXTokenizerFast"""]

try:
	if not is_torch_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	lowerCamelCase_    :		List[str]							=	[
	    """GPT_NEOX_PRETRAINED_MODEL_ARCHIVE_LIST""",
	    """GPTNeoXForCausalLM""",
	    """GPTNeoXForQuestionAnswering""",
	    """GPTNeoXForSequenceClassification""",
	    """GPTNeoXForTokenClassification""",
	    """GPTNeoXLayer""",
	    """GPTNeoXModel""",
	    """GPTNeoXPreTrainedModel""",
	]


if TYPE_CHECKING:
	from .configuration_gpt_neox import GPT_NEOX_PRETRAINED_CONFIG_ARCHIVE_MAP, GPTNeoXConfig

	try:
		if not is_tokenizers_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .tokenization_gpt_neox_fast import GPTNeoXTokenizerFast

	try:
		if not is_torch_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_gpt_neox import (
		    GPT_NEOX_PRETRAINED_MODEL_ARCHIVE_LIST,
		    GPTNeoXForCausalLM,
		    GPTNeoXForQuestionAnswering,
		    GPTNeoXForSequenceClassification,
		    GPTNeoXForTokenClassification,
		    GPTNeoXLayer,
		    GPTNeoXModel,
		    GPTNeoXPreTrainedModel,
		)


else:
	import sys

	lowerCamelCase_    :		Dict							=	_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)




