




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)

__magic_name__  :  Union[str, Any]					=       [
    '''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     SCREAMING_SNAKE_CASE__		(unittest.TestCase			):
     def        A__      (						self	:		Tuple       ,						__lowerCamelCase	:		str       ,						__lowerCamelCase	:		bool       ,						__lowerCamelCase	:		str = None       ,						__lowerCamelCase	:		list = None						):



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



       """simple docstring"""
       self.one_complete_example('''complete_nlp_example.py'''       ,						UpperCamelCase__						)
       self.one_complete_example('''complete_nlp_example.py'''       ,						UpperCamelCase__						)



     def        A__      (						self	:		Any						):



       """simple docstring"""
       lowerCAmelCase__										=      os.path.abspath(os.path.join('''examples'''       ,						'''cv_example.py'''						)						)
       lowerCAmelCase__										=      [
           ''' ''' * 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'''       ,						UpperCamelCase__       ,						UpperCamelCase__       ,						UpperCamelCase__						)
       self.one_complete_example('''complete_cv_example.py'''       ,						UpperCamelCase__       ,						UpperCamelCase__       ,						UpperCamelCase__						)





@mock.patch.dict(os.environ    ,					{"TESTING_MOCKED_DATALOADERS": "1"}			)
class     SCREAMING_SNAKE_CASE__		(_UpperCamelCase			):
     lowercase_ :      Dict				= False
     @classmethod
     def        A__      (						cls	:		Optional[int]						):



       """simple docstring"""
       super().setUpClass()
       lowerCAmelCase__										=      tempfile.mkdtemp()
       lowerCAmelCase__										=      os.path.join(cls._tmpdir       ,						'''default_config.yml'''						)

       write_basic_config(save_location=cls.configPath						)
       lowerCAmelCase__										=      ['''accelerate''', '''launch''', '''--config_file''', cls.configPath]
     @classmethod
     def        A__      (						cls	:		List[str]						):



       """simple docstring"""
       super().tearDownClass()
       shutil.rmtree(cls._tmpdir						)
     def        A__      (						self	:		List[Any]						):



       """simple docstring"""
       lowerCAmelCase__										=      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        A__      (						self	:		Any						):



       """simple docstring"""
       lowerCAmelCase__										=      F"""\n        examples/by_feature/checkpointing.py\n        --checkpointing_steps 1\n        --output_dir {self.tmpdir}\n        """.split()
       lowerCAmelCase__										=      run_command(self._launch_args + testargs						)
       self.assertTrue(os.path.exists(os.path.join(self.tmpdir       ,						'''step_2'''						)						)						)
     def        A__      (						self	:		Any						):



       """simple docstring"""
       lowerCAmelCase__										=      F"""\n        examples/by_feature/checkpointing.py\n        --resume_from_checkpoint {os.path.join(self.tmpdir       ,						'epoch_0'						)}\n        """.split()
       lowerCAmelCase__										=      run_command(self._launch_args + testargs       ,						return_stdout=UpperCamelCase__						)
       self.assertNotIn('''epoch 0:'''       ,						UpperCamelCase__						)
       self.assertIn('''epoch 1:'''       ,						UpperCamelCase__						)
     def        A__      (						self	:		Optional[Any]						):



       """simple docstring"""
       lowerCAmelCase__										=      F"""\n        examples/by_feature/checkpointing.py\n        --resume_from_checkpoint {os.path.join(self.tmpdir       ,						'step_2'						)}\n        """.split()
       lowerCAmelCase__										=      run_command(self._launch_args + testargs       ,						return_stdout=UpperCamelCase__						)
       if torch.cuda.is_available():
         lowerCAmelCase__										=      torch.cuda.device_count()
       else:
         lowerCAmelCase__										=      1
       if num_processes > 1:
         self.assertNotIn('''epoch 0:'''       ,						UpperCamelCase__						)
         self.assertIn('''epoch 1:'''       ,						UpperCamelCase__						)
       else:
         self.assertIn('''epoch 0:'''       ,						UpperCamelCase__						)
         self.assertIn('''epoch 1:'''       ,						UpperCamelCase__						)
     @slow
     def        A__      (						self	:		List[Any]						):



       """simple docstring"""
       lowerCAmelCase__										=      '''\n        examples/by_feature/cross_validation.py\n        --num_folds 2\n        '''.split()
       with mock.patch.dict(os.environ       ,						{'''TESTING_MOCKED_DATALOADERS''': '''0'''}						):
         lowerCAmelCase__										=      run_command(self._launch_args + testargs       ,						return_stdout=UpperCamelCase__						)
         lowerCAmelCase__										=      re.findall('''({.+})'''       ,						UpperCamelCase__						)
         lowerCAmelCase__										=      [r for r in results if '''accuracy''' in r][-1]
         lowerCAmelCase__										=      ast.literal_eval(UpperCamelCase__						)
         self.assertGreaterEqual(results['''accuracy''']       ,						0.75						)
     def        A__      (						self	:		Any						):



       """simple docstring"""
       lowerCAmelCase__										=      ['''examples/by_feature/multi_process_metrics.py''']
       run_command(self._launch_args + testargs						)
     @require_trackers
     @mock.patch.dict(os.environ       ,						{'''WANDB_MODE''': '''offline'''}						)
     def        A__      (						self	:		Tuple						):



       """simple docstring"""
       with tempfile.TemporaryDirectory() as tmpdir:
         lowerCAmelCase__										=      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(UpperCamelCase__       ,						'''tracking'''						)						)						)
     def        A__      (						self	:		Optional[Any]						):



       """simple docstring"""
       lowerCAmelCase__										=      ['''examples/by_feature/gradient_accumulation.py''']
       run_command(self._launch_args + testargs						)



     def        A__      (						self	:		str						):



       """simple docstring"""
       lowerCAmelCase__										=      ['''examples/by_feature/local_sgd.py''']
       run_command(self._launch_args + testargs						)


'''simple docstring'''






import pytest
import requests

from datasets.utils.file_utils import http_head

from .utils import OfflineSimulationMode, RequestWouldHangIndefinitelyError, offline





@pytest.mark.integration
def  _SCREAMING_SNAKE_CASE		(      ):
     with offline(OfflineSimulationMode.CONNECTION_TIMES_OUT				):
          with pytest.raises(__snake_case				):
               requests.request('GET'   ,		'https://huggingface.co'				)
          with pytest.raises(requests.exceptions.ConnectTimeout				):
               requests.request('GET'   ,		'https://huggingface.co'   ,		timeout=1.0				)





@pytest.mark.integration
def  _SCREAMING_SNAKE_CASE		(      ):
     with offline(OfflineSimulationMode.CONNECTION_FAILS				):
          with pytest.raises(requests.exceptions.ConnectionError				):
               requests.request('GET'   ,		'https://huggingface.co'				)





def  _SCREAMING_SNAKE_CASE		(      ):
     with offline(OfflineSimulationMode.HF_DATASETS_OFFLINE_SET_TO_1				):
          with pytest.raises(__snake_case				):
               http_head('https://huggingface.co'				)



