





"""simple docstring"""




import os
from datetime import datetime as dt

from github import Github


UpperCamelCase_									=[
    """good first issue""",
    """good second issue""",
    """good difficult issue""",
    """enhancement""",
    """new pipeline/model""",
    """new scheduler""",
    """wip""",
]





def 	a_    (							):
						_UpperCamelCase      : str         =   Github(os.environ['''GITHUB_TOKEN''']       )
						_UpperCamelCase      : List[Any]         =   g.get_repo('''huggingface/diffusers'''       )
						_UpperCamelCase      : Any         =   repo.get_issues(state='''open'''       )

						for issue in open_issues:
												_UpperCamelCase      : Optional[int]         =   sorted(issue.get_comments()	,						key=lambda _lowercase       : i.created_at	,						reverse=_lowercase       )
												_UpperCamelCase      : Optional[Any]         =   comments[0] if len(_lowercase       ) > 0 else None
												if (
												    last_comment is not None
												    and last_comment.user.login == "github-actions[bot]"
												    and (dt.utcnow() - issue.updated_at).days > 7
												    and (dt.utcnow() - issue.created_at).days >= 30
												    and not any(label.name.lower() in LABELS_TO_EXEMPT for label in issue.get_labels()       )
												):
																		# Closes the issue after 7 days of inactivity since the Stalebot notification.
																		issue.edit(state='''closed'''       )
												elif (
												    "stale" in issue.get_labels()
												    and last_comment is not None
												    and last_comment.user.login != "github-actions[bot]"
												):
																		# Opens the issue if someone other than Stalebot commented.
																		issue.edit(state='''open'''       )
																		issue.remove_from_labels('''stale'''       )
												elif (
												    (dt.utcnow() - issue.updated_at).days > 23
												    and (dt.utcnow() - issue.created_at).days >= 30
												    and not any(label.name.lower() in LABELS_TO_EXEMPT for label in issue.get_labels()       )
												):
																		# Post a Stalebot notification after 23 days of inactivity.
																		issue.create_comment(
																		    '''This issue has been automatically marked as stale because it has not had '''
																		    '''recent activity. If you think this still needs to be addressed '''
																		    '''please comment on this thread.\n\nPlease note that issues that do not follow the '''
																		    '''[contributing guidelines](https://github.com/huggingface/diffusers/blob/main/CONTRIBUTING.md) '''
																		    '''are likely to be ignored.'''       )
																		issue.add_to_labels('''stale'''       )


if __name__ == "__main__":
						main()










