'''simple docstring'''





import argparse
import json
import logging
import os
import shutil
import sys
import tempfile
import unittest
from unittest import mock

import torch
from accelerate.utils import write_basic_config

from transformers.testing_utils import TestCasePlus, get_gpu_count, run_command, slow, torch_device
from transformers.utils import is_apex_available


logging.basicConfig(level=logging.DEBUG)

SCREAMING_SNAKE_CASE_:	int    =logging.getLogger()





def       lowerCAmelCase_							(   )       -> Dict:


     '''simple docstring'''




     UpperCAmelCase_			       =  argparse.ArgumentParser()
     parser.add_argument("-f"     )
     UpperCAmelCase_			       =  parser.parse_args()
     return args.f





def       lowerCAmelCase_							(   snake_case_			:					List[Any]     )       -> str:


     '''simple docstring'''




     UpperCAmelCase_			       =  {}
     UpperCAmelCase_			       =  os.path.join(snake_case_   ,       "all_results.json"     )
     if os.path.exists(snake_case_     ):
          with open(snake_case_   ,       "r"     ) as f:
               UpperCAmelCase_			       =  json.load(snake_case_     )
     else:
          raise ValueError(f"""can't find {path}"""     )
     return results





def       lowerCAmelCase_							(   )       -> Dict:


     '''simple docstring'''




     UpperCAmelCase_			       =  torch.cuda.is_available() and torch_device == "cuda"
     return is_using_cuda and is_apex_available()


SCREAMING_SNAKE_CASE_:	Any    =logging.StreamHandler(sys.stdout)
logger.addHandler(stream_handler)






