




import ast
import os
import re
import shutil
import tempfile
import unittest
from unittest import mock

import torch

from accelerate.test_utils.examples import compare_against_test
from accelerate.test_utils.testing import TempDirTestCase, require_trackers, run_command, slow
from accelerate.utils import write_basic_config


# DataLoaders built from `test_samples/MRPC` for quick testing
# Should mock `{script_name}.get_dataloaders` via:
# @mock.patch("{script_name}.get_dataloaders", mocked_dataloaders)

_snake_case				:				Dict       							=		[
    'cross_validation.py',
    'gradient_accumulation.py',
    'local_sgd.py',
    'multi_process_metrics.py',
    'memory.py',
    'automatic_gradient_accumulation.py',
    'fsdp_with_peak_mem_tracking.py',
    'deepspeed_with_config_support.py',
    'megatron_lm_gpt_pretraining.py',
]

class       A   (		unittest.TestCase   ):







							def        __lowerCAmelCase      (  self	:  Dict							,      lowerCAmelCase_	:  str							,      lowerCAmelCase_	:  bool							,      lowerCAmelCase_	:  str = None							,      lowerCAmelCase_	:  list = None )      ->							Union[str, Any]:


														"""simple docstring"""


														_a     					=    None
														_a     					=    os.path.abspath(os.path.join('''examples'''							,      '''by_feature''' ) )
														_a     					=    os.path.abspath('''examples''' )
														for item in os.listdir(lowerCAmelCase_ ):
																					if item not in EXCLUDE_EXAMPLES:
																												_a     					=    os.path.join(lowerCAmelCase_							,      lowerCAmelCase_ )
																												if os.path.isfile(lowerCAmelCase_ ) and ".py" in item_path:
																																			with self.subTest(
																																			    tested_script=lowerCAmelCase_							,      feature_script=lowerCAmelCase_							,      tested_section='''main()''' if parser_only else '''training_function()'''							,      ):
																																										_a     					=    compare_against_test(
																																										    os.path.join(lowerCAmelCase_							,      lowerCAmelCase_ )							,      lowerCAmelCase_							,      lowerCAmelCase_							,      lowerCAmelCase_ )
																																										_a     					=    '''\n'''.join(lowerCAmelCase_ )
																																										if special_strings is not None:
																																																	for string in special_strings:
																																																								_a     					=    diff.replace(lowerCAmelCase_							,      '''''' )
																																										self.assertEqual(lowerCAmelCase_							,      '''''' )







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


														"""simple docstring"""


														self.one_complete_example('''complete_nlp_example.py'''							,      lowerCAmelCase_ )
														self.one_complete_example('''complete_nlp_example.py'''							,      lowerCAmelCase_ )







							def        __lowerCAmelCase      (  self	:  int )      ->							Optional[int]:


														"""simple docstring"""


														_a     					=    os.path.abspath(os.path.join('''examples'''							,      '''cv_example.py''' ) )
														_a     					=    [
														    ''' ''' * 16 + '''{\n\n''',
														    ''' ''' * 20 + '''"accuracy": eval_metric["accuracy"],\n\n''',
														    ''' ''' * 20 + '''"f1": eval_metric["f1"],\n\n''',
														    ''' ''' * 20 + '''"train_loss": total_loss.item() / len(train_dataloader),\n\n''',
														    ''' ''' * 20 + '''"epoch": epoch,\n\n''',
														    ''' ''' * 16 + '''},\n\n''',
														    ''' ''' * 16 + '''step=epoch,\n''',
														    ''' ''' * 12,
														    ''' ''' * 8 + '''for step, batch in enumerate(active_dataloader):\n''',
														]
														self.one_complete_example('''complete_cv_example.py'''							,      lowerCAmelCase_							,      lowerCAmelCase_							,      lowerCAmelCase_ )
														self.one_complete_example('''complete_cv_example.py'''							,      lowerCAmelCase_							,      lowerCAmelCase_							,      lowerCAmelCase_ )



