


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






			"""simple docstring"""






			def __init__(							self      ,						snake_case      ,						):

						'''simple docstring'''


						UpperCamelCase__					=       parent
						UpperCamelCase__					=       13
						UpperCamelCase__					=       7
						UpperCamelCase__					=       True
						UpperCamelCase__					=       True
						UpperCamelCase__					=       True
						UpperCamelCase__					=       99
						UpperCamelCase__					=       32
						UpperCamelCase__					=       2
						UpperCamelCase__					=       4
						UpperCamelCase__					=       37
						UpperCamelCase__					=       "gelu"
						UpperCamelCase__					=       0.1
						UpperCamelCase__					=       0.1
						UpperCamelCase__					=       512
						UpperCamelCase__					=       16
						UpperCamelCase__					=       2
						UpperCamelCase__					=       0.02
						UpperCamelCase__					=       3
						UpperCamelCase__					=       4
						UpperCamelCase__					=       None




			def 				snake_case__				(							self     ):

						'''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__					=       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 				snake_case__				(							self     ):

						'''simple docstring'''


						(
						    (
						    UpperCamelCase__      
						),      (
						    UpperCamelCase__      
						),      (
						    UpperCamelCase__      
						),      (
						    UpperCamelCase__      
						),      (
						    UpperCamelCase__      
						),      (
						    UpperCamelCase__      
						),            
						)					=       self.prepare_config_and_inputs()

						UpperCamelCase__					=       True
						UpperCamelCase__					=       floats_tensor([self.batch_size, self.seq_length, self.hidden_size]     )
						UpperCamelCase__					=       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 				snake_case__				(							self      ,						snake_case      ,						snake_case      ,						snake_case      ,						snake_case      ,						snake_case      ,						snake_case     ):

						'''simple docstring'''


						UpperCamelCase__					=       TFEsmModel(config=snake_case     )
						UpperCamelCase__					=       {"input_ids": input_ids, "attention_mask": input_mask}
						UpperCamelCase__					=       model(snake_case     )

						UpperCamelCase__					=       [input_ids, input_mask]
						UpperCamelCase__					=       model(snake_case     )

						UpperCamelCase__					=       model(snake_case     )

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




			def 				snake_case__				(							self      ,						snake_case      ,						snake_case      ,						snake_case      ,						snake_case      ,						snake_case      ,						snake_case      ,						snake_case      ,						snake_case      ,						):

						'''simple docstring'''


						UpperCamelCase__					=       True

						UpperCamelCase__					=       TFEsmModel(config=snake_case     )
						UpperCamelCase__					=       {
						    "input_ids": input_ids,
						    "attention_mask": input_mask,
						    "encoder_hidden_states": encoder_hidden_states,
						    "encoder_attention_mask": encoder_attention_mask,
						}
						UpperCamelCase__					=       model(snake_case     )

						UpperCamelCase__					=       [input_ids, input_mask]
						UpperCamelCase__					=       model(snake_case      ,						encoder_hidden_states=snake_case     )

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

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




			def 				snake_case__				(							self      ,						snake_case      ,						snake_case      ,						snake_case      ,						snake_case      ,						snake_case      ,						snake_case     ):

						'''simple docstring'''


						UpperCamelCase__					=       TFEsmForMaskedLM(config=snake_case     )
						UpperCamelCase__					=       model([input_ids, input_mask]     )
						self.parent.assertEqual(result.logits.shape      ,						(self.batch_size, self.seq_length, self.vocab_size)     )




			def 				snake_case__				(							self      ,						snake_case      ,						snake_case      ,						snake_case      ,						snake_case      ,						snake_case      ,						snake_case     ):

						'''simple docstring'''


						UpperCamelCase__					=       self.num_labels
						UpperCamelCase__					=       TFEsmForTokenClassification(config=snake_case     )
						UpperCamelCase__					=       {"input_ids": input_ids, "attention_mask": input_mask}
						UpperCamelCase__					=       model(snake_case     )
						self.parent.assertEqual(result.logits.shape      ,						(self.batch_size, self.seq_length, self.num_labels)     )







			def 				snake_case__				(							self     ):

						'''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_tf
