
"""simple docstring"""






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__:
	'''simple docstring'''

	def __init__(						self    :Dict		, lowerCamelCase_    :Union[str, Any]		, )							->			int:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     Dict				= parent
			SCREAMING_SNAKE_CASE       :     Tuple				= 13
			SCREAMING_SNAKE_CASE       :     Union[str, Any]				= 7
			SCREAMING_SNAKE_CASE       :     Optional[Any]				= True
			SCREAMING_SNAKE_CASE       :     int				= True
			SCREAMING_SNAKE_CASE       :     Optional[int]				= True
			SCREAMING_SNAKE_CASE       :     int				= 99
			SCREAMING_SNAKE_CASE       :     Optional[Any]				= 32
			SCREAMING_SNAKE_CASE       :     Optional[Any]				= 2
			SCREAMING_SNAKE_CASE       :     Optional[int]				= 4
			SCREAMING_SNAKE_CASE       :     Dict				= 37
			SCREAMING_SNAKE_CASE       :     Union[str, Any]				= '''gelu'''
			SCREAMING_SNAKE_CASE       :     Optional[Any]				= 0.1
			SCREAMING_SNAKE_CASE       :     Union[str, Any]				= 0.1
			SCREAMING_SNAKE_CASE       :     Optional[int]				= 5_12
			SCREAMING_SNAKE_CASE       :     Union[str, Any]				= 16
			SCREAMING_SNAKE_CASE       :     List[Any]				= 2
			SCREAMING_SNAKE_CASE       :     Dict				= 0.0_2
			SCREAMING_SNAKE_CASE       :     List[str]				= 3
			SCREAMING_SNAKE_CASE       :     Optional[int]				= 4
			SCREAMING_SNAKE_CASE       :     Dict				= None





	def   __lowerCAmelCase (						self    :List[Any]					)							->			str:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     Dict				= ids_tensor([self.batch_size, self.seq_length]		, self.vocab_size					)

			SCREAMING_SNAKE_CASE       :     Optional[Any]				= None
			if self.use_input_mask:
					SCREAMING_SNAKE_CASE       :     Optional[int]				= random_attention_mask([self.batch_size, self.seq_length]					)

			SCREAMING_SNAKE_CASE       :     Tuple				= None
			SCREAMING_SNAKE_CASE       :     Union[str, Any]				= None
			SCREAMING_SNAKE_CASE       :     List[str]				= None
			if self.use_labels:
					SCREAMING_SNAKE_CASE       :     List[Any]				= ids_tensor([self.batch_size]		, self.type_sequence_label_size					)
					SCREAMING_SNAKE_CASE       :     Union[str, Any]				= ids_tensor([self.batch_size, self.seq_length]		, self.num_labels					)
					SCREAMING_SNAKE_CASE       :     int				= ids_tensor([self.batch_size]		, self.num_choices					)

			SCREAMING_SNAKE_CASE       :     Dict				= 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   __lowerCAmelCase (						self    :Union[str, Any]					)							->			Optional[int]:







			'''simple docstring'''




			(
			    (
			    SCREAMING_SNAKE_CASE
			),					(
			    SCREAMING_SNAKE_CASE
			),					(
			    SCREAMING_SNAKE_CASE
			),					(
			    SCREAMING_SNAKE_CASE
			),					(
			    SCREAMING_SNAKE_CASE
			),					(
			    SCREAMING_SNAKE_CASE
			),					
			)       :     List[str]				= self.prepare_config_and_inputs()

			SCREAMING_SNAKE_CASE       :     str				= True
			SCREAMING_SNAKE_CASE       :     int				= floats_tensor([self.batch_size, self.seq_length, self.hidden_size]					)
			SCREAMING_SNAKE_CASE       :     List[Any]				= 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   __lowerCAmelCase (						self    :List[Any]		, lowerCamelCase_    :Dict		, lowerCamelCase_    :Optional[Any]		, lowerCamelCase_    :Tuple		, lowerCamelCase_    :List[str]		, lowerCamelCase_    :Tuple		, lowerCamelCase_    :Union[str, Any]					)							->			Dict:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     List[Any]				= TFEsmModel(config=lowerCamelCase_					)
			SCREAMING_SNAKE_CASE       :     Any				= {'''input_ids''': input_ids, '''attention_mask''': input_mask}
			SCREAMING_SNAKE_CASE       :     int				= model(lowerCamelCase_					)

			SCREAMING_SNAKE_CASE       :     Optional[Any]				= [input_ids, input_mask]
			SCREAMING_SNAKE_CASE       :     int				= model(lowerCamelCase_					)

			SCREAMING_SNAKE_CASE       :     Optional[int]				= model(lowerCamelCase_					)

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





	def   __lowerCAmelCase (						self    :Tuple		, lowerCamelCase_    :Union[str, Any]		, lowerCamelCase_    :str		, lowerCamelCase_    :List[Any]		, lowerCamelCase_    :Dict		, lowerCamelCase_    :int		, lowerCamelCase_    :str		, lowerCamelCase_    :Tuple		, lowerCamelCase_    :str		, )							->			str:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     Dict				= True

			SCREAMING_SNAKE_CASE       :     Tuple				= TFEsmModel(config=lowerCamelCase_					)
			SCREAMING_SNAKE_CASE       :     Dict				= {
			    '''input_ids''': input_ids,
			    '''attention_mask''': input_mask,
			    '''encoder_hidden_states''': encoder_hidden_states,
			    '''encoder_attention_mask''': encoder_attention_mask,
			}
			SCREAMING_SNAKE_CASE       :     Any				= model(lowerCamelCase_					)

			SCREAMING_SNAKE_CASE       :     List[str]				= [input_ids, input_mask]
			SCREAMING_SNAKE_CASE       :     Any				= model(lowerCamelCase_		, encoder_hidden_states=lowerCamelCase_					)

			# Also check the case where encoder outputs are not passed
			SCREAMING_SNAKE_CASE       :     Optional[Any]				= model(lowerCamelCase_		, attention_mask=lowerCamelCase_					)

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





	def   __lowerCAmelCase (						self    :List[str]		, lowerCamelCase_    :Union[str, Any]		, lowerCamelCase_    :Dict		, lowerCamelCase_    :Optional[int]		, lowerCamelCase_    :str		, lowerCamelCase_    :List[str]		, lowerCamelCase_    :Any					)							->			Any:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     int				= TFEsmForMaskedLM(config=lowerCamelCase_					)
			SCREAMING_SNAKE_CASE       :     Optional[int]				= model([input_ids, input_mask]					)
			self.parent.assertEqual(result.logits.shape		, (self.batch_size, self.seq_length, self.vocab_size)					)





	def   __lowerCAmelCase (						self    :int		, lowerCamelCase_    :List[Any]		, lowerCamelCase_    :str		, lowerCamelCase_    :List[Any]		, lowerCamelCase_    :Optional[int]		, lowerCamelCase_    :Dict		, lowerCamelCase_    :List[str]					)							->			int:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     List[Any]				= self.num_labels
			SCREAMING_SNAKE_CASE       :     List[Any]				= TFEsmForTokenClassification(config=lowerCamelCase_					)
			SCREAMING_SNAKE_CASE       :     Optional[int]				= {'''input_ids''': input_ids, '''attention_mask''': input_mask}
			SCREAMING_SNAKE_CASE       :     Union[str, Any]				= model(lowerCamelCase_					)
			self.parent.assertEqual(result.logits.shape		, (self.batch_size, self.seq_length, self.num_labels)					)







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







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     Any				= self.prepare_config_and_inputs()
			(
			    (
			    SCREAMING_SNAKE_CASE
			),					(
			    SCREAMING_SNAKE_CASE
			),					(
			    SCREAMING_SNAKE_CASE
			),					(
			    SCREAMING_SNAKE_CASE
			),					(
			    SCREAMING_SNAKE_CASE
			),					(
			    SCREAMING_SNAKE_CASE
			),					
			)       :     List[Any]				= config_and_inputs
			SCREAMING_SNAKE_CASE       :     List[Any]				= {'''input_ids''': input_ids, '''attention_mask''': input_mask}
			return config, inputs_dict