@mock.patch.dict(os.environ					,{'TESTING_MOCKED_DATALOADERS': '1'}   )
class       A   (		_a   ):
							lowercase_          =    False







							@classmethod
							def        __lowerCAmelCase      (  cls	:  Dict )      ->							Any:


														"""simple docstring"""


														super().setUpClass()
														_a     					=    tempfile.mkdtemp()
														_a     					=    os.path.join(cls._tmpdir							,      '''default_config.yml''' )

														write_basic_config(save_location=cls.configPath )
														_a     					=    ['''accelerate''', '''launch''', '''--config_file''', cls.configPath]







							@classmethod
							def        __lowerCAmelCase      (  cls	:  List[Any] )      ->							Dict:


														"""simple docstring"""


														super().tearDownClass()
														shutil.rmtree(cls._tmpdir )







							def        __lowerCAmelCase      (  self	:  Optional[int] )      ->							Optional[int]:


														"""simple docstring"""


														_a     					=    F'\n        examples/by_feature/checkpointing.py\n        --checkpointing_steps epoch\n        --output_dir {self.tmpdir}\n        '.split()
														run_command(self._launch_args + testargs )
														self.assertTrue(os.path.exists(os.path.join(self.tmpdir							,      '''epoch_0''' ) ) )







							def        __lowerCAmelCase      (  self	:  int )      ->							str:


														"""simple docstring"""


														_a     					=    F'\n        examples/by_feature/checkpointing.py\n        --checkpointing_steps 1\n        --output_dir {self.tmpdir}\n        '.split()
														_a     					=    run_command(self._launch_args + testargs )
														self.assertTrue(os.path.exists(os.path.join(self.tmpdir							,      '''step_2''' ) ) )







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


														"""simple docstring"""


														_a     					=    F'\n        examples/by_feature/checkpointing.py\n        --resume_from_checkpoint {os.path.join(self.tmpdir							,      "epoch_0" )}\n        '.split()
														_a     					=    run_command(self._launch_args + testargs							,      return_stdout=lowerCAmelCase_ )
														self.assertNotIn('''epoch 0:'''							,      lowerCAmelCase_ )
														self.assertIn('''epoch 1:'''							,      lowerCAmelCase_ )







							def        __lowerCAmelCase      (  self	:  Union[str, Any] )      ->							Union[str, Any]:


														"""simple docstring"""


														_a     					=    F'\n        examples/by_feature/checkpointing.py\n        --resume_from_checkpoint {os.path.join(self.tmpdir							,      "step_2" )}\n        '.split()
														_a     					=    run_command(self._launch_args + testargs							,      return_stdout=lowerCAmelCase_ )
														if torch.cuda.is_available():
																					_a     					=    torch.cuda.device_count()
														else:
																					_a     					=    1
														if num_processes > 1:
																					self.assertNotIn('''epoch 0:'''							,      lowerCAmelCase_ )
																					self.assertIn('''epoch 1:'''							,      lowerCAmelCase_ )
														else:
																					self.assertIn('''epoch 0:'''							,      lowerCAmelCase_ )
																					self.assertIn('''epoch 1:'''							,      lowerCAmelCase_ )







							@slow
							def        __lowerCAmelCase      (  self	:  Any )      ->							Tuple:


														"""simple docstring"""


														_a     					=    '''
        examples/by_feature/cross_validation.py
        --num_folds 2
        '''.split()
														with mock.patch.dict(os.environ							,      {'''TESTING_MOCKED_DATALOADERS''': '''0'''} ):
																					_a     					=    run_command(self._launch_args + testargs							,      return_stdout=lowerCAmelCase_ )
																					_a     					=    re.findall('''({.+})'''							,      lowerCAmelCase_ )
																					_a     					=    [r for r in results if '''accuracy''' in r][-1]
																					_a     					=    ast.literal_eval(lowerCAmelCase_ )
																					self.assertGreaterEqual(results['''accuracy''']							,      0.7_5 )







							def        __lowerCAmelCase      (  self	:  Optional[Any] )      ->							Union[str, Any]:


														"""simple docstring"""


														_a     					=    ['''examples/by_feature/multi_process_metrics.py''']
														run_command(self._launch_args + testargs )







							@require_trackers
							@mock.patch.dict(os.environ							,      {'''WANDB_MODE''': '''offline'''} )
							def        __lowerCAmelCase      (  self	:  Tuple )      ->							Optional[Any]:


														"""simple docstring"""


														with tempfile.TemporaryDirectory() as tmpdir:
																					_a     					=    F'\n            examples/by_feature/tracking.py\n            --with_tracking\n            --project_dir {tmpdir}\n            '.split()
																					run_command(self._launch_args + testargs )
																					self.assertTrue(os.path.exists(os.path.join(lowerCAmelCase_							,      '''tracking''' ) ) )







							def        __lowerCAmelCase      (  self	:  str )      ->							Any:


														"""simple docstring"""


														_a     					=    ['''examples/by_feature/gradient_accumulation.py''']
														run_command(self._launch_args + testargs )







							def        __lowerCAmelCase      (  self	:  str )      ->							Dict:


														"""simple docstring"""


														_a     					=    ['''examples/by_feature/local_sgd.py''']
														run_command(self._launch_args + testargs )







