


import unittest

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

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
							import torch

							from transformers import (
							    OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST,
							    OpenAIGPTConfig,
							    OpenAIGPTDoubleHeadsModel,
							    OpenAIGPTForSequenceClassification,
							    OpenAIGPTLMHeadModel,
							    OpenAIGPTModel,
							)

class 						A__							:




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


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  =parent
										_SCREAMING_SNAKE_CASE			  =batch_size
										_SCREAMING_SNAKE_CASE			  =seq_length
										_SCREAMING_SNAKE_CASE			  =is_training
										_SCREAMING_SNAKE_CASE			  =use_token_type_ids
										_SCREAMING_SNAKE_CASE			  =use_labels
										_SCREAMING_SNAKE_CASE			  =vocab_size
										_SCREAMING_SNAKE_CASE			  =hidden_size
										_SCREAMING_SNAKE_CASE			  =num_hidden_layers
										_SCREAMING_SNAKE_CASE			  =num_attention_heads
										_SCREAMING_SNAKE_CASE			  =intermediate_size
										_SCREAMING_SNAKE_CASE			  =hidden_act
										_SCREAMING_SNAKE_CASE			  =hidden_dropout_prob
										_SCREAMING_SNAKE_CASE			  =attention_probs_dropout_prob
										_SCREAMING_SNAKE_CASE			  =max_position_embeddings
										_SCREAMING_SNAKE_CASE			  =type_vocab_size
										_SCREAMING_SNAKE_CASE			  =type_sequence_label_size
										_SCREAMING_SNAKE_CASE			  =initializer_range
										_SCREAMING_SNAKE_CASE			  =num_labels
										_SCREAMING_SNAKE_CASE			  =num_choices
										_SCREAMING_SNAKE_CASE			  =scope
										_SCREAMING_SNAKE_CASE			  =self.vocab_size - 1




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


										"""simple docstring"""





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

										_SCREAMING_SNAKE_CASE			  =None
										if self.use_token_type_ids:
														_SCREAMING_SNAKE_CASE			  =ids_tensor([self.batch_size, self.seq_length]				,    self.type_vocab_size  )

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

										_SCREAMING_SNAKE_CASE			  =OpenAIGPTConfig(
										    vocab_size=self.vocab_size				,    n_embd=self.hidden_size				,    n_layer=self.num_hidden_layers				,    n_head=self.num_attention_heads				,    n_positions=self.max_position_embeddings				,    pad_token_id=self.pad_token_id				,    )

										_SCREAMING_SNAKE_CASE			  =ids_tensor([self.num_hidden_layers, self.num_attention_heads]				,    2  )

										return (
										    config,
										    input_ids,
										    head_mask,
										    token_type_ids,
										    sequence_labels,
										    token_labels,
										    choice_labels,
										)




						def 							__UpperCamelCase				(       self					:      Optional[int]				,    _a					:      List[str]				,    _a					:      str				,    _a					:      Optional[int]				,    _a					:      int				,    *_a					:      Dict  )							->     List[Any]:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  =OpenAIGPTModel(config=_a  )
										model.to(_a  )
										model.eval()

										_SCREAMING_SNAKE_CASE			  =model(_a				,    token_type_ids=_a				,    head_mask=_a  )
										_SCREAMING_SNAKE_CASE			  =model(_a				,    token_type_ids=_a  )
										_SCREAMING_SNAKE_CASE			  =model(_a  )

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




						def 							__UpperCamelCase				(       self					:      Union[str, Any]				,    _a					:      int				,    _a					:      str				,    _a					:      int				,    _a					:      Any				,    *_a					:      Tuple  )							->     str:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  =OpenAIGPTLMHeadModel(_a  )
										model.to(_a  )
										model.eval()

										_SCREAMING_SNAKE_CASE			  =model(_a				,    token_type_ids=_a				,    labels=_a  )
										self.parent.assertEqual(result.loss.shape				,    ()  )
										self.parent.assertEqual(result.logits.shape				,    (self.batch_size, self.seq_length, self.vocab_size)  )




						def 							__UpperCamelCase				(       self					:      Union[str, Any]				,    _a					:      Union[str, Any]				,    _a					:      Optional[int]				,    _a					:      Optional[Any]				,    _a					:      Tuple				,    *_a					:      List[str]  )							->     Tuple:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  =OpenAIGPTDoubleHeadsModel(_a  )
										model.to(_a  )
										model.eval()

										_SCREAMING_SNAKE_CASE			  =model(_a				,    token_type_ids=_a				,    labels=_a  )
										self.parent.assertEqual(result.loss.shape				,    ()  )
										self.parent.assertEqual(result.logits.shape				,    (self.batch_size, self.seq_length, self.vocab_size)  )




						def 							__UpperCamelCase				(       self					:      Optional[Any]				,    _a					:      Optional[int]				,    _a					:      Any				,    _a					:      Union[str, Any]				,    _a					:      int				,    *_a					:      Optional[Any]  )							->     List[Any]:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  =self.num_labels
										_SCREAMING_SNAKE_CASE			  =OpenAIGPTForSequenceClassification(_a  )
										model.to(_a  )
										model.eval()

										_SCREAMING_SNAKE_CASE			  =ids_tensor([self.batch_size]				,    self.type_sequence_label_size  )
										_SCREAMING_SNAKE_CASE			  =model(_a				,    token_type_ids=_a				,    labels=_a  )
										self.parent.assertEqual(result.logits.shape				,    (self.batch_size, self.num_labels)  )




						def 							__UpperCamelCase				(       self					:      Tuple  )							->     Dict:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  =self.prepare_config_and_inputs()
										(
										    (
										    _SCREAMING_SNAKE_CASE
										)  ,				(
										    _SCREAMING_SNAKE_CASE
										)  ,				(
										    _SCREAMING_SNAKE_CASE
										)  ,				(
										    _SCREAMING_SNAKE_CASE
										)  ,				(
										    _SCREAMING_SNAKE_CASE
										)  ,				(
										    _SCREAMING_SNAKE_CASE
										)  ,				(
										    _SCREAMING_SNAKE_CASE
										)  ,				
										)			  =config_and_inputs
										_SCREAMING_SNAKE_CASE			  ={
										    '''input_ids''': input_ids,
										    '''token_type_ids''': token_type_ids,
										    '''head_mask''': head_mask,
										}

										return config, inputs_dict

