




from __future__ import annotations

import os
import tempfile
import unittest

from transformers import ConvBertConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
		import tensorflow as tf

		from transformers import (
		    TFConvBertForMaskedLM,
		    TFConvBertForMultipleChoice,
		    TFConvBertForQuestionAnswering,
		    TFConvBertForSequenceClassification,
		    TFConvBertForTokenClassification,
		    TFConvBertModel,
		)
class 		UpperCAmelCase   :







						'''simple docstring'''





						def __init__(						self							:     Any       ,	__lowercase							:     Dict       ,	__lowercase							:     Union[str, Any]=13       ,	__lowercase							:     Any=7       ,	__lowercase							:     List[Any]=True       ,	__lowercase							:     Union[str, Any]=True       ,	__lowercase							:     Tuple=True       ,	__lowercase							:     Any=True       ,	__lowercase							:     Optional[int]=99       ,	__lowercase							:     List[Any]=32       ,	__lowercase							:     List[Any]=2       ,	__lowercase							:     Tuple=4       ,	__lowercase							:     Optional[int]=37       ,	__lowercase							:     Optional[Any]="gelu"       ,	__lowercase							:     int=0.1       ,	__lowercase							:     Optional[int]=0.1       ,	__lowercase							:     Tuple=5_12       ,	__lowercase							:     int=16       ,	__lowercase							:     int=2       ,	__lowercase							:     int=0.02       ,	__lowercase							:     Union[str, Any]=3       ,	__lowercase							:     List[str]=4       ,	__lowercase							:     Any=None       ,	):






							"""simple docstring"""






							snake_case_		    =     parent
							snake_case_		    =     13
							snake_case_		    =     7
							snake_case_		    =     True
							snake_case_		    =     True
							snake_case_		    =     True
							snake_case_		    =     True
							snake_case_		    =     99
							snake_case_		    =     3_84
							snake_case_		    =     2
							snake_case_		    =     4
							snake_case_		    =     37
							snake_case_		    =     "gelu"
							snake_case_		    =     0.1
							snake_case_		    =     0.1
							snake_case_		    =     5_12
							snake_case_		    =     16
							snake_case_		    =     2
							snake_case_		    =     0.02
							snake_case_		    =     3
							snake_case_		    =     4
							snake_case_		    =     1_28
							snake_case_		    =     2
							snake_case_		    =     9
							snake_case_		    =     1
							snake_case_		    =     None






						def        snake_case__						(						self							:     Optional[int]						):






							"""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
							if self.use_token_type_ids:
								snake_case_		    =     ids_tensor([self.batch_size, self.seq_length]       ,	self.type_vocab_size						)

							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_		    =     ConvBertConfig(
							    vocab_size=self.vocab_size       ,	hidden_size=self.hidden_size       ,	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       ,	return_dict=__lowercase       ,	)

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






						def        snake_case__						(						self							:     List[Any]       ,	__lowercase							:     Any       ,	__lowercase							:     List[Any]       ,	__lowercase							:     List[Any]       ,	__lowercase							:     int       ,	__lowercase							:     int       ,	__lowercase							:     Tuple       ,	__lowercase							:     Dict						):






							"""simple docstring"""






							snake_case_		    =     TFConvBertModel(config=__lowercase						)
							snake_case_		    =     {"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}

							snake_case_		    =     [input_ids, input_mask]
							snake_case_		    =     model(__lowercase						)

							snake_case_		    =     model(__lowercase						)

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






						def        snake_case__						(						self							:     List[Any]       ,	__lowercase							:     Dict       ,	__lowercase							:     int       ,	__lowercase							:     Any       ,	__lowercase							:     Any       ,	__lowercase							:     Optional[Any]       ,	__lowercase							:     Union[str, Any]       ,	__lowercase							:     int						):






							"""simple docstring"""






							snake_case_		    =     TFConvBertForMaskedLM(config=__lowercase						)
							snake_case_		    =     {
							    "input_ids": input_ids,
							    "attention_mask": input_mask,
							    "token_type_ids": token_type_ids,
							}
							snake_case_		    =     model(__lowercase						)
							self.parent.assertEqual(result.logits.shape       ,	(self.batch_size, self.seq_length, self.vocab_size)						)






						def        snake_case__						(						self							:     List[str]       ,	__lowercase							:     Optional[int]       ,	__lowercase							:     Dict       ,	__lowercase							:     List[str]       ,	__lowercase							:     Optional[int]       ,	__lowercase							:     Any       ,	__lowercase							:     Optional[int]       ,	__lowercase							:     Any						):






							"""simple docstring"""






							snake_case_		    =     self.num_labels
							snake_case_		    =     TFConvBertForSequenceClassification(config=__lowercase						)
							snake_case_		    =     {
							    "input_ids": input_ids,
							    "attention_mask": input_mask,
							    "token_type_ids": token_type_ids,
							}

							snake_case_		    =     model(__lowercase						)
							self.parent.assertEqual(result.logits.shape       ,	(self.batch_size, self.num_labels)						)






						def        snake_case__						(						self							:     List[Any]       ,	__lowercase							:     Optional[Any]       ,	__lowercase							:     List[str]       ,	__lowercase							:     Optional[int]       ,	__lowercase							:     Tuple       ,	__lowercase							:     Optional[Any]       ,	__lowercase							:     int       ,	__lowercase							:     Any						):






							"""simple docstring"""






							snake_case_		    =     self.num_choices
							snake_case_		    =     TFConvBertForMultipleChoice(config=__lowercase						)
							snake_case_		    =     tf.tile(tf.expand_dims(__lowercase       ,	1						)       ,	(1, self.num_choices, 1)						)
							snake_case_		    =     tf.tile(tf.expand_dims(__lowercase       ,	1						)       ,	(1, self.num_choices, 1)						)
							snake_case_		    =     tf.tile(tf.expand_dims(__lowercase       ,	1						)       ,	(1, self.num_choices, 1)						)
							snake_case_		    =     {
							    "input_ids": multiple_choice_inputs_ids,
							    "attention_mask": multiple_choice_input_mask,
							    "token_type_ids": multiple_choice_token_type_ids,
							}
							snake_case_		    =     model(__lowercase						)
							self.parent.assertEqual(result.logits.shape       ,	(self.batch_size, self.num_choices)						)






						def        snake_case__						(						self							:     Optional[Any]       ,	__lowercase							:     Any       ,	__lowercase							:     str       ,	__lowercase							:     List[str]       ,	__lowercase							:     Optional[int]       ,	__lowercase							:     Optional[Any]       ,	__lowercase							:     Optional[int]       ,	__lowercase							:     str						):






							"""simple docstring"""






							snake_case_		    =     self.num_labels
							snake_case_		    =     TFConvBertForTokenClassification(config=__lowercase						)
							snake_case_		    =     {
							    "input_ids": input_ids,
							    "attention_mask": input_mask,
							    "token_type_ids": token_type_ids,
							}
							snake_case_		    =     model(__lowercase						)
							self.parent.assertEqual(result.logits.shape       ,	(self.batch_size, self.seq_length, self.num_labels)						)






						def        snake_case__						(						self							:     Optional[int]       ,	__lowercase							:     Tuple       ,	__lowercase							:     Dict       ,	__lowercase							:     Union[str, Any]       ,	__lowercase							:     Tuple       ,	__lowercase							:     Optional[Any]       ,	__lowercase							:     List[Any]       ,	__lowercase							:     Optional[Any]						):






							"""simple docstring"""






							snake_case_		    =     TFConvBertForQuestionAnswering(config=__lowercase						)
							snake_case_		    =     {
							    "input_ids": input_ids,
							    "attention_mask": input_mask,
							    "token_type_ids": token_type_ids,
							}

							snake_case_		    =     model(__lowercase						)
							self.parent.assertEqual(result.start_logits.shape       ,	(self.batch_size, self.seq_length)						)
							self.parent.assertEqual(result.end_logits.shape       ,	(self.batch_size, self.seq_length)						)






						def        snake_case__						(						self							:     Tuple						):






							"""simple docstring"""






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







@require_tf
class 		UpperCAmelCase   (				UpperCAmelCase__       ,   UpperCAmelCase__       ,   unittest.TestCase			):







						'''simple docstring'''





						lowerCAmelCase_     		=   (
						    (
						        TFConvBertModel,
						        TFConvBertForMaskedLM,
						        TFConvBertForQuestionAnswering,
						        TFConvBertForSequenceClassification,
						        TFConvBertForTokenClassification,
						        TFConvBertForMultipleChoice,
						    )
						    if is_tf_available()
						    else ()
						)
						lowerCAmelCase_     		=   (
						    {
						        '''feature-extraction''': TFConvBertModel,
						        '''fill-mask''': TFConvBertForMaskedLM,
						        '''question-answering''': TFConvBertForQuestionAnswering,
						        '''text-classification''': TFConvBertForSequenceClassification,
						        '''token-classification''': TFConvBertForTokenClassification,
						        '''zero-shot''': TFConvBertForSequenceClassification,
						    }
						    if is_tf_available()
						    else {}
						)
						lowerCAmelCase_     		=   False
						lowerCAmelCase_     		=   False
						lowerCAmelCase_     		=   False






						def        snake_case__						(						self							:     Dict						):






							"""simple docstring"""






							snake_case_		    =     TFConvBertModelTester(self						)
							snake_case_		    =     ConfigTester(self       ,	config_class=__lowercase       ,	hidden_size=37						)






						def        snake_case__						(						self							:     str						):






							"""simple docstring"""






							self.config_tester.run_common_tests()






						def        snake_case__						(						self							:     Dict						):






							"""simple docstring"""






							snake_case_		    =     self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*__lowercase						)






						def        snake_case__						(						self							:     Dict						):






							"""simple docstring"""






							snake_case_		    =     self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_masked_lm(*__lowercase						)






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






							"""simple docstring"""






							snake_case_		    =     self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_multiple_choice(*__lowercase						)






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






							"""simple docstring"""






							snake_case_		    =     self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_question_answering(*__lowercase						)






						def        snake_case__						(						self							:     List[Any]						):






							"""simple docstring"""






							snake_case_		    =     self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_sequence_classification(*__lowercase						)






						def        snake_case__						(						self							:     Dict						):






							"""simple docstring"""






							snake_case_		    =     self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_token_classification(*__lowercase						)






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






							"""simple docstring"""






							snake_case_    ,      snake_case_		    =     self.model_tester.prepare_config_and_inputs_for_common()
							snake_case_		    =     True
							snake_case_		    =     True

							if hasattr(__lowercase       ,	"use_cache"						):
								snake_case_		    =     True

							snake_case_		    =     getattr(self.model_tester       ,	"encoder_seq_length"       ,	self.model_tester.seq_length						)
							snake_case_		    =     getattr(self.model_tester       ,	"key_length"       ,	__lowercase						)

							for model_class in self.all_model_classes:
								snake_case_		    =     self._prepare_for_class(__lowercase       ,	__lowercase						)
								snake_case_		    =     model_class(__lowercase						)
								snake_case_		    =     len(model(__lowercase						)						)

								with tempfile.TemporaryDirectory() as tmpdirname:
									model.save_pretrained(__lowercase       ,	saved_model=__lowercase						)
									snake_case_		    =     os.path.join(__lowercase       ,	"saved_model"       ,	"1"						)
									snake_case_		    =     tf.keras.models.load_model(__lowercase						)
									snake_case_		    =     model(__lowercase						)

									if self.is_encoder_decoder:
										snake_case_		    =     outputs["encoder_hidden_states"]
										snake_case_		    =     outputs["encoder_attentions"]
									else:
										snake_case_		    =     outputs["hidden_states"]
										snake_case_		    =     outputs["attentions"]

									self.assertEqual(len(__lowercase						)       ,	__lowercase						)

									snake_case_		    =     getattr(
									    self.model_tester       ,	"expected_num_hidden_layers"       ,	self.model_tester.num_hidden_layers + 1						)

									self.assertEqual(len(__lowercase						)       ,	__lowercase						)
									self.assertListEqual(
									    list(output_hidden_states[0].shape[-2:]						)       ,	[self.model_tester.seq_length, self.model_tester.hidden_size]       ,	)

									self.assertEqual(len(__lowercase						)       ,	self.model_tester.num_hidden_layers						)
									self.assertListEqual(
									    list(output_attentions[0].shape[-3:]						)       ,	[self.model_tester.num_attention_heads / 2, encoder_seq_length, encoder_key_length]       ,	)






						@slow
						def        snake_case__						(						self							:     Optional[int]						):






							"""simple docstring"""






							snake_case_		    =     TFConvBertModel.from_pretrained("YituTech/conv-bert-base"						)
							self.assertIsNotNone(__lowercase						)






						def        snake_case__						(						self							:     Optional[Any]						):






							"""simple docstring"""






							snake_case_    ,      snake_case_		    =     self.model_tester.prepare_config_and_inputs_for_common()
							snake_case_		    =     True
							snake_case_		    =     getattr(self.model_tester       ,	"decoder_seq_length"       ,	self.model_tester.seq_length						)
							snake_case_		    =     getattr(self.model_tester       ,	"encoder_seq_length"       ,	self.model_tester.seq_length						)
							snake_case_		    =     getattr(self.model_tester       ,	"key_length"       ,	__lowercase						)
							snake_case_		    =     getattr(self.model_tester       ,	"key_length"       ,	__lowercase						)

							def check_decoder_attentions_output(__lowercase							:     int						):
								snake_case_		    =     len(__lowercase						)
								self.assertEqual(out_len % 2       ,	0						)
								snake_case_		    =     outputs.decoder_attentions
								self.assertEqual(len(__lowercase						)       ,	self.model_tester.num_hidden_layers						)
								self.assertListEqual(
								    list(decoder_attentions[0].shape[-3:]						)       ,	[self.model_tester.num_attention_heads / 2, decoder_seq_length, decoder_key_length]       ,	)

							def check_encoder_attentions_output(__lowercase							:     List[Any]						):
								snake_case_		    =     [
								    t.numpy() for t in (outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions)
								]
								self.assertEqual(len(__lowercase						)       ,	self.model_tester.num_hidden_layers						)
								self.assertListEqual(
								    list(attentions[0].shape[-3:]						)       ,	[self.model_tester.num_attention_heads / 2, encoder_seq_length, encoder_key_length]       ,	)

							for model_class in self.all_model_classes:
								snake_case_		    =     True
								snake_case_		    =     False
								snake_case_		    =     model_class(__lowercase						)
								snake_case_		    =     model(self._prepare_for_class(__lowercase       ,	__lowercase						)						)
								snake_case_		    =     len(__lowercase						)
								self.assertEqual(config.output_hidden_states       ,	__lowercase						)
								check_encoder_attentions_output(__lowercase						)

								if self.is_encoder_decoder:
									snake_case_		    =     model_class(__lowercase						)
									snake_case_		    =     model(self._prepare_for_class(__lowercase       ,	__lowercase						)						)
									self.assertEqual(config.output_hidden_states       ,	__lowercase						)
									check_decoder_attentions_output(__lowercase						)

								# Check that output attentions can also be changed via the config
								del inputs_dict["output_attentions"]
								snake_case_		    =     True
								snake_case_		    =     model_class(__lowercase						)
								snake_case_		    =     model(self._prepare_for_class(__lowercase       ,	__lowercase						)						)
								self.assertEqual(config.output_hidden_states       ,	__lowercase						)
								check_encoder_attentions_output(__lowercase						)

								# Check attention is always last and order is fine
								snake_case_		    =     True
								snake_case_		    =     True
								snake_case_		    =     model_class(__lowercase						)
								snake_case_		    =     model(self._prepare_for_class(__lowercase       ,	__lowercase						)						)

								self.assertEqual(out_len + (2 if self.is_encoder_decoder else 1)       ,	len(__lowercase						)						)
								self.assertEqual(model.config.output_hidden_states       ,	__lowercase						)
								check_encoder_attentions_output(__lowercase						)







@require_tf
class 		UpperCAmelCase   (				unittest.TestCase			):







						'''simple docstring'''





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






							"""simple docstring"""






							snake_case_		    =     TFConvBertModel.from_pretrained("YituTech/conv-bert-base"						)
							snake_case_		    =     tf.constant([[0, 1, 2, 3, 4, 5]]						)
							snake_case_		    =     model(__lowercase						)[0]

							snake_case_		    =     [1, 6, 7_68]
							self.assertEqual(output.shape       ,	__lowercase						)

							snake_case_		    =     tf.constant(
							    [
							        [
							            [-0.0347_5493, -0.468_6034, -0.3063_8832],
							            [0.2263_7248, -0.2698_8646, -0.742_3424],
							            [0.1032_4868, -0.4501_3508, -0.5828_0784],
							        ]
							    ]						)
							tf.debugging.assert_near(output[:, :3, :3]       ,	__lowercase       ,	atol=1E-4						)






import functools


def 						lowerCamelCase__    (		_A     ,	_A							):







	'''simple docstring'''





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

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

	if len(_A							) == 0:
		return 0

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

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

	snake_case_		    =     set(_A							)

	@functools.cache
	def dynamic_programming(_A							) -> 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()
