

import os
from datetime import datetime as dt

from github import Github


_SCREAMING_SNAKE_CASE  :						List[Any]         =    [
    '''good first issue''',
    '''feature request''',
    '''wip''',
]
def        UpperCAmelCase_     (		):





     '''simple docstring'''




     SCREAMING_SNAKE_CASE__					=					Github(os.environ['''GITHUB_TOKEN''']       )
     SCREAMING_SNAKE_CASE__					=					g.get_repo('''huggingface/accelerate'''       )
     SCREAMING_SNAKE_CASE__					=					repo.get_issues(state='''open'''       )

     for issue in open_issues:
          SCREAMING_SNAKE_CASE__					=					sorted([comment for comment in issue.get_comments()]   ,	key=lambda _A       : i.created_at   ,	reverse=_A       )
          SCREAMING_SNAKE_CASE__					=					comments[0] if len(_A       ) > 0 else None
          SCREAMING_SNAKE_CASE__					=					dt.utcnow()
          SCREAMING_SNAKE_CASE__					=					(current_time - issue.updated_at).days
          SCREAMING_SNAKE_CASE__					=					(current_time - issue.created_at).days
          if (
              last_comment is not None
              and last_comment.user.login == "github-actions[bot]"
              and days_since_updated > 7
              and days_since_creation >= 30
              and not any(label.name.lower() in LABELS_TO_EXEMPT for label in issue.get_labels()       )
          ):
               # Close issue since it has been 7 days of inactivity since bot mention.
               issue.edit(state='''closed'''       )
          elif (
              days_since_updated > 23
              and days_since_creation >= 30
              and not any(label.name.lower() in LABELS_TO_EXEMPT for label in issue.get_labels()       )
          ):
               # Add stale comment
               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/accelerate/blob/main/CONTRIBUTING.md) '''
                   '''are likely to be ignored.'''       )


if __name__ == "__main__":
       main()





import unittest

from transformers import MobileBertConfig, is_torch_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_sentencepiece, require_tokenizers, 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 (
           MODEL_FOR_PRETRAINING_MAPPING,
           MobileBertForMaskedLM,
           MobileBertForMultipleChoice,
           MobileBertForNextSentencePrediction,
           MobileBertForPreTraining,
           MobileBertForQuestionAnswering,
           MobileBertForSequenceClassification,
           MobileBertForTokenClassification,
           MobileBertModel,
       )






class  UpperCAmelCase__	:






  """simple docstring"""


  def __init__(							self		:	Optional[int]			,     __lowerCamelCase		:	Tuple			,     __lowerCamelCase		:	List[str]=13			,     __lowerCamelCase		:	Any=7			,     __lowerCamelCase		:	str=True			,     __lowerCamelCase		:	Tuple=True			,     __lowerCamelCase		:	Tuple=True			,     __lowerCamelCase		:	str=True			,     __lowerCamelCase		:	int=99			,     __lowerCamelCase		:	Optional[int]=64			,     __lowerCamelCase		:	Dict=32			,     __lowerCamelCase		:	Dict=5			,     __lowerCamelCase		:	Optional[Any]=4			,     __lowerCamelCase		:	Optional[Any]=37			,     __lowerCamelCase		:	Dict="gelu"			,     __lowerCamelCase		:	Any=0.1			,     __lowerCamelCase		:	str=0.1			,     __lowerCamelCase		:	Optional[Any]=512			,     __lowerCamelCase		:	List[Any]=16			,     __lowerCamelCase		:	Optional[int]=2			,     __lowerCamelCase		:	Union[str, Any]=0.02			,     __lowerCamelCase		:	List[str]=3			,     __lowerCamelCase		:	Any=4			,     __lowerCamelCase		:	Dict=None			,     )	->							int:
       SCREAMING_SNAKE_CASE__					=					parent
       SCREAMING_SNAKE_CASE__					=					batch_size
       SCREAMING_SNAKE_CASE__					=					seq_length
       SCREAMING_SNAKE_CASE__					=					is_training
       SCREAMING_SNAKE_CASE__					=					use_input_mask
       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__					=					embedding_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






  def    lowercase_	(							self		:	List[str]      )	->							Optional[int]:
       SCREAMING_SNAKE_CASE__					=					ids_tensor([self.batch_size, self.seq_length]			,     self.vocab_size      )

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

       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__					=					self.get_config()

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






  def    lowercase_	(							self		:	Dict      )	->							Any:
       return MobileBertConfig(
           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			,     embedding_size=self.embedding_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			,     is_decoder=__lowerCamelCase			,     initializer_range=self.initializer_range			,     )






  def    lowercase_	(							self		:	List[str]			,     __lowerCamelCase		:	int			,     __lowerCamelCase		:	str			,     __lowerCamelCase		:	Tuple			,     __lowerCamelCase		:	Union[str, Any]			,     __lowerCamelCase		:	int			,     __lowerCamelCase		:	Optional[Any]			,     __lowerCamelCase		:	List[Any]      )	->							Any:
       SCREAMING_SNAKE_CASE__					=					MobileBertModel(config=__lowerCamelCase      )
       model.to(__lowerCamelCase      )
       model.eval()
       SCREAMING_SNAKE_CASE__					=					model(__lowerCamelCase			,     attention_mask=__lowerCamelCase			,     token_type_ids=__lowerCamelCase      )
       SCREAMING_SNAKE_CASE__					=					model(__lowerCamelCase			,     token_type_ids=__lowerCamelCase      )
       SCREAMING_SNAKE_CASE__					=					model(__lowerCamelCase      )

       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    lowercase_	(							self		:	Dict			,     __lowerCamelCase		:	int			,     __lowerCamelCase		:	List[Any]			,     __lowerCamelCase		:	Dict			,     __lowerCamelCase		:	Dict			,     __lowerCamelCase		:	Optional[int]			,     __lowerCamelCase		:	str			,     __lowerCamelCase		:	Any      )	->							Optional[Any]:
       SCREAMING_SNAKE_CASE__					=					MobileBertForMaskedLM(config=__lowerCamelCase      )
       model.to(__lowerCamelCase      )
       model.eval()
       SCREAMING_SNAKE_CASE__					=					model(__lowerCamelCase			,     attention_mask=__lowerCamelCase			,     token_type_ids=__lowerCamelCase			,     labels=__lowerCamelCase      )
       self.parent.assertEqual(result.logits.shape			,     (self.batch_size, self.seq_length, self.vocab_size)      )






  def    lowercase_	(							self		:	int			,     __lowerCamelCase		:	Any			,     __lowerCamelCase		:	Optional[int]			,     __lowerCamelCase		:	Optional[int]			,     __lowerCamelCase		:	List[str]			,     __lowerCamelCase		:	List[str]			,     __lowerCamelCase		:	List[Any]			,     __lowerCamelCase		:	List[Any]      )	->							int:
       SCREAMING_SNAKE_CASE__					=					MobileBertForNextSentencePrediction(config=__lowerCamelCase      )
       model.to(__lowerCamelCase      )
       model.eval()
       SCREAMING_SNAKE_CASE__					=					model(
           __lowerCamelCase			,     attention_mask=__lowerCamelCase			,     token_type_ids=__lowerCamelCase			,     labels=__lowerCamelCase			,     )
       self.parent.assertEqual(result.logits.shape			,     (self.batch_size, 2)      )






  def    lowercase_	(							self		:	str			,     __lowerCamelCase		:	int			,     __lowerCamelCase		:	List[Any]			,     __lowerCamelCase		:	List[str]			,     __lowerCamelCase		:	Dict			,     __lowerCamelCase		:	Optional[Any]			,     __lowerCamelCase		:	List[str]			,     __lowerCamelCase		:	Any      )	->							int:
       SCREAMING_SNAKE_CASE__					=					MobileBertForPreTraining(config=__lowerCamelCase      )
       model.to(__lowerCamelCase      )
       model.eval()
       SCREAMING_SNAKE_CASE__					=					model(
           __lowerCamelCase			,     attention_mask=__lowerCamelCase			,     token_type_ids=__lowerCamelCase			,     labels=__lowerCamelCase			,     next_sentence_label=__lowerCamelCase			,     )
       self.parent.assertEqual(result.prediction_logits.shape			,     (self.batch_size, self.seq_length, self.vocab_size)      )
       self.parent.assertEqual(result.seq_relationship_logits.shape			,     (self.batch_size, 2)      )






  def    lowercase_	(							self		:	List[Any]			,     __lowerCamelCase		:	int			,     __lowerCamelCase		:	Tuple			,     __lowerCamelCase		:	int			,     __lowerCamelCase		:	int			,     __lowerCamelCase		:	Dict			,     __lowerCamelCase		:	Optional[Any]			,     __lowerCamelCase		:	Any      )	->							Dict:
       SCREAMING_SNAKE_CASE__					=					MobileBertForQuestionAnswering(config=__lowerCamelCase      )
       model.to(__lowerCamelCase      )
       model.eval()
       SCREAMING_SNAKE_CASE__					=					model(
           __lowerCamelCase			,     attention_mask=__lowerCamelCase			,     token_type_ids=__lowerCamelCase			,     start_positions=__lowerCamelCase			,     end_positions=__lowerCamelCase			,     )
       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    lowercase_	(							self		:	Optional[Any]			,     __lowerCamelCase		:	int			,     __lowerCamelCase		:	Dict			,     __lowerCamelCase		:	Optional[Any]			,     __lowerCamelCase		:	str			,     __lowerCamelCase		:	List[Any]			,     __lowerCamelCase		:	int			,     __lowerCamelCase		:	Union[str, Any]      )	->							List[Any]:
       SCREAMING_SNAKE_CASE__					=					self.num_labels
       SCREAMING_SNAKE_CASE__					=					MobileBertForSequenceClassification(__lowerCamelCase      )
       model.to(__lowerCamelCase      )
       model.eval()
       SCREAMING_SNAKE_CASE__					=					model(__lowerCamelCase			,     attention_mask=__lowerCamelCase			,     token_type_ids=__lowerCamelCase			,     labels=__lowerCamelCase      )
       self.parent.assertEqual(result.logits.shape			,     (self.batch_size, self.num_labels)      )






  def    lowercase_	(							self		:	int			,     __lowerCamelCase		:	Optional[int]			,     __lowerCamelCase		:	Any			,     __lowerCamelCase		:	str			,     __lowerCamelCase		:	Any			,     __lowerCamelCase		:	int			,     __lowerCamelCase		:	str			,     __lowerCamelCase		:	Union[str, Any]      )	->							int:
       SCREAMING_SNAKE_CASE__					=					self.num_labels
       SCREAMING_SNAKE_CASE__					=					MobileBertForTokenClassification(config=__lowerCamelCase      )
       model.to(__lowerCamelCase      )
       model.eval()
       SCREAMING_SNAKE_CASE__					=					model(__lowerCamelCase			,     attention_mask=__lowerCamelCase			,     token_type_ids=__lowerCamelCase			,     labels=__lowerCamelCase      )
       self.parent.assertEqual(result.logits.shape			,     (self.batch_size, self.seq_length, self.num_labels)      )






  def    lowercase_	(							self		:	Union[str, Any]			,     __lowerCamelCase		:	Dict			,     __lowerCamelCase		:	List[str]			,     __lowerCamelCase		:	Any			,     __lowerCamelCase		:	Dict			,     __lowerCamelCase		:	Any			,     __lowerCamelCase		:	int			,     __lowerCamelCase		:	Tuple      )	->							List[Any]:
       SCREAMING_SNAKE_CASE__					=					self.num_choices
       SCREAMING_SNAKE_CASE__					=					MobileBertForMultipleChoice(config=__lowerCamelCase      )
       model.to(__lowerCamelCase      )
       model.eval()
       SCREAMING_SNAKE_CASE__					=					input_ids.unsqueeze(1      ).expand(-1			,     self.num_choices			,     -1      ).contiguous()
       SCREAMING_SNAKE_CASE__					=					token_type_ids.unsqueeze(1      ).expand(-1			,     self.num_choices			,     -1      ).contiguous()
       SCREAMING_SNAKE_CASE__					=					input_mask.unsqueeze(1      ).expand(-1			,     self.num_choices			,     -1      ).contiguous()
       SCREAMING_SNAKE_CASE__					=					model(
           __lowerCamelCase			,     attention_mask=__lowerCamelCase			,     token_type_ids=__lowerCamelCase			,     labels=__lowerCamelCase			,     )
       self.parent.assertEqual(result.logits.shape			,     (self.batch_size, self.num_choices)      )







  def    lowercase_	(							self		:	List[str]      )	->							Tuple:
       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, '''attention_mask''': input_mask}
       return config, inputs_dict






@require_torch
class  UpperCAmelCase__	( A__		,  A__		,  unittest.TestCase ):






  """simple docstring"""


  a     =      (
      (
          MobileBertModel,
          MobileBertForMaskedLM,
          MobileBertForMultipleChoice,
          MobileBertForNextSentencePrediction,
          MobileBertForPreTraining,
          MobileBertForQuestionAnswering,
          MobileBertForSequenceClassification,
          MobileBertForTokenClassification,
      )
      if is_torch_available()
      else ()
  )
  a     =      (
      {
          "feature-extraction": MobileBertModel,
          "fill-mask": MobileBertForMaskedLM,
          "question-answering": MobileBertForQuestionAnswering,
          "text-classification": MobileBertForSequenceClassification,
          "token-classification": MobileBertForTokenClassification,
          "zero-shot": MobileBertForSequenceClassification,
      }
      if is_torch_available()
      else {}
  )
  a     =      True






  def    lowercase_	(							self		:	int			,     __lowerCamelCase		:	Optional[Any]			,     __lowerCamelCase		:	List[str]			,     __lowerCamelCase		:	Optional[int]=False      )	->							str:
       SCREAMING_SNAKE_CASE__					=					super()._prepare_for_class(__lowerCamelCase			,     __lowerCamelCase			,     return_labels=__lowerCamelCase      )

       if return_labels:
            if model_class in get_values(__lowerCamelCase      ):
                 SCREAMING_SNAKE_CASE__					=					torch.zeros(
                     (self.model_tester.batch_size, self.model_tester.seq_length)			,     dtype=torch.long			,     device=__lowerCamelCase      )
                 SCREAMING_SNAKE_CASE__					=					torch.zeros(
                     self.model_tester.batch_size			,     dtype=torch.long			,     device=__lowerCamelCase      )
       return inputs_dict






  def    lowercase_	(							self		:	Optional[Any]      )	->							List[str]:
       SCREAMING_SNAKE_CASE__					=					MobileBertModelTester(self      )
       SCREAMING_SNAKE_CASE__					=					ConfigTester(self			,     config_class=__lowerCamelCase			,     hidden_size=37      )






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






  def    lowercase_	(							self		:	Optional[int]      )	->							Union[str, Any]:
       SCREAMING_SNAKE_CASE__					=					self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_mobilebert_model(*__lowerCamelCase      )






  def    lowercase_	(							self		:	Tuple      )	->							Any:
       SCREAMING_SNAKE_CASE__					=					self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_mobilebert_for_masked_lm(*__lowerCamelCase      )






  def    lowercase_	(							self		:	Dict      )	->							Optional[Any]:
       SCREAMING_SNAKE_CASE__					=					self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_mobilebert_for_multiple_choice(*__lowerCamelCase      )






  def    lowercase_	(							self		:	Union[str, Any]      )	->							Optional[Any]:
       SCREAMING_SNAKE_CASE__					=					self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_mobilebert_for_next_sequence_prediction(*__lowerCamelCase      )






  def    lowercase_	(							self		:	Any      )	->							str:
       SCREAMING_SNAKE_CASE__					=					self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_mobilebert_for_pretraining(*__lowerCamelCase      )






  def    lowercase_	(							self		:	Dict      )	->							str:
       SCREAMING_SNAKE_CASE__					=					self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_mobilebert_for_question_answering(*__lowerCamelCase      )






  def    lowercase_	(							self		:	List[str]      )	->							str:
       SCREAMING_SNAKE_CASE__					=					self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_mobilebert_for_sequence_classification(*__lowerCamelCase      )







  def    lowercase_	(							self		:	Tuple      )	->							List[Any]:
       SCREAMING_SNAKE_CASE__					=					self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_mobilebert_for_token_classification(*__lowerCamelCase      )



def        UpperCAmelCase_     (		_A       ):





     '''simple docstring'''




     return torch.tensor(
         _A   ,	dtype=torch.long   ,	device=_A   ,	)


_SCREAMING_SNAKE_CASE  :						Optional[Any]         =    1e-3







@require_torch
@require_sentencepiece
@require_tokenizers
class  UpperCAmelCase__	( unittest.TestCase ):






  """simple docstring"""


  @slow
  def    lowercase_	(							self		:	List[str]      )	->							List[Any]:
       SCREAMING_SNAKE_CASE__					=					MobileBertModel.from_pretrained('''google/mobilebert-uncased'''      ).to(__lowerCamelCase      )
       SCREAMING_SNAKE_CASE__					=					_long_tensor([[101, 7110, 1005, 1056, 2023, 1_1333, 1_7413, 1029, 102]]      )
       with torch.no_grad():
            SCREAMING_SNAKE_CASE__					=					model(__lowerCamelCase      )[0]
       SCREAMING_SNAKE_CASE__					=					torch.Size((1, 9, 512)      )
       self.assertEqual(output.shape			,     __lowerCamelCase      )
       SCREAMING_SNAKE_CASE__					=					torch.tensor(
           [
               [
                   [-2.4_73_65_26e07, 8.2_69_16_56e04, 1.6_52_18_38e05],
                   [-5.7_54_17_04e-01, 3.9_05_60_22e00, 4.4_01_15_07e00],
                   [2.6_04_73_59e00, 1.5_67_76_52e00, -1.7_32_41_88e-01],
               ]
           ]			,     device=__lowerCamelCase			,     )

       # MobileBERT results range from 10e0 to 10e8. Even a 0.0000001% difference with a value of 10e8 results in a
       # ~1 difference, it's therefore not a good idea to measure using addition.
       # Here, we instead divide the expected result with the result in order to obtain ~1. We then check that the
       # result is held between bounds: 1 - TOLERANCE < expected_result / result < 1 + TOLERANCE
       SCREAMING_SNAKE_CASE__					=					torch.all((expected_slice / output[..., :3, :3]) >= 1 - TOLERANCE      )
       SCREAMING_SNAKE_CASE__					=					torch.all((expected_slice / output[..., :3, :3]) <= 1 + TOLERANCE      )

       self.assertTrue(lower_bound and upper_bound      )


