


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   							=						[
    '''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 	__lowerCamelCase			(unittest.TestCase						):







       def 		snake_case_	(			self: List[str],A_: str,A_: bool,A_: str = None,A_: list = None					):






            '''simple docstring'''




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







       def 		snake_case_	(			self: int					):






            '''simple docstring'''




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







       def 		snake_case_	(			self: Any					):






            '''simple docstring'''




            __UpperCamelCase =			os.path.abspath(os.path.join('examples','cv_example.py'					)					)
            __UpperCamelCase =			[
                ' ' * 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',A_,A_,A_					)
            self.one_complete_example('complete_cv_example.py',A_,A_,A_					)



@mock.patch.dict(os.environ				,      {"""TESTING_MOCKED_DATALOADERS""": """1"""}						)
class 	__lowerCamelCase			(_a						):
       _lowercase											=     False







       @classmethod
       def 		snake_case_	(			cls: int					):






            '''simple docstring'''




            super().setUpClass()
            __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 		snake_case_	(			cls: Optional[Any]					):






            '''simple docstring'''




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







       def 		snake_case_	(			self: Tuple					):






            '''simple docstring'''




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







       def 		snake_case_	(			self: str					):






            '''simple docstring'''




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







       def 		snake_case_	(			self: Optional[Any]					):






            '''simple docstring'''




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







       def 		snake_case_	(			self: str					):






            '''simple docstring'''




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







       @slow
       def 		snake_case_	(			self: Optional[Any]					):






            '''simple docstring'''




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







       def 		snake_case_	(			self: Tuple					):






            '''simple docstring'''




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







       @require_trackers
       @mock.patch.dict(os.environ,{'WANDB_MODE': 'offline'}					)
       def 		snake_case_	(			self: Dict					):






            '''simple docstring'''




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







       def 		snake_case_	(			self: List[str]					):






            '''simple docstring'''




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







       def 		snake_case_	(			self: List[Any]					):






            '''simple docstring'''




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









'''simple docstring'''




def 						__lowerCamelCase			(	UpperCAmelCase_ = 10_00							)   ->int:
	return sum(e for e in range(3					,				UpperCAmelCase_							) if e % 3 == 0 or e % 5 == 0							)


if __name__ == "__main__":
			print(f"""{solution() = }""")



