






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    :    Optional[int]			,		UpperCamelCase__    :    str			,		):






											'''simple docstring'''







											snake_case__	  =       parent
											snake_case__	  =       1_3
											snake_case__	  =       7
											snake_case__	  =       True
											snake_case__	  =       True
											snake_case__	  =       True
											snake_case__	  =       9_9
											snake_case__	  =       3_2
											snake_case__	  =       2
											snake_case__	  =       4
											snake_case__	  =       3_7
											snake_case__	  =       """gelu"""
											snake_case__	  =       0.1
											snake_case__	  =       0.1
											snake_case__	  =       5_1_2
											snake_case__	  =       1_6
											snake_case__	  =       2
											snake_case__	  =       0.02
											snake_case__	  =       3
											snake_case__	  =       4
											snake_case__	  =       None



				def 					__magic_name__							(      self    :    Union[str, Any]):






											'''simple docstring'''







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

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

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

											snake_case__	  =       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 					__magic_name__							(      self    :    int):






											'''simple docstring'''







											(
											    (
											    snake_case__
											)  , (
											    snake_case__
											)  , (
											    snake_case__
											)  , (
											    snake_case__
											)  , (
											    snake_case__
											)  , (
											    snake_case__
											)  , 
											)	  =       self.prepare_config_and_inputs()

											snake_case__	  =       True
											snake_case__	  =       floats_tensor([self.batch_size, self.seq_length, self.hidden_size])
											snake_case__	  =       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 					__magic_name__							(      self    :    List[Any]			,		UpperCamelCase__    :    str			,		UpperCamelCase__    :    str			,		UpperCamelCase__    :    Optional[int]			,		UpperCamelCase__    :    Any			,		UpperCamelCase__    :    List[str]			,		UpperCamelCase__    :    List[str]):






											'''simple docstring'''







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

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

											snake_case__	  =       model(UpperCamelCase__)

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



				def 					__magic_name__							(      self    :    List[Any]			,		UpperCamelCase__    :    List[Any]			,		UpperCamelCase__    :    Dict			,		UpperCamelCase__    :    Dict			,		UpperCamelCase__    :    Dict			,		UpperCamelCase__    :    List[str]			,		UpperCamelCase__    :    List[Any]			,		UpperCamelCase__    :    Any			,		UpperCamelCase__    :    str			,		):






											'''simple docstring'''







											snake_case__	  =       True

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

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

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

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



				def 					__magic_name__							(      self    :    Optional[Any]			,		UpperCamelCase__    :    Any			,		UpperCamelCase__    :    Any			,		UpperCamelCase__    :    int			,		UpperCamelCase__    :    str			,		UpperCamelCase__    :    Tuple			,		UpperCamelCase__    :    Optional[int]):






											'''simple docstring'''







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



				def 					__magic_name__							(      self    :    Tuple			,		UpperCamelCase__    :    Tuple			,		UpperCamelCase__    :    List[Any]			,		UpperCamelCase__    :    Optional[Any]			,		UpperCamelCase__    :    str			,		UpperCamelCase__    :    Optional[Any]			,		UpperCamelCase__    :    int):






											'''simple docstring'''







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



				def 					__magic_name__							(      self    :    Tuple):






											'''simple docstring'''







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


@require_tf
class    _lowerCAmelCase			(		lowercase_     ,      lowercase_     ,      unittest.TestCase      ):



				"""simple docstring"""



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



				def 					__magic_name__							(      self    :    Optional[int]):






											'''simple docstring'''







											snake_case__	  =       TFEsmModelTester(self)
											snake_case__	  =       ConfigTester(self			,		config_class=UpperCamelCase__			,		hidden_size=3_7)



				def 					__magic_name__							(      self    :    str):






											'''simple docstring'''







											self.config_tester.run_common_tests()



				def 					__magic_name__							(      self    :    Union[str, Any]):






											'''simple docstring'''







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



				def 					__magic_name__							(      self    :    Dict):






											'''simple docstring'''







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



				def 					__magic_name__							(      self    :    Optional[Any]):






											'''simple docstring'''







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



				def 					__magic_name__							(      self    :    int):






											'''simple docstring'''







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



				@slow
				def 					__magic_name__							(      self    :    List[str]):






											'''simple docstring'''







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



				@unittest.skip("""Protein models do not support embedding resizing.""")
				def 					__magic_name__							(      self    :    Union[str, Any]):






											'''simple docstring'''







											pass



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






											'''simple docstring'''







											pass



				def 					__magic_name__							(      self    :    Dict):






											'''simple docstring'''







											snake_case__  , snake_case__	  =       self.model_tester.prepare_config_and_inputs_for_common()

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


@require_tf
class    _lowerCAmelCase			(		unittest.TestCase      ):



				"""simple docstring"""



				@slow
				def 					__magic_name__							(      self    :    Dict):






											'''simple docstring'''







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

											snake_case__	  =       tf.constant([[0, 1, 2, 3, 4, 5]])
											snake_case__	  =       model(UpperCamelCase__)[0]
											snake_case__	  =       [1, 6, 3_3]
											self.assertEqual(list(output.numpy().shape)			,		UpperCamelCase__)
											# compare the actual values for a slice.
											snake_case__	  =       tf.constant(
											    [
											        [
											            [8.92_15_18, -10.58_98_14, -6.4_67_13_07],
											            [-6.3_96_71_56, -13.91_13_77, -1.1_21_19_15],
											            [-7.78_12_47, -13.95_15_57, -3.74_05_92],
											        ]
											    ])
											self.assertTrue(numpy.allclose(output[:, :3, :3].numpy()			,		expected_slice.numpy()			,		atol=1E-2))



				@slow
				def 					__magic_name__							(      self    :    Optional[Any]):






											'''simple docstring'''







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

											snake_case__	  =       tf.constant([[0, 6, 4, 1_3, 5, 4, 1_6, 1_2, 1_1, 7, 2]])
											snake_case__	  =       model(UpperCamelCase__)[0]
											# compare the actual values for a slice.
											snake_case__	  =       tf.constant(
											    [
											        [
											            [0.14_44_30_92, 0.54_12_53_27, 0.3_24_77_39],
											            [0.30_34_04_84, 0.00_52_66_76, 0.31_07_77_22],
											            [0.32_27_80_43, -0.24_98_70_96, 0.3_41_46_28],
											        ]
											    ])
											self.assertTrue(numpy.allclose(output[:, :3, :3].numpy()			,		expected_slice.numpy()			,		atol=1E-4))








def _UpperCAmelCase   (	a						:	int = 400_0000 ):
							snake_case__	  =       [0, 1]
							snake_case__	  =       0
							while fib[i] <= n:
														fib.append(fib[i] + fib[i + 1] )
														if fib[i + 2] > n:
																					break
														i += 1
							snake_case__	  =       0
							for j in range(len(a ) - 1 ):
														if fib[j] % 2 == 0:
																					total += fib[j]

							return total


if __name__ == "__main__":
	print(F'''{solution() = }''')