@require_tf
class 				lowercase__(				_UpperCAmelCase		,						_UpperCAmelCase		,						unittest.TestCase   ):
	'''simple docstring'''

	UpperCamelCase				=  (
	    (
	        TFEsmModel,
	        TFEsmForMaskedLM,
	        TFEsmForSequenceClassification,
	        TFEsmForTokenClassification,
	    )
	    if is_tf_available()
	    else ()
	)
	UpperCamelCase				=  (
	    {
	        """feature-extraction""": TFEsmModel,
	        """fill-mask""": TFEsmForMaskedLM,
	        """text-classification""": TFEsmForSequenceClassification,
	        """token-classification""": TFEsmForTokenClassification,
	        """zero-shot""": TFEsmForSequenceClassification,
	    }
	    if is_tf_available()
	    else {}
	)
	UpperCamelCase				=  False
	UpperCamelCase				=  False





	def   __lowerCAmelCase (						self    :Optional[Any]					)							->			Dict:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     List[str]				= TFEsmModelTester(self					)
			SCREAMING_SNAKE_CASE       :     Any				= ConfigTester(self		, config_class=lowerCamelCase_		, hidden_size=37					)





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







			'''simple docstring'''




			self.config_tester.run_common_tests()





	def   __lowerCAmelCase (						self    :Optional[Any]					)							->			Optional[int]:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     Optional[Any]				= self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_model(*lowerCamelCase_					)





	def   __lowerCAmelCase (						self    :List[str]					)							->			List[str]:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     Dict				= self.model_tester.prepare_config_and_inputs_for_decoder()
			self.model_tester.create_and_check_model_as_decoder(*lowerCamelCase_					)





	def   __lowerCAmelCase (						self    :Dict					)							->			Optional[Any]:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     List[Any]				= self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_for_masked_lm(*lowerCamelCase_					)





	def   __lowerCAmelCase (						self    :List[str]					)							->			Optional[Any]:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     str				= self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_for_token_classification(*lowerCamelCase_					)





	@slow
	def   __lowerCAmelCase (						self    :List[Any]					)							->			str:







			'''simple docstring'''




			for model_name in TF_ESM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
					SCREAMING_SNAKE_CASE       :     List[Any]				= TFEsmModel.from_pretrained(lowerCamelCase_					)
					self.assertIsNotNone(lowerCamelCase_					)





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







			'''simple docstring'''




			pass





	@unittest.skip('''Protein models do not support embedding resizing.'''					)
	def   __lowerCAmelCase (						self    :Union[str, Any]					)							->			Dict:







			'''simple docstring'''




			pass







	def   __lowerCAmelCase (						self    :List[str]					)							->			List[Any]:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE,					SCREAMING_SNAKE_CASE       :     Tuple				= self.model_tester.prepare_config_and_inputs_for_common()

			for model_class in self.all_model_classes:
					SCREAMING_SNAKE_CASE       :     Tuple				= model_class(lowerCamelCase_					)
					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
							SCREAMING_SNAKE_CASE       :     Dict				= model.get_bias()
							assert isinstance(lowerCamelCase_		, lowerCamelCase_					)
							for k, v in name.items():
									assert isinstance(lowerCamelCase_		, tf.Variable					)
					else:
							SCREAMING_SNAKE_CASE       :     List[Any]				= model.get_output_embeddings()
							assert x is None
							SCREAMING_SNAKE_CASE       :     str				= model.get_bias()
							assert name is None





