





'''simple docstring'''

import unittest

from transformers import EsmConfig, is_torch_available
from transformers.testing_utils import TestCasePlus, require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
			import torch

			from transformers import EsmForMaskedLM, EsmForSequenceClassification, EsmForTokenClassification, EsmModel
			from transformers.models.esm.modeling_esm import (
			    ESM_PRETRAINED_MODEL_ARCHIVE_LIST,
			    EsmEmbeddings,
			    create_position_ids_from_input_ids,
			)

class       UpperCAmelCase :




		def __init__(self      :	str							,			A__      :	Any							,			A__      :	str=1_3							,			A__      :	str=7							,			A__      :	int=False							,			A__      :	Tuple=True							,			A__      :	Tuple=False							,			A__      :	Optional[int]=True							,			A__      :	Union[str, Any]=3_3							,			A__      :	Tuple=3_2							,			A__      :	Optional[int]=5							,			A__      :	Union[str, Any]=4							,			A__      :	Tuple=3_7							,			A__      :	int="gelu"							,			A__      :	Union[str, Any]=0.1							,			A__      :	Any=0.1							,			A__      :	Tuple=5_1_2							,			A__      :	Dict=1_6							,			A__      :	str=2							,			A__      :	Union[str, Any]=0.0_2							,			A__      :	str=3							,			A__      :	str=4							,			A__      :	int=None							,			)					-> int:
						lowercase         = parent
						lowercase         = batch_size
						lowercase         = seq_length
						lowercase         = is_training
						lowercase         = use_input_mask
						lowercase         = use_token_type_ids
						lowercase         = use_labels
						lowercase         = vocab_size
						lowercase         = hidden_size
						lowercase         = num_hidden_layers
						lowercase         = num_attention_heads
						lowercase         = intermediate_size
						lowercase         = hidden_act
						lowercase         = hidden_dropout_prob
						lowercase         = attention_probs_dropout_prob
						lowercase         = max_position_embeddings
						lowercase         = type_vocab_size
						lowercase         = type_sequence_label_size
						lowercase         = initializer_range
						lowercase         = num_labels
						lowercase         = num_choices
						lowercase         = scope




		def 				UpperCAmelCase__   (self      :	Any				)					-> Union[str, Any]:
						lowercase         = ids_tensor([self.batch_size, self.seq_length]							,			self.vocab_size				)

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

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

						lowercase         = self.get_config()

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




		def 				UpperCAmelCase__   (self      :	Dict				)					-> Tuple:
						return EsmConfig(
						    vocab_size=self.vocab_size							,			hidden_size=self.hidden_size							,			pad_token_id=1							,			num_hidden_layers=self.num_hidden_layers							,			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							,			)




		def 				UpperCAmelCase__   (self      :	List[Any]							,			A__      :	Optional[Any]							,			A__      :	Optional[int]							,			A__      :	Union[str, Any]							,			A__      :	int							,			A__      :	List[str]							,			A__      :	List[Any]				)					-> Union[str, Any]:
						lowercase         = EsmModel(config=A__				)
						model.to(A__				)
						model.eval()
						lowercase         = model(A__							,			attention_mask=A__				)
						lowercase         = model(A__				)
						lowercase         = model(A__				)

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




		def 				UpperCAmelCase__   (self      :	Optional[Any]							,			A__      :	Dict							,			A__      :	Optional[Any]							,			A__      :	str							,			A__      :	List[Any]							,			A__      :	int							,			A__      :	List[Any]				)					-> Optional[Any]:
						lowercase         = EsmForMaskedLM(config=A__				)
						model.to(A__				)
						model.eval()
						lowercase         = model(A__							,			attention_mask=A__							,			labels=A__				)
						self.parent.assertEqual(result.logits.shape							,			(self.batch_size, self.seq_length, self.vocab_size)				)




		def 				UpperCAmelCase__   (self      :	Optional[Any]							,			A__      :	Tuple							,			A__      :	List[Any]							,			A__      :	str							,			A__      :	Optional[Any]							,			A__      :	Optional[int]							,			A__      :	Optional[int]				)					-> Any:
						lowercase         = self.num_labels
						lowercase         = EsmForTokenClassification(config=A__				)
						model.to(A__				)
						model.eval()
						lowercase         = model(A__							,			attention_mask=A__							,			labels=A__				)
						self.parent.assertEqual(result.logits.shape							,			(self.batch_size, self.seq_length, self.num_labels)				)





		def 				UpperCAmelCase__   (self      :	Optional[Any]				)					-> int:
						lowercase         = self.prepare_config_and_inputs()
						(
						    (
						    lowercase							
						)   ,							(
						    lowercase							
						)   ,							(
						    lowercase							
						)   ,							(
						    lowercase							
						)   ,							(
						    lowercase							
						)   ,							(
						    lowercase							
						)   ,														
						)         = config_and_inputs
						lowercase         = {"input_ids": input_ids, "attention_mask": input_mask}
						return config, inputs_dict




