






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

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







							'''simple docstring'''





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

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







							'''simple docstring'''





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

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

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

							lowerCAmelCase__       =						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 		UpperCAmelCase  (							self       )->					Union[str, Any]:







							'''simple docstring'''





							(
							    (
							    lowerCAmelCase__ 
							)      ,							(
							    lowerCAmelCase__ 
							)      ,							(
							    lowerCAmelCase__ 
							)      ,							(
							    lowerCAmelCase__ 
							)      ,							(
							    lowerCAmelCase__ 
							)      ,							(
							    lowerCAmelCase__ 
							)      ,							 
							)       =						self.prepare_config_and_inputs()

							lowerCAmelCase__       =						True
							lowerCAmelCase__       =						floats_tensor([self.batch_size, self.seq_length, self.hidden_size]       )
							lowerCAmelCase__       =						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 		UpperCAmelCase  (							self		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase       )->					List[Any]:







							'''simple docstring'''





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

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

							lowerCAmelCase__       =						model(UpperCamelCase__       )

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

	def 		UpperCAmelCase  (							self		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase		,    )->					str:







							'''simple docstring'''





							lowerCAmelCase__       =						True

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

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

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

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

	def 		UpperCAmelCase  (							self		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase       )->					int:







							'''simple docstring'''





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

	def 		UpperCAmelCase  (							self		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase       )->					Optional[int]:







							'''simple docstring'''





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


	def 		UpperCAmelCase  (							self       )->					Tuple:







							'''simple docstring'''





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





@require_tf
class      lowercase__     (			lowercase_,					lowercase_,					unittest.TestCase	):
	a_         =(
	    (
	        TFEsmModel,
	        TFEsmForMaskedLM,
	        TFEsmForSequenceClassification,
	        TFEsmForTokenClassification,
	    )
	    if is_tf_available()
	    else ()
	)
	a_         =(
	    {
	        '''feature-extraction''': TFEsmModel,
	        '''fill-mask''': TFEsmForMaskedLM,
	        '''text-classification''': TFEsmForSequenceClassification,
	        '''token-classification''': TFEsmForTokenClassification,
	        '''zero-shot''': TFEsmForSequenceClassification,
	    }
	    if is_tf_available()
	    else {}
	)
	a_         =False
	a_         =False

	def 		UpperCAmelCase  (							self       )->					Dict:







							'''simple docstring'''





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

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







							'''simple docstring'''





							self.config_tester.run_common_tests()

	def 		UpperCAmelCase  (							self       )->					Any:







							'''simple docstring'''





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

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







							'''simple docstring'''





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

	def 		UpperCAmelCase  (							self       )->					Optional[Any]:







							'''simple docstring'''





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

	def 		UpperCAmelCase  (							self       )->					Tuple:







							'''simple docstring'''





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

	@slow
	def 		UpperCAmelCase  (							self       )->					Tuple:







							'''simple docstring'''





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

	@unittest.skip("Protein models do not support embedding resizing."       )
	def 		UpperCAmelCase  (							self       )->					Tuple:







							'''simple docstring'''





							pass

	@unittest.skip("Protein models do not support embedding resizing."       )
	def 		UpperCAmelCase  (							self       )->					Optional[Any]:







							'''simple docstring'''





							pass


	def 		UpperCAmelCase  (							self       )->					Tuple:







							'''simple docstring'''





							lowerCAmelCase__      ,							lowerCAmelCase__       =						self.model_tester.prepare_config_and_inputs_for_common()

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





@require_tf
class      lowercase__     (			unittest.TestCase	):

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







							'''simple docstring'''





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

							lowerCAmelCase__       =						tf.constant([[0, 1, 2, 3, 4, 5]]       )
							lowerCAmelCase__       =						model(UpperCamelCase__       )[0]
							lowerCAmelCase__       =						[1, 6, 33]
							self.assertEqual(list(output.numpy().shape       )		,    UpperCamelCase__       )
							# compare the actual values for a slice.
							lowerCAmelCase__       =						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 		UpperCAmelCase  (							self       )->					Tuple:







							'''simple docstring'''





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

							lowerCAmelCase__       =						tf.constant([[0, 6, 4, 13, 5, 4, 16, 12, 11, 7, 2]]       )
							lowerCAmelCase__       =						model(UpperCamelCase__       )[0]
							# compare the actual values for a slice.
							lowerCAmelCase__       =						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 __future__ import annotations

from collections.abc import Generator


def        _a  (     ) ->   Generator[int, None, None]:
						"""simple docstring"""







						lowerCAmelCase__       =						{}
						lowerCAmelCase__       =						2
						while True:
												lowerCAmelCase__       =						factor_map.pop(UpperCamelCase_    ,   UpperCamelCase_   )
												if factor:
																		lowerCAmelCase__       =						factor + prime
																		while x in factor_map:
																								x += factor
																		lowerCAmelCase__       =						factor
												else:
																		lowerCAmelCase__       =						prime
																		yield prime
												prime += 1


def        _a  (     UpperCamelCase_					:				float = 1e1_0   ) ->   int:
						"""simple docstring"""







						lowerCAmelCase__       =						sieve()

						lowerCAmelCase__       =						1
						while True:
												lowerCAmelCase__       =						next(UpperCamelCase_   )
												if (2 * prime * n) > limit:
																		return n
												# Ignore the next prime as the reminder will be 2.
												next(UpperCamelCase_   )
												n += 2


if __name__ == "__main__":
	print(solution())