class 			__A (					UpperCamelCase__      ):



    @classmethod
    def    _lowercase		(cls       :       Any					):
         # Write Accelerate config, will pick up on CPU, GPU, and multi-GPU
         UpperCAmelCase_			       =  tempfile.mkdtemp()
         UpperCAmelCase_			       =  os.path.join(cls.tmpdir  ,     "default_config.yml"					)
         write_basic_config(save_location=cls.configPath					)
         UpperCAmelCase_			       =  ["accelerate", "launch", "--config_file", cls.configPath]



    @classmethod
    def    _lowercase		(cls       :       int					):
         shutil.rmtree(cls.tmpdir					)



    @mock.patch.dict(os.environ  ,     {"WANDB_MODE": "offline"}					)
    def    _lowercase		(self       :       Union[str, Any]					):
         UpperCAmelCase_			       =  self.get_auto_remove_tmp_dir()
         UpperCAmelCase_			       =  f"""
            {self.examples_dir}/pytorch/text-classification/run_glue_no_trainer.py
            --model_name_or_path distilbert-base-uncased
            --output_dir {tmp_dir}
            --train_file ./tests/fixtures/tests_samples/MRPC/train.csv
            --validation_file ./tests/fixtures/tests_samples/MRPC/dev.csv
            --per_device_train_batch_size=2
            --per_device_eval_batch_size=1
            --learning_rate=1e-4
            --seed=42
            --checkpointing_steps epoch
            --with_tracking
        """.split()

         if is_cuda_and_apex_available():
              testargs.append("--fp16"					)

         run_command(self._launch_args + testargs					)
         UpperCAmelCase_			       =  get_results(__a					)
         self.assertGreaterEqual(result["eval_accuracy"]  ,     0.75					)
         self.assertTrue(os.path.exists(os.path.join(__a  ,     "epoch_0"					)					)					)
         self.assertTrue(os.path.exists(os.path.join(__a  ,     "glue_no_trainer"					)					)					)



    @mock.patch.dict(os.environ  ,     {"WANDB_MODE": "offline"}					)
    def    _lowercase		(self       :       Optional[Any]					):
         UpperCAmelCase_			       =  self.get_auto_remove_tmp_dir()
         UpperCAmelCase_			       =  f"""
            {self.examples_dir}/pytorch/language-modeling/run_clm_no_trainer.py
            --model_name_or_path distilgpt2
            --train_file ./tests/fixtures/sample_text.txt
            --validation_file ./tests/fixtures/sample_text.txt
            --block_size 128
            --per_device_train_batch_size 5
            --per_device_eval_batch_size 5
            --num_train_epochs 2
            --output_dir {tmp_dir}
            --checkpointing_steps epoch
            --with_tracking
        """.split()

         if torch.cuda.device_count() > 1:
              # Skipping because there are not enough batches to train the model + would need a drop_last to work.
              return

         run_command(self._launch_args + testargs					)
         UpperCAmelCase_			       =  get_results(__a					)
         self.assertLess(result["perplexity"]  ,     100					)
         self.assertTrue(os.path.exists(os.path.join(__a  ,     "epoch_0"					)					)					)
         self.assertTrue(os.path.exists(os.path.join(__a  ,     "clm_no_trainer"					)					)					)



    @mock.patch.dict(os.environ  ,     {"WANDB_MODE": "offline"}					)
    def    _lowercase		(self       :       Union[str, Any]					):
         UpperCAmelCase_			       =  self.get_auto_remove_tmp_dir()
         UpperCAmelCase_			       =  f"""
            {self.examples_dir}/pytorch/language-modeling/run_mlm_no_trainer.py
            --model_name_or_path distilroberta-base
            --train_file ./tests/fixtures/sample_text.txt
            --validation_file ./tests/fixtures/sample_text.txt
            --output_dir {tmp_dir}
            --num_train_epochs=1
            --checkpointing_steps epoch
            --with_tracking
        """.split()

         run_command(self._launch_args + testargs					)
         UpperCAmelCase_			       =  get_results(__a					)
         self.assertLess(result["perplexity"]  ,     42					)
         self.assertTrue(os.path.exists(os.path.join(__a  ,     "epoch_0"					)					)					)
         self.assertTrue(os.path.exists(os.path.join(__a  ,     "mlm_no_trainer"					)					)					)



    @mock.patch.dict(os.environ  ,     {"WANDB_MODE": "offline"}					)
    def    _lowercase		(self       :       Optional[Any]					):
         # with so little data distributed training needs more epochs to get the score on par with 0/1 gpu
         UpperCAmelCase_			       =  7 if get_gpu_count() > 1 else 2

         UpperCAmelCase_			       =  self.get_auto_remove_tmp_dir()
         UpperCAmelCase_			       =  f"""
            {self.examples_dir}/pytorch/token-classification/run_ner_no_trainer.py
            --model_name_or_path bert-base-uncased
            --train_file tests/fixtures/tests_samples/conll/sample.json
            --validation_file tests/fixtures/tests_samples/conll/sample.json
            --output_dir {tmp_dir}
            --learning_rate=2e-4
            --per_device_train_batch_size=2
            --per_device_eval_batch_size=2
            --num_train_epochs={epochs}
            --seed 7
            --checkpointing_steps epoch
            --with_tracking
        """.split()

         run_command(self._launch_args + testargs					)
         UpperCAmelCase_			       =  get_results(__a					)
         self.assertGreaterEqual(result["eval_accuracy"]  ,     0.75					)
         self.assertLess(result["train_loss"]  ,     0.5					)
         self.assertTrue(os.path.exists(os.path.join(__a  ,     "epoch_0"					)					)					)
         self.assertTrue(os.path.exists(os.path.join(__a  ,     "ner_no_trainer"					)					)					)



    @unittest.skip(reason="Fix me @muellerzr"					)
    @mock.patch.dict(os.environ  ,     {"WANDB_MODE": "offline"}					)
    def    _lowercase		(self       :       int					):
         UpperCAmelCase_			       =  self.get_auto_remove_tmp_dir()
         UpperCAmelCase_			       =  f"""
            {self.examples_dir}/pytorch/question-answering/run_qa_no_trainer.py
            --model_name_or_path bert-base-uncased
            --version_2_with_negative
            --train_file tests/fixtures/tests_samples/SQUAD/sample.json
            --validation_file tests/fixtures/tests_samples/SQUAD/sample.json
            --output_dir {tmp_dir}
            --seed=42
            --max_train_steps=10
            --num_warmup_steps=2
            --learning_rate=2e-4
            --per_device_train_batch_size=2
            --per_device_eval_batch_size=1
            --checkpointing_steps epoch
            --with_tracking
        """.split()

         run_command(self._launch_args + testargs					)
         UpperCAmelCase_			       =  get_results(__a					)
         # Because we use --version_2_with_negative the testing script uses SQuAD v2 metrics.
         self.assertGreaterEqual(result["eval_f1"]  ,     28					)
         self.assertGreaterEqual(result["eval_exact"]  ,     28					)
         self.assertTrue(os.path.exists(os.path.join(__a  ,     "epoch_0"					)					)					)
         self.assertTrue(os.path.exists(os.path.join(__a  ,     "qa_no_trainer"					)					)					)



    @mock.patch.dict(os.environ  ,     {"WANDB_MODE": "offline"}					)
    def    _lowercase		(self       :       str					):
         UpperCAmelCase_			       =  self.get_auto_remove_tmp_dir()
         UpperCAmelCase_			       =  f"""
            {self.examples_dir}/pytorch/multiple-choice/run_swag_no_trainer.py
            --model_name_or_path bert-base-uncased
            --train_file tests/fixtures/tests_samples/swag/sample.json
            --validation_file tests/fixtures/tests_samples/swag/sample.json
            --output_dir {tmp_dir}
            --max_train_steps=20
            --num_warmup_steps=2
            --learning_rate=2e-4
            --per_device_train_batch_size=2
            --per_device_eval_batch_size=1
            --with_tracking
        """.split()

         run_command(self._launch_args + testargs					)
         UpperCAmelCase_			       =  get_results(__a					)
         self.assertGreaterEqual(result["eval_accuracy"]  ,     0.8					)
         self.assertTrue(os.path.exists(os.path.join(__a  ,     "swag_no_trainer"					)					)					)



    @slow
    @mock.patch.dict(os.environ  ,     {"WANDB_MODE": "offline"}					)
    def    _lowercase		(self       :       Optional[int]					):
         UpperCAmelCase_			       =  self.get_auto_remove_tmp_dir()
         UpperCAmelCase_			       =  f"""
            {self.examples_dir}/pytorch/summarization/run_summarization_no_trainer.py
            --model_name_or_path t5-small
            --train_file tests/fixtures/tests_samples/xsum/sample.json
            --validation_file tests/fixtures/tests_samples/xsum/sample.json
            --output_dir {tmp_dir}
            --max_train_steps=50
            --num_warmup_steps=8
            --learning_rate=2e-4
            --per_device_train_batch_size=2
            --per_device_eval_batch_size=1
            --checkpointing_steps epoch
            --with_tracking
        """.split()

         run_command(self._launch_args + testargs					)
         UpperCAmelCase_			       =  get_results(__a					)
         self.assertGreaterEqual(result["eval_rouge1"]  ,     10					)
         self.assertGreaterEqual(result["eval_rouge2"]  ,     2					)
         self.assertGreaterEqual(result["eval_rougeL"]  ,     7					)
         self.assertGreaterEqual(result["eval_rougeLsum"]  ,     7					)
         self.assertTrue(os.path.exists(os.path.join(__a  ,     "epoch_0"					)					)					)
         self.assertTrue(os.path.exists(os.path.join(__a  ,     "summarization_no_trainer"					)					)					)



    @slow
    @mock.patch.dict(os.environ  ,     {"WANDB_MODE": "offline"}					)
    def    _lowercase		(self       :       List[str]					):
         UpperCAmelCase_			       =  self.get_auto_remove_tmp_dir()
         UpperCAmelCase_			       =  f"""
            {self.examples_dir}/pytorch/translation/run_translation_no_trainer.py
            --model_name_or_path sshleifer/student_marian_en_ro_6_1
            --source_lang en
            --target_lang ro
            --train_file tests/fixtures/tests_samples/wmt16/sample.json
            --validation_file tests/fixtures/tests_samples/wmt16/sample.json
            --output_dir {tmp_dir}
            --max_train_steps=50
            --num_warmup_steps=8
            --num_beams=6
            --learning_rate=3e-3
            --per_device_train_batch_size=2
            --per_device_eval_batch_size=1
            --source_lang en_XX
            --target_lang ro_RO
            --checkpointing_steps epoch
            --with_tracking
        """.split()

         run_command(self._launch_args + testargs					)
         UpperCAmelCase_			       =  get_results(__a					)
         self.assertGreaterEqual(result["eval_bleu"]  ,     30					)
         self.assertTrue(os.path.exists(os.path.join(__a  ,     "epoch_0"					)					)					)
         self.assertTrue(os.path.exists(os.path.join(__a  ,     "translation_no_trainer"					)					)					)



    @slow
    def    _lowercase		(self       :       Dict					):
         UpperCAmelCase_			       =  logging.StreamHandler(sys.stdout					)
         logger.addHandler(__a					)

         UpperCAmelCase_			       =  self.get_auto_remove_tmp_dir()
         UpperCAmelCase_			       =  f"""
            {self.examples_dir}/pytorch/semantic-segmentation/run_semantic_segmentation_no_trainer.py
            --dataset_name huggingface/semantic-segmentation-test-sample
            --output_dir {tmp_dir}
            --max_train_steps=10
            --num_warmup_steps=2
            --learning_rate=2e-4
            --per_device_train_batch_size=2
            --per_device_eval_batch_size=1
            --checkpointing_steps epoch
        """.split()

         run_command(self._launch_args + testargs					)
         UpperCAmelCase_			       =  get_results(__a					)
         self.assertGreaterEqual(result["eval_overall_accuracy"]  ,     0.10					)






    @mock.patch.dict(os.environ  ,     {"WANDB_MODE": "offline"}					)
    def    _lowercase		(self       :       Any					):
         UpperCAmelCase_			       =  self.get_auto_remove_tmp_dir()
         UpperCAmelCase_			       =  f"""
            {self.examples_dir}/pytorch/image-classification/run_image_classification_no_trainer.py
            --model_name_or_path google/vit-base-patch16-224-in21k
            --dataset_name hf-internal-testing/cats_vs_dogs_sample
            --learning_rate 1e-4
            --per_device_train_batch_size 2
            --per_device_eval_batch_size 1
            --max_train_steps 2
            --train_val_split 0.1
            --seed 42
            --output_dir {tmp_dir}
            --with_tracking
            --checkpointing_steps 1
        """.split()

         if is_cuda_and_apex_available():
              testargs.append("--fp16"					)

         run_command(self._launch_args + testargs					)
         UpperCAmelCase_			       =  get_results(__a					)
         # The base model scores a 25%
         self.assertGreaterEqual(result["eval_accuracy"]  ,     0.6					)
         self.assertTrue(os.path.exists(os.path.join(__a  ,     "step_1"					)					)					)
         self.assertTrue(os.path.exists(os.path.join(__a  ,     "image_classification_no_trainer"					)					)					)












from datetime import datetime as dt
import os

from github import Github


__magic_name__   :  Dict        =							[
    '''good first issue''',
    '''good second issue''',
    '''good difficult issue''',
    '''feature request''',
    '''new model''',
    '''wip''',
]
def 		lowercase__  (				) ->			Dict:
      """simple docstring"""

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

      for issue in open_issues:
            UpperCamelCase					       =  sorted([comment for comment in issue.get_comments()]       ,							key=lambda _UpperCamelCase: i.created_at       ,							reverse=_UpperCamelCase)
            UpperCamelCase					       =  comments[0] if len(_UpperCamelCase) > 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()