@require_torch
class       UpperCAmelCase (						_lowercase			,      _lowercase			,      unittest.TestCase  ):
		UpperCAmelCase					:	int 			=		False

		UpperCAmelCase					:	Optional[int] 			=		(
		    (
		        EsmForMaskedLM,
		        EsmModel,
		        EsmForSequenceClassification,
		        EsmForTokenClassification,
		    )
		    if is_torch_available()
		    else ()
		)
		UpperCAmelCase					:	Dict 			=		()
		UpperCAmelCase					:	Dict 			=		(
		    {
		        '''feature-extraction''': EsmModel,
		        '''fill-mask''': EsmForMaskedLM,
		        '''text-classification''': EsmForSequenceClassification,
		        '''token-classification''': EsmForTokenClassification,
		        '''zero-shot''': EsmForSequenceClassification,
		    }
		    if is_torch_available()
		    else {}
		)
		UpperCAmelCase					:	List[Any] 			=		True




		def 				UpperCAmelCase__   (self      :	List[Any]				)					-> Dict:
						lowercase         = EsmModelTester(self				)
						lowercase         = ConfigTester(self							,			config_class=A__							,			hidden_size=3_7				)




		def 				UpperCAmelCase__   (self      :	Union[str, Any]				)					-> Tuple:
						self.config_tester.run_common_tests()




		def 				UpperCAmelCase__   (self      :	str				)					-> List[Any]:
						lowercase         = self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_model(*A__				)




		def 				UpperCAmelCase__   (self      :	Optional[Any]				)					-> List[str]:
						lowercase         = self.model_tester.prepare_config_and_inputs()
						for type in ["absolute", "relative_key", "relative_key_query"]:
										lowercase         = type
										self.model_tester.create_and_check_model(*A__				)




		def 				UpperCAmelCase__   (self      :	int				)					-> List[Any]:
						lowercase         = self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_masked_lm(*A__				)




		def 				UpperCAmelCase__   (self      :	Optional[int]				)					-> Union[str, Any]:
						lowercase         = self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_token_classification(*A__				)




		@slow
		def 				UpperCAmelCase__   (self      :	int				)					-> Optional[int]:
						for model_name in ESM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
										lowercase         = EsmModel.from_pretrained(A__				)
										self.assertIsNotNone(A__				)




		def 				UpperCAmelCase__   (self      :	Tuple				)					-> Any:
						lowercase         = self.model_tester.prepare_config_and_inputs()[0]
						lowercase         = EsmEmbeddings(config=A__				)

						lowercase         = torch.as_tensor([[1_2, 3_1, 1_3, model.padding_idx]]				)
						lowercase         = torch.as_tensor(
						    [
						        [
						            0 + model.padding_idx + 1,
						            1 + model.padding_idx + 1,
						            2 + model.padding_idx + 1,
						            model.padding_idx,
						        ]
						    ]				)
						lowercase         = create_position_ids_from_input_ids(A__							,			model.padding_idx				)
						self.assertEqual(position_ids.shape							,			expected_positions.shape				)
						self.assertTrue(torch.all(torch.eq(A__							,			A__				)				)				)




		def 				UpperCAmelCase__   (self      :	Optional[int]				)					-> Any:
						lowercase         = self.model_tester.prepare_config_and_inputs()[0]
						lowercase         = EsmEmbeddings(config=A__				)

						lowercase         = torch.empty(2							,			4							,			3_0				)
						lowercase         = [
						    0 + embeddings.padding_idx + 1,
						    1 + embeddings.padding_idx + 1,
						    2 + embeddings.padding_idx + 1,
						    3 + embeddings.padding_idx + 1,
						]
						lowercase         = torch.as_tensor([expected_single_positions, expected_single_positions]				)
						lowercase         = embeddings.create_position_ids_from_inputs_embeds(A__				)
						self.assertEqual(position_ids.shape							,			expected_positions.shape				)
						self.assertTrue(torch.all(torch.eq(A__							,			A__				)				)				)




		@unittest.skip("Esm does not support embedding resizing"				)
		def 				UpperCAmelCase__   (self      :	Optional[Any]				)					-> List[Any]:
						pass




		@unittest.skip("Esm does not support embedding resizing"				)
		def 				UpperCAmelCase__   (self      :	List[str]				)					-> Tuple:
						pass





		@unittest.skip("Will be fixed soon by reducing the size of the model used for common tests."				)
		def 				UpperCAmelCase__   (self      :	Dict				)					-> Tuple:
						pass