'''simple docstring'''


import argparse
import math
import traceback

import dateutil.parser as date_parser
import requests
def 		snake_case_   (UpperCamelCase	:  Dict				):





							'''simple docstring'''


							_a     					=    {}

							_a     					=    job['''started_at''']
							_a     					=    job['''completed_at''']

							_a     					=    date_parser.parse(UpperCamelCase				)
							_a     					=    date_parser.parse(UpperCamelCase				)

							_a     					=    round((end_datetime - start_datetime).total_seconds() / 60.0				)

							_a     					=    start
							_a     					=    end
							_a     					=    duration_in_min

							return job_info
def 		snake_case_   (UpperCamelCase	:  int			,						UpperCamelCase	:  int=None				):





							'''simple docstring'''


							_a     					=    None
							if token is not None:
														_a     					=    {'''Accept''': '''application/vnd.github+json''', '''Authorization''': f'Bearer {token}'}

							_a     					=    f'https://api.github.com/repos/huggingface/transformers/actions/runs/{workflow_run_id}/jobs?per_page=100'
							_a     					=    requests.get(UpperCamelCase			,						headers=UpperCamelCase				).json()
							_a     					=    {}

							try:
														job_time.update({job['''name''']: extract_time_from_single_job(UpperCamelCase				) for job in result['''jobs''']}				)
														_a     					=    math.ceil((result['''total_count'''] - 100) / 100				)

														for i in range(UpperCamelCase				):
																					_a     					=    requests.get(url + f'&page={i + 2}'			,						headers=UpperCamelCase				).json()
																					job_time.update({job['''name''']: extract_time_from_single_job(UpperCamelCase				) for job in result['''jobs''']}				)

														return job_time
							except Exception:
														print(f'Unknown error, could not fetch links:\n{traceback.format_exc()}'				)

							return {}


if __name__ == "__main__":
				_snake_case				:				int       							=		argparse.ArgumentParser()
				# Required parameters
				parser.add_argument('--workflow_run_id', type=str, required=True, help='A GitHub Actions workflow run id.')
				_snake_case				:				Tuple       							=		parser.parse_args()

				_snake_case				:				int       							=		get_job_time(args.workflow_run_id)
				_snake_case				:				int       							=		dict(sorted(job_time.items(), key=lambda item: item[1]["duration"], reverse=True))

				for k, v in job_time.items():
								print(F'''{k}: {v['duration']}''')

