






from datetime import datetime as dt
import os

from github import Github


UpperCAmelCase__				   =		[
    "good first issue",
    "good second issue",
    "good difficult issue",
    "feature request",
    "new model",
    "wip",
]
def 						_a    (      )							->			Tuple:
 a		  =      Github(os.environ['''GITHUB_TOKEN'''] )
 a		  =      g.get_repo('''huggingface/transformers''' )
 a		  =      repo.get_issues(state='''open''' )

 for issue in open_issues:
  a		  =      sorted([comment for comment in issue.get_comments()]	,							key=lambda a : i.created_at	,							reverse=a )
  a		  =      comments[0] if len(a ) > 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() )
  ):
   # print(f"Would close issue {issue.number} since it has been 7 days of inactivity since bot mention.")
   issue.edit(state='''closed''' )
  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() )
  ):
   # print(f"Would add stale comment to {issue.number}")
   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/transformers/blob/main/CONTRIBUTING.md) '''
       '''are likely to be ignored.''' )


if __name__ == "__main__":
     main()







'''simple docstring'''




import unittest

import numpy as np

from transformers import DistilBertConfig, is_flax_available
from transformers.testing_utils import require_flax, slow

from ...test_modeling_flax_common import FlaxModelTesterMixin, ids_tensor, random_attention_mask


if is_flax_available():
						import jax.numpy as jnp

						from transformers.models.distilbert.modeling_flax_distilbert import (
						    FlaxDistilBertForMaskedLM,
						    FlaxDistilBertForMultipleChoice,
						    FlaxDistilBertForQuestionAnswering,
						    FlaxDistilBertForSequenceClassification,
						    FlaxDistilBertForTokenClassification,
						    FlaxDistilBertModel,
						)







class 	_lowerCAmelCase							(			unittest.TestCase ):


	def __init__(self       ,      lowercase       ,      lowercase=13       ,      lowercase=7       ,      lowercase=True       ,      lowercase=True       ,      lowercase=True       ,      lowercase=True       ,      lowercase=99       ,      lowercase=32       ,      lowercase=5       ,      lowercase=4       ,      lowercase=37       ,      lowercase="gelu"       ,      lowercase=0.1       ,      lowercase=0.1       ,      lowercase=512       ,      lowercase=16       ,      lowercase=2       ,      lowercase=0.02       ,      lowercase=4       ,      ):
				A_	:						List[Any]	=     parent
				A_	:						str	=     batch_size
				A_	:						List[Any]	=     seq_length
				A_	:						Dict	=     is_training
				A_	:						List[Any]	=     use_attention_mask
				A_	:						Any	=     use_token_type_ids
				A_	:						Optional[int]	=     use_labels
				A_	:						Tuple	=     vocab_size
				A_	:						List[str]	=     hidden_size
				A_	:						List[str]	=     num_hidden_layers
				A_	:						Optional[Any]	=     num_attention_heads
				A_	:						int	=     intermediate_size
				A_	:						Optional[Any]	=     hidden_act
				A_	:						List[Any]	=     hidden_dropout_prob
				A_	:						Optional[Any]	=     attention_probs_dropout_prob
				A_	:						Any	=     max_position_embeddings
				A_	:						Union[str, Any]	=     type_vocab_size
				A_	:						int	=     type_sequence_label_size
				A_	:						Any	=     initializer_range
				A_	:						List[str]	=     num_choices


	def     _a	(self							):
				A_	:						List[str]	=     ids_tensor([self.batch_size, self.seq_length]       ,      self.vocab_size							)

				A_	:						Any	=     None
				if self.use_attention_mask:
							A_	:						Any	=     random_attention_mask([self.batch_size, self.seq_length]							)

				A_	:						Union[str, Any]	=     DistilBertConfig(
				    vocab_size=self.vocab_size       ,      dim=self.hidden_size       ,      n_layers=self.num_hidden_layers       ,      n_heads=self.num_attention_heads       ,      hidden_dim=self.intermediate_size       ,      hidden_act=self.hidden_act       ,      dropout=self.hidden_dropout_prob       ,      attention_dropout=self.attention_probs_dropout_prob       ,      max_position_embeddings=self.max_position_embeddings       ,      initializer_range=self.initializer_range       ,      tie_weights_=lowercase       ,      )

				return config, input_ids, attention_mask


	def     _a	(self							):
				A_	:						List[str]	=     self.prepare_config_and_inputs()
				A_,    A_,    A_	:						str	=     config_and_inputs
				A_	:						Any	=     {"""input_ids""": input_ids, """attention_mask""": attention_mask}
				return config, inputs_dict







@require_flax
class 	_lowerCAmelCase							(			__UpperCAmelCase      ,			unittest.TestCase ):
	__SCREAMING_SNAKE_CASE   :		Optional[Any]					=					(
	    (
	        FlaxDistilBertModel,
	        FlaxDistilBertForMaskedLM,
	        FlaxDistilBertForMultipleChoice,
	        FlaxDistilBertForQuestionAnswering,
	        FlaxDistilBertForSequenceClassification,
	        FlaxDistilBertForTokenClassification,
	        FlaxDistilBertForQuestionAnswering,
	    )
	    if is_flax_available()
	    else ()
	)


	def     _a	(self							):
				A_	:						Tuple	=     FlaxDistilBertModelTester(self							)


	@slow
	def     _a	(self							):
				for model_class_name in self.all_model_classes:
							A_	:						Union[str, Any]	=     model_class_name.from_pretrained("""distilbert-base-uncased"""							)
							A_	:						Any	=     model(np.ones((1, 1)							)							)
							self.assertIsNotNone(lowercase							)







@require_flax
class 	_lowerCAmelCase							(			unittest.TestCase ):


	@slow
	def     _a	(self							):
				A_	:						List[str]	=     FlaxDistilBertModel.from_pretrained("""distilbert-base-uncased"""							)
				A_	:						Optional[Any]	=     np.array([[0, 345, 232, 328, 740, 140, 1695, 69, 6078, 1588, 2]]							)
				A_	:						int	=     np.array([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]							)
				A_	:						Optional[int]	=     model(lowercase       ,      attention_mask=lowercase							)[0]
				A_	:						Optional[Any]	=     (1, 11, 768)
				self.assertEqual(output.shape       ,      lowercase							)
				A_	:						Union[str, Any]	=     np.array([[[-0.16_39, 0.32_99, 0.16_48], [-0.17_46, 0.32_89, 0.17_10], [-0.18_84, 0.33_57, 0.18_10]]]							)

				self.assertTrue(jnp.allclose(output[:, 1:4, 1:4]       ,      lowercase       ,      atol=1E-4							)							)