@require_torch
class       UpperCAmelCase (						_lowercase  ):




		@slow
		def 				UpperCAmelCase__   (self      :	Dict				)					-> Optional[Any]:
						with torch.no_grad():
										lowercase         = EsmForMaskedLM.from_pretrained("facebook/esm2_t6_8M_UR50D"				)
										model.eval()
										lowercase         = torch.tensor([[0, 1, 2, 3, 4, 5]]				)
										lowercase         = model(A__				)[0]

										lowercase         = 3_3

										lowercase         = torch.Size((1, 6, vocab_size)				)
										self.assertEqual(output.shape							,			A__				)

										lowercase         = torch.tensor(
										    [[[8.9_2_1_5, -1_0.5_8_9_8, -6.4_6_7_1], [-6.3_9_6_7, -1_3.9_1_1_4, -1.1_2_1_2], [-7.7_8_1_2, -1_3.9_5_1_6, -3.7_4_0_6]]]				)
										self.assertTrue(torch.allclose(output[:, :3, :3]							,			A__							,			atol=1e-4				)				)





		@slow
		def 				UpperCAmelCase__   (self      :	Tuple				)					-> Optional[Any]:
						with torch.no_grad():
										lowercase         = EsmModel.from_pretrained("facebook/esm2_t6_8M_UR50D"				)
										model.eval()

										lowercase         = torch.tensor([[0, 6, 4, 1_3, 5, 4, 1_6, 1_2, 1_1, 7, 2]]				)
										lowercase         = model(A__				)[0]
										# compare the actual values for a slice.
										lowercase         = torch.tensor(
										    [[[0.1_4_4_4, 0.5_4_1_3, 0.3_2_4_8], [0.3_0_3_4, 0.0_0_5_3, 0.3_1_0_8], [0.3_2_2_8, -0.2_4_9_9, 0.3_4_1_5]]]				)
										self.assertTrue(torch.allclose(output[:, :3, :3]							,			A__							,			atol=1e-4				)				)











'''simple docstring'''

import functools







def 							UpperCAmelCase_    (	lowerCAmelCase_		,							lowerCAmelCase_							):

				"""simple docstring"""






				if not isinstance(lowerCAmelCase_		,							lowerCAmelCase_							) or not all(isinstance(lowerCAmelCase_		,							lowerCAmelCase_							) for day in days							):
								raise ValueError("The parameter days should be a list of integers"							)

				if len(lowerCAmelCase_							) != 3 or not all(isinstance(lowerCAmelCase_		,							lowerCAmelCase_							) for cost in costs							):
								raise ValueError("The parameter costs should be a list of three integers"							)

				if len(lowerCAmelCase_							) == 0:
								return 0

				if min(lowerCAmelCase_							) <= 0:
								raise ValueError("All days elements should be greater than 0"							)

				if max(lowerCAmelCase_							) >= 366:
								raise ValueError("All days elements should be less than 366"							)

				lowercase         = set(lowerCAmelCase_							)

				@functools.cache
				def dynamic_programming(lowerCAmelCase_							) -> int:
								if index > 365:
												return 0

								if index not in days_set:
												return dynamic_programming(index + 1							)

								return min(
								    costs[0] + dynamic_programming(index + 1							)		,							costs[1] + dynamic_programming(index + 7							)		,							costs[2] + dynamic_programming(index + 30							)		,							)

				return dynamic_programming(1							)


if __name__ == "__main__":
			import doctest

			doctest.testmod()