class        lowerCamelCase__	(							UpperCAmelCase					,	UpperCAmelCase					,	unittest.TestCase      ):






			"""simple docstring"""






			_UpperCamelCase		:					int    =		(
			    (
			        TFEsmModel,
			        TFEsmForMaskedLM,
			        TFEsmForSequenceClassification,
			        TFEsmForTokenClassification,
			    )
			    if is_tf_available()
			    else ()
			)
			_UpperCamelCase		:					Any    =		(
			    {
			        'feature-extraction': TFEsmModel,
			        'fill-mask': TFEsmForMaskedLM,
			        'text-classification': TFEsmForSequenceClassification,
			        'token-classification': TFEsmForTokenClassification,
			        'zero-shot': TFEsmForSequenceClassification,
			    }
			    if is_tf_available()
			    else {}
			)
			_UpperCamelCase		:					int    =		False
			_UpperCamelCase		:					List[Any]    =		False




			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       TFEsmModelTester(self     )
						UpperCamelCase__					=       ConfigTester(self      ,						config_class=snake_case      ,						hidden_size=37     )




			def 				snake_case__				(							self     ):

						'''simple docstring'''


						self.config_tester.run_common_tests()




			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_model(*snake_case     )




			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       self.model_tester.prepare_config_and_inputs_for_decoder()
						self.model_tester.create_and_check_model_as_decoder(*snake_case     )




			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_masked_lm(*snake_case     )




			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_token_classification(*snake_case     )




			@slow
			def 				snake_case__				(							self     ):

						'''simple docstring'''


						for model_name in TF_ESM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									UpperCamelCase__					=       TFEsmModel.from_pretrained(snake_case     )
									self.assertIsNotNone(snake_case     )




			@unittest.skip("Protein models do not support embedding resizing."     )
			def 				snake_case__				(							self     ):

						'''simple docstring'''


						pass




			@unittest.skip("Protein models do not support embedding resizing."     )
			def 				snake_case__				(							self     ):

						'''simple docstring'''


						pass







			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__,      UpperCamelCase__					=       self.model_tester.prepare_config_and_inputs_for_common()

						for model_class in self.all_model_classes:
									UpperCamelCase__					=       model_class(snake_case     )
									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
												UpperCamelCase__					=       model.get_bias()
												assert isinstance(snake_case      ,						snake_case     )
												for k, v in name.items():
															assert isinstance(snake_case      ,						tf.Variable     )
									else:
												UpperCamelCase__					=       model.get_output_embeddings()
												assert x is None
												UpperCamelCase__					=       model.get_bias()
												assert name is None






@require_tf
class        lowerCamelCase__	(							unittest.TestCase      ):






			"""simple docstring"""






			@slow
			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       TFEsmForMaskedLM.from_pretrained("facebook/esm2_t6_8M_UR50D"     )

						UpperCamelCase__					=       tf.constant([[0, 1, 2, 3, 4, 5]]     )
						UpperCamelCase__					=       model(snake_case     )[0]
						UpperCamelCase__					=       [1, 6, 33]
						self.assertEqual(list(output.numpy().shape     )      ,						snake_case     )
						# compare the actual values for a slice.
						UpperCamelCase__					=       tf.constant(
						    [
						        [
						            [8.921518, -10.589814, -6.4671307],
						            [-6.3967156, -13.911377, -1.1211915],
						            [-7.781247, -13.951557, -3.740592],
						        ]
						    ]     )
						self.assertTrue(numpy.allclose(output[:, :3, :3].numpy()      ,						expected_slice.numpy()      ,						atol=1E-2     )     )







			@slow
			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       TFEsmModel.from_pretrained("facebook/esm2_t6_8M_UR50D"     )

						UpperCamelCase__					=       tf.constant([[0, 6, 4, 13, 5, 4, 16, 12, 11, 7, 2]]     )
						UpperCamelCase__					=       model(snake_case     )[0]
						# compare the actual values for a slice.
						UpperCamelCase__					=       tf.constant(
						    [
						        [
						            [0.14443092, 0.54125327, 0.3247739],
						            [0.30340484, 0.00526676, 0.31077722],
						            [0.32278043, -0.24987096, 0.3414628],
						        ]
						    ]     )
						self.assertTrue(numpy.allclose(output[:, :3, :3].numpy()      ,						expected_slice.numpy()      ,						atol=1E-4     )     )






def        UpperCamelCase_(				_A   :List[str]				,     _A   :Tuple				,     _A   :Any				,     _A   :Tuple				,     _A   :Optional[int]				,     _A   :str  )->		List[str]:
			if index == r:
						for j in range(_A  ):
									print(data[j]				,     end=" "  )
						print(" "  )
						return
			#  When no more elements are there to put in data[]
			if i >= n:
						return
			# current is included, put next at next location
			UpperCamelCase__					=       arr[i]
			combination_util(_A				,     _A				,     _A				,     index + 1				,     _A				,     i + 1  )
			# current is excluded, replace it with
			# next (Note that i+1 is passed, but
			# index is not changed)
			combination_util(_A				,     _A				,     _A				,     _A				,     _A				,     i + 1  )
			# The main function that prints all combinations
			# of size r in arr[] of size n. This function
			# mainly uses combinationUtil()
def        UpperCamelCase_(				_A   :Dict				,     _A   :Optional[Any]				,     _A   :Union[str, Any]  )->		Optional[int]:
			# A temporary array to store all combination one by one
			UpperCamelCase__					=       [0] * r
			# Print all combination using temporary array 'data[]'
			combination_util(_A				,     _A				,     _A				,     0				,     _A				,     0  )


if __name__ == "__main__":
						# Driver code to check the function above
						__UpperCamelCase    		=       [1_0, 2_0, 3_0, 4_0, 5_0]
						print_combination(arr, len(arr), 3)
						# This code is contributed by Ambuj sahu