"""simple docstring"""




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		:   Dict,			lowerCAmelCase__		:   Optional[Any],			lowerCAmelCase__		:   Optional[int]=1_3,			lowerCAmelCase__		:   Optional[Any]=7,			lowerCAmelCase__		:   Optional[Any]=True,			lowerCAmelCase__		:   Any=True,			lowerCAmelCase__		:   str=True,			lowerCAmelCase__		:   Any=9_9,			lowerCAmelCase__		:   Dict=3_2,			lowerCAmelCase__		:   List[Any]=5,			lowerCAmelCase__		:   Tuple=4,			lowerCAmelCase__		:   List[Any]=3_7,			lowerCAmelCase__		:   Tuple="gelu",			lowerCAmelCase__		:   Any=0.1,			lowerCAmelCase__		:   Optional[Any]=0.1,			lowerCAmelCase__		:   Dict=5_1_2,			lowerCAmelCase__		:   List[str]=1_6,			lowerCAmelCase__		:   Tuple=2,			lowerCAmelCase__		:   int=0.02,			lowerCAmelCase__		:   int=3,			lowerCAmelCase__		:   Optional[Any]=4,			lowerCAmelCase__		:   Dict=None,			)     ->				int:




										'''simple docstring'''



										_UpperCamelCase      : Tuple         =   parent
										_UpperCamelCase      : Union[str, Any]         =   batch_size
										_UpperCamelCase      : Union[str, Any]         =   seq_length
										_UpperCamelCase      : Tuple         =   is_training
										_UpperCamelCase      : Tuple         =   use_token_type_ids
										_UpperCamelCase      : Optional[int]         =   use_labels
										_UpperCamelCase      : Dict         =   vocab_size
										_UpperCamelCase      : int         =   hidden_size
										_UpperCamelCase      : Optional[Any]         =   num_hidden_layers
										_UpperCamelCase      : str         =   num_attention_heads
										_UpperCamelCase      : Union[str, Any]         =   intermediate_size
										_UpperCamelCase      : List[str]         =   hidden_act
										_UpperCamelCase      : Optional[Any]         =   hidden_dropout_prob
										_UpperCamelCase      : int         =   attention_probs_dropout_prob
										_UpperCamelCase      : Union[str, Any]         =   max_position_embeddings
										_UpperCamelCase      : int         =   type_vocab_size
										_UpperCamelCase      : List[str]         =   type_sequence_label_size
										_UpperCamelCase      : List[str]         =   initializer_range
										_UpperCamelCase      : int         =   num_labels
										_UpperCamelCase      : List[str]         =   num_choices
										_UpperCamelCase      : str         =   scope
										_UpperCamelCase      : Optional[int]         =   self.vocab_size - 1






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




										'''simple docstring'''



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

										_UpperCamelCase      : List[str]         =   None
										if self.use_token_type_ids:
																_UpperCamelCase      : Tuple         =   ids_tensor([self.batch_size, self.seq_length],			self.type_vocab_size							)

										_UpperCamelCase      : Optional[int]         =   None
										_UpperCamelCase      : str         =   None
										_UpperCamelCase      : List[str]         =   None
										if self.use_labels:
																_UpperCamelCase      : int         =   ids_tensor([self.batch_size],			self.type_sequence_label_size							)
																_UpperCamelCase      : Dict         =   ids_tensor([self.batch_size, self.seq_length],			self.num_labels							)
																_UpperCamelCase      : Dict         =   ids_tensor([self.batch_size],			self.num_choices							)

										_UpperCamelCase      : str         =   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,			)

										_UpperCamelCase      : List[Any]         =   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     snake_case     (			self		:   Union[str, Any],			lowerCAmelCase__		:   Optional[int],			lowerCAmelCase__		:   List[str],			lowerCAmelCase__		:   List[str],			lowerCAmelCase__		:   List[str],			*lowerCAmelCase__		:   List[Any]							)     ->				Optional[Any]:




										'''simple docstring'''



										_UpperCamelCase      : Dict         =   OpenAIGPTModel(config=lowerCAmelCase__							)
										model.to(lowerCAmelCase__							)
										model.eval()

										_UpperCamelCase      : List[str]         =   model(lowerCAmelCase__,			token_type_ids=lowerCAmelCase__,			head_mask=lowerCAmelCase__							)
										_UpperCamelCase      : Any         =   model(lowerCAmelCase__,			token_type_ids=lowerCAmelCase__							)
										_UpperCamelCase      : List[str]         =   model(lowerCAmelCase__							)

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






				def     snake_case     (			self		:   Any,			lowerCAmelCase__		:   Tuple,			lowerCAmelCase__		:   Union[str, Any],			lowerCAmelCase__		:   Any,			lowerCAmelCase__		:   Optional[Any],			*lowerCAmelCase__		:   Union[str, Any]							)     ->				Any:




										'''simple docstring'''



										_UpperCamelCase      : Any         =   OpenAIGPTLMHeadModel(lowerCAmelCase__							)
										model.to(lowerCAmelCase__							)
										model.eval()

										_UpperCamelCase      : Tuple         =   model(lowerCAmelCase__,			token_type_ids=lowerCAmelCase__,			labels=lowerCAmelCase__							)
										self.parent.assertEqual(result.loss.shape,			()							)
										self.parent.assertEqual(result.logits.shape,			(self.batch_size, self.seq_length, self.vocab_size)							)






				def     snake_case     (			self		:   Optional[int],			lowerCAmelCase__		:   str,			lowerCAmelCase__		:   List[str],			lowerCAmelCase__		:   Any,			lowerCAmelCase__		:   List[Any],			*lowerCAmelCase__		:   Any							)     ->				int:




										'''simple docstring'''



										_UpperCamelCase      : Tuple         =   OpenAIGPTDoubleHeadsModel(lowerCAmelCase__							)
										model.to(lowerCAmelCase__							)
										model.eval()

										_UpperCamelCase      : Optional[int]         =   model(lowerCAmelCase__,			token_type_ids=lowerCAmelCase__,			labels=lowerCAmelCase__							)
										self.parent.assertEqual(result.loss.shape,			()							)
										self.parent.assertEqual(result.logits.shape,			(self.batch_size, self.seq_length, self.vocab_size)							)






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




										'''simple docstring'''



										_UpperCamelCase      : List[Any]         =   self.num_labels
										_UpperCamelCase      : Optional[int]         =   OpenAIGPTForSequenceClassification(lowerCAmelCase__							)
										model.to(lowerCAmelCase__							)
										model.eval()

										_UpperCamelCase      : str         =   ids_tensor([self.batch_size],			self.type_sequence_label_size							)
										_UpperCamelCase      : Union[str, Any]         =   model(lowerCAmelCase__,			token_type_ids=lowerCAmelCase__,			labels=lowerCAmelCase__							)
										self.parent.assertEqual(result.logits.shape,			(self.batch_size, self.num_labels)							)






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




										'''simple docstring'''



										_UpperCamelCase      : Any         =   self.prepare_config_and_inputs()
										(
										    (
										    _UpperCamelCase
										)       ,							(
										    _UpperCamelCase
										)       ,							(
										    _UpperCamelCase
										)       ,							(
										    _UpperCamelCase
										)       ,							(
										    _UpperCamelCase
										)       ,							(
										    _UpperCamelCase
										)       ,							(
										    _UpperCamelCase
										)       ,							
										)      : Tuple         =   config_and_inputs
										_UpperCamelCase      : Tuple         =   {
										    '''input_ids''': input_ids,
										    '''token_type_ids''': token_type_ids,
										    '''head_mask''': head_mask,
										}

										return config, inputs_dict