@require_torch
class 						A__							(		UpperCamelCase__   ,     UpperCamelCase__   ,     UpperCamelCase__   ,     unittest.TestCase  ):
						UpperCAmelCase             =						(
						    (OpenAIGPTModel, OpenAIGPTLMHeadModel, OpenAIGPTDoubleHeadsModel, OpenAIGPTForSequenceClassification)
						    if is_torch_available()
						    else ()
						)
						UpperCAmelCase             =						(
						    (OpenAIGPTLMHeadModel,) if is_torch_available() else ()
						)  # TODO (PVP): Add Double HeadsModel when generate() function is changed accordingly
						UpperCAmelCase             =						(
						    {
						        "feature-extraction": OpenAIGPTModel,
						        "text-classification": OpenAIGPTForSequenceClassification,
						        "text-generation": OpenAIGPTLMHeadModel,
						        "zero-shot": OpenAIGPTForSequenceClassification,
						    }
						    if is_torch_available()
						    else {}
						)




						def 							__UpperCamelCase				(       self					:      Tuple				,    _a					:      str				,    _a					:      Optional[Any]				,    _a					:      Dict				,    _a					:      Union[str, Any]				,    _a					:      str  )							->     str:


										"""simple docstring"""





										if pipeline_test_casse_name == "ZeroShotClassificationPipelineTests":
														# Get `tokenizer does not have a padding token` error for both fast/slow tokenizers.
														# `OpenAIGPTConfig` was never used in pipeline tests, either because of a missing checkpoint or because a
														# tiny config could not be created.
														return True

										return False




						def 							__UpperCamelCase				(       self					:      List[Any]				,    _a					:      Optional[Any]				,    _a					:      List[Any]				,    _a					:      Union[str, Any]=False  )							->     Union[str, Any]:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  =super()._prepare_for_class(_a				,    _a				,    return_labels=_a  )

										if return_labels:
														if model_class.__name__ == "OpenAIGPTDoubleHeadsModel":
																		_SCREAMING_SNAKE_CASE			  =torch.zeros(
																		    (self.model_tester.batch_size, self.model_tester.num_choices, self.model_tester.seq_length)				,    dtype=torch.long				,    device=_a				,    )
																		_SCREAMING_SNAKE_CASE			  =inputs_dict['''labels''']
																		_SCREAMING_SNAKE_CASE			  =inputs_dict['''labels''']
																		_SCREAMING_SNAKE_CASE			  =torch.zeros(
																		    (self.model_tester.batch_size, self.model_tester.num_choices)				,    dtype=torch.long				,    device=_a				,    )
																		_SCREAMING_SNAKE_CASE			  =torch.zeros(
																		    self.model_tester.batch_size				,    dtype=torch.long				,    device=_a  )
										return inputs_dict




						def 							__UpperCamelCase				(       self					:      List[Any]  )							->     Tuple:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  =OpenAIGPTModelTester(self  )
										_SCREAMING_SNAKE_CASE			  =ConfigTester(self				,    config_class=_a				,    n_embd=37  )




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


										"""simple docstring"""





										self.config_tester.run_common_tests()




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


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  =self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_openai_gpt_model(*_a  )




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


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  =self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_lm_head_model(*_a  )




						def 							__UpperCamelCase				(       self					:      Tuple  )							->     int:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  =self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_double_lm_head_model(*_a  )




						def 							__UpperCamelCase				(       self					:      List[str]  )							->     Optional[int]:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  =self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_openai_gpt_for_sequence_classification(*_a  )




						@slow
						def 							__UpperCamelCase				(       self					:      Any  )							->     int:


										"""simple docstring"""





										for model_name in OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
														_SCREAMING_SNAKE_CASE			  =OpenAIGPTModel.from_pretrained(_a  )
														self.assertIsNotNone(_a  )