@require_tf
class 				lowercase__(				unittest.TestCase   ):
	'''simple docstring'''

	@slow
	def   __lowerCAmelCase (						self    :Optional[Any]					)							->			Optional[Any]:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     int				= TFEsmForMaskedLM.from_pretrained('''facebook/esm2_t6_8M_UR50D'''					)

			SCREAMING_SNAKE_CASE       :     Tuple				= tf.constant([[0, 1, 2, 3, 4, 5]]					)
			SCREAMING_SNAKE_CASE       :     Tuple				= model(lowerCamelCase_					)[0]
			SCREAMING_SNAKE_CASE       :     Any				= [1, 6, 33]
			self.assertEqual(list(output.numpy().shape					)		, lowerCamelCase_					)
			# compare the actual values for a slice.
			SCREAMING_SNAKE_CASE       :     Optional[Any]				= tf.constant(
			    [
			        [
			            [8.9_2_1_5_1_8, -1_0.5_8_9_8_1_4, -6.4_6_7_1_3_0_7],
			            [-6.3_9_6_7_1_5_6, -1_3.9_1_1_3_7_7, -1.1_2_1_1_9_1_5],
			            [-7.7_8_1_2_4_7, -1_3.9_5_1_5_5_7, -3.7_4_0_5_9_2],
			        ]
			    ]					)
			self.assertTrue(numpy.allclose(output[:, :3, :3].numpy()		, expected_slice.numpy()		, atol=1E-2					)					)







	@slow
	def   __lowerCAmelCase (						self    :Dict					)							->			List[str]:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     Tuple				= TFEsmModel.from_pretrained('''facebook/esm2_t6_8M_UR50D'''					)

			SCREAMING_SNAKE_CASE       :     List[str]				= tf.constant([[0, 6, 4, 13, 5, 4, 16, 12, 11, 7, 2]]					)
			SCREAMING_SNAKE_CASE       :     Union[str, Any]				= model(lowerCamelCase_					)[0]
			# compare the actual values for a slice.
			SCREAMING_SNAKE_CASE       :     Any				= tf.constant(
			    [
			        [
			            [0.1_4_4_4_3_0_9_2, 0.5_4_1_2_5_3_2_7, 0.3_2_4_7_7_3_9],
			            [0.3_0_3_4_0_4_8_4, 0.0_0_5_2_6_6_7_6, 0.3_1_0_7_7_7_2_2],
			            [0.3_2_2_7_8_0_4_3, -0.2_4_9_8_7_0_9_6, 0.3_4_1_4_6_2_8],
			        ]
			    ]					)
			self.assertTrue(numpy.allclose(output[:, :3, :3].numpy()		, expected_slice.numpy()		, atol=1E-4					)					)







"""simple docstring"""






def __A						(   a_ :							int     )->							list[int]:




		'''simple docstring'''






		if num <= 0:
				raise ValueError('''Input must be a positive integer'''     )

		SCREAMING_SNAKE_CASE       :     Optional[int]				= [True] * (num + 1)

		SCREAMING_SNAKE_CASE       :     Optional[Any]				= 2
		while p * p <= num:
				if primes[p]:
						for i in range(p * p		,		num + 1		,		a_     ):
								SCREAMING_SNAKE_CASE       :     Any				= False
				p += 1

		return [prime for prime in range(2		,		num + 1     ) if primes[prime]]


if __name__ == "__main__":
					import doctest

					doctest.testmod()

					lowerCamelCase__ :       str						     =			int(input("Enter a positive integer: ").strip())
					print(prime_sieve_eratosthenes(user_num))