@require_torch
class 			_a						(				_lowerCAmelCase     ,    _lowerCAmelCase     ,    _lowerCAmelCase     ,    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     snake_case     (			self		:   Union[str, Any],			lowerCAmelCase__		:   Any,			lowerCAmelCase__		:   List[str],			lowerCAmelCase__		:   str,			lowerCAmelCase__		:   List[str],			lowerCAmelCase__		:   List[str]							)     ->				List[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     snake_case     (			self		:   str,			lowerCAmelCase__		:   Optional[int],			lowerCAmelCase__		:   List[str],			lowerCAmelCase__		:   Optional[int]=False							)     ->				Tuple:




										'''simple docstring'''



										_UpperCamelCase      : Optional[Any]         =   super()._prepare_for_class(lowerCAmelCase__,			lowerCAmelCase__,			return_labels=lowerCAmelCase__							)

										if return_labels:
																if model_class.__name__ == "OpenAIGPTDoubleHeadsModel":
																						_UpperCamelCase      : Union[str, Any]         =   torch.zeros(
																						    (self.model_tester.batch_size, self.model_tester.num_choices, self.model_tester.seq_length),			dtype=torch.long,			device=lowerCAmelCase__,			)
																						_UpperCamelCase      : Tuple         =   inputs_dict['''labels''']
																						_UpperCamelCase      : List[str]         =   inputs_dict['''labels''']
																						_UpperCamelCase      : Optional[Any]         =   torch.zeros(
																						    (self.model_tester.batch_size, self.model_tester.num_choices),			dtype=torch.long,			device=lowerCAmelCase__,			)
																						_UpperCamelCase      : Dict         =   torch.zeros(
																						    self.model_tester.batch_size,			dtype=torch.long,			device=lowerCAmelCase__							)
										return inputs_dict






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




										'''simple docstring'''



										_UpperCamelCase      : Optional[Any]         =   OpenAIGPTModelTester(self							)
										_UpperCamelCase      : int         =   ConfigTester(self,			config_class=lowerCAmelCase__,			n_embd=3_7							)






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




										'''simple docstring'''



										self.config_tester.run_common_tests()






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




										'''simple docstring'''



										_UpperCamelCase      : List[Any]         =   self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_openai_gpt_model(*lowerCAmelCase__							)






				def     snake_case     (			self		:   Any							)     ->				Dict:




										'''simple docstring'''



										_UpperCamelCase      : Union[str, Any]         =   self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_lm_head_model(*lowerCAmelCase__							)






				def     snake_case     (			self		:   int							)     ->				Dict:




										'''simple docstring'''



										_UpperCamelCase      : Union[str, Any]         =   self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_double_lm_head_model(*lowerCAmelCase__							)






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




										'''simple docstring'''



										_UpperCamelCase      : List[Any]         =   self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_openai_gpt_for_sequence_classification(*lowerCAmelCase__							)






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




										'''simple docstring'''



										for model_name in OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																_UpperCamelCase      : int         =   OpenAIGPTModel.from_pretrained(lowerCAmelCase__							)
																self.assertIsNotNone(lowerCAmelCase__							)




@require_torch
class 			_a						(				unittest.TestCase    ):






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




										'''simple docstring'''



										_UpperCamelCase      : int         =   OpenAIGPTLMHeadModel.from_pretrained('''openai-gpt'''							)
										model.to(lowerCAmelCase__							)
										_UpperCamelCase      : str         =   torch.tensor([[4_8_1, 4_7_3_5, 5_4_4]],			dtype=torch.long,			device=lowerCAmelCase__							)  # the president is
										_UpperCamelCase      : Optional[int]         =   [
										    4_8_1,
										    4_7_3_5,
										    5_4_4,
										    2_4_6,
										    9_6_3,
										    8_7_0,
										    7_6_2,
										    2_3_9,
										    2_4_4,
										    4_0_4_7_7,
										    2_4_4,
										    2_4_9,
										    7_1_9,
										    8_8_1,
										    4_8_7,
										    5_4_4,
										    2_4_0,
										    2_4_4,
										    6_0_3,
										    4_8_1,
										]  # the president is a very good man. " \n " i\'m sure he is, " said the

										_UpperCamelCase      : Union[str, Any]         =   model.generate(lowerCAmelCase__,			do_sample=lowerCAmelCase__							)
										self.assertListEqual(output_ids[0].tolist(),			lowerCAmelCase__							)