@require_torch
class 						A__							(		unittest.TestCase  ):




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


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  =OpenAIGPTLMHeadModel.from_pretrained('''openai-gpt'''  )
										model.to(_a  )
										_SCREAMING_SNAKE_CASE			  =torch.tensor([[481, 4735, 544]]				,    dtype=torch.long				,    device=_a  )  # the president is
										_SCREAMING_SNAKE_CASE			  =[
										    481,
										    4735,
										    544,
										    246,
										    963,
										    870,
										    762,
										    239,
										    244,
										    4_0477,
										    244,
										    249,
										    719,
										    881,
										    487,
										    544,
										    240,
										    244,
										    603,
										    481,
										]  # the president is a very good man. " \n " i\'m sure he is, " said the

										_SCREAMING_SNAKE_CASE			  =model.generate(_a				,    do_sample=_a  )
										self.assertListEqual(output_ids[0].tolist()				,    _a  )



snake_case_						:			dict[tuple[int, int, int], int]													=							{}







def 						lowerCamelCase(   a__	,a__	,a__):

				# if we are absent twice, or late 3 consecutive days,
				# no further prize strings are possible
				if late == 3 or absent == 2:
								return 0

				# if we have no days left, and have not failed any other rules,
				# we have a prize string
				if days == 0:
								return 1

				# No easy solution, so now we need to do the recursive calculation

				# First, check if the combination is already in the cache, and
				# if yes, return the stored value from there since we already
				# know the number of possible prize strings from this point on
				_SCREAMING_SNAKE_CASE			  =(days, absent, late)
				if key in cache:
								return cache[key]

				# now we calculate the three possible ways that can unfold from
				# this point on, depending on our attendance today

				# 1) if we are late (but not absent), the "absent" counter stays as
				# it is, but the "late" counter increases by one
				_SCREAMING_SNAKE_CASE			  =_calculate(days - 1	,a__	,late + 1)

				# 2) if we are absent, the "absent" counter increases by 1, and the
				# "late" counter resets to 0
				_SCREAMING_SNAKE_CASE			  =_calculate(days - 1	,absent + 1	,0)

				# 3) if we are on time, this resets the "late" counter and keeps the
				# absent counter
				_SCREAMING_SNAKE_CASE			  =_calculate(days - 1	,a__	,0)

				_SCREAMING_SNAKE_CASE			  =state_late + state_absent + state_ontime

				_SCREAMING_SNAKE_CASE			  =prizestrings
				return prizestrings







def 						lowerCamelCase(   a__ = 30):
				return _calculate(a__	,absent=0	,late=0)


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