






import inspect
import os
import unittest
from pathlib import Path

import torch

import accelerate
from accelerate.test_utils import execute_subprocess_async
from accelerate.test_utils.testing import run_command


class     _a							(	unittest.TestCase     ):






  """simple docstring"""





  A_						       = inspect.getfile(accelerate.test_utils     )
  A_						       = os.path.sep.join(mod_file.split(os.path.sep     )[:-1] + ["""scripts""", """test_cli.py"""]     )

  A_						       = ["""accelerate""", """launch"""]
  A_						       = Path.home() / """.cache/huggingface/accelerate"""
  A_						       = """default_config.yaml"""
  A_						       = config_folder / config_file
  A_						       = config_folder / """_default_config.yaml"""

  A_						       = Path("""tests/test_configs"""     )




  @classmethod
  def  _UpperCAmelCase  (  cls			)      ->			Dict:
     if cls.config_path.is_file():
        cls.config_path.rename(cls.changed_path			)




  @classmethod
  def  _UpperCAmelCase  (  cls			)      ->			int:
     if cls.changed_path.is_file():
        cls.changed_path.rename(cls.config_path			)




  def  _UpperCAmelCase  (  self			)      ->			Tuple:
     UpperCamelCase_						=  self.base_cmd
     if torch.cuda.is_available() and (torch.cuda.device_count() > 1):
        cmd += ["--multi_gpu"]
     execute_subprocess_async(cmd + [self.test_file_path]		,		env=os.environ.copy()			)




  def  _UpperCAmelCase  (  self			)      ->			List[Any]:
     for config in sorted(self.test_config_path.glob('**/*.yaml'			)			):
        with self.subTest(config_file=_UpperCAmelCase			):
           execute_subprocess_async(
               self.base_cmd + ['--config_file', str(_UpperCAmelCase			), self.test_file_path]		,		env=os.environ.copy()			)




  def  _UpperCAmelCase  (  self			)      ->			List[Any]:
     execute_subprocess_async(['accelerate', 'test']		,		env=os.environ.copy()			)




class     _a							(	unittest.TestCase     ):






  """simple docstring"""





  A_						       = """test-tpu"""
  A_						       = """us-central1-a"""
  A_						       = """ls"""
  A_						       = ["""accelerate""", """tpu-config"""]
  A_						       = """cd /usr/share"""
  A_						       = """tests/test_samples/test_command_file.sh"""
  A_						       = """Running gcloud compute tpus tpu-vm ssh"""




  def  _UpperCAmelCase  (  self			)      ->			Dict:
     UpperCamelCase_						=  run_command(
         self.cmd
         + ['--command', self.command, '--tpu_zone', self.tpu_zone, '--tpu_name', self.tpu_name, '--debug']		,		return_stdout=_UpperCAmelCase		,		)
     self.assertIn(
         f"""{self.gcloud} test-tpu --zone us-central1-a --command {self.base_output}; ls --worker all"""		,		_UpperCAmelCase		,		)




  def  _UpperCAmelCase  (  self			)      ->			Any:
     UpperCamelCase_						=  run_command(
         self.cmd
         + [
             '--config_file',
             'tests/test_configs/0_12_0.yaml',
             '--command',
             self.command,
             '--tpu_zone',
             self.tpu_zone,
             '--tpu_name',
             self.tpu_name,
             '--debug',
         ]		,		return_stdout=_UpperCAmelCase		,		)
     self.assertIn(
         f"""{self.gcloud} test-tpu --zone us-central1-a --command {self.base_output}; ls --worker all"""		,		_UpperCAmelCase		,		)




  def  _UpperCAmelCase  (  self			)      ->			Dict:
     UpperCamelCase_						=  run_command(
         self.cmd + ['--config_file', 'tests/test_configs/latest.yaml', '--debug']		,		return_stdout=_UpperCAmelCase			)
     self.assertIn(
         f"""{self.gcloud} test-tpu --zone us-central1-a --command {self.base_output}; echo \"hello world\"; echo \"this is a second command\" --worker all"""		,		_UpperCAmelCase		,		)




  def  _UpperCAmelCase  (  self			)      ->			int:
     UpperCamelCase_						=  run_command(
         self.cmd + ['--config_file', 'tests/test_configs/latest.yaml', '--command', self.command, '--debug']		,		return_stdout=_UpperCAmelCase		,		)
     self.assertIn(
         f"""{self.gcloud} test-tpu --zone us-central1-a --command {self.base_output}; ls --worker all"""		,		_UpperCAmelCase		,		)




  def  _UpperCAmelCase  (  self			)      ->			Union[str, Any]:
     UpperCamelCase_						=  run_command(
         self.cmd
         + [
             '--config_file',
             'tests/test_configs/latest.yaml',
             '--command',
             self.command,
             '--command',
             'echo "Hello World"',
             '--debug',
         ]		,		return_stdout=_UpperCAmelCase		,		)
     self.assertIn(
         f"""{self.gcloud} test-tpu --zone us-central1-a --command {self.base_output}; ls; echo \"Hello World\" --worker all"""		,		_UpperCAmelCase		,		)




  def  _UpperCAmelCase  (  self			)      ->			Union[str, Any]:
     UpperCamelCase_						=  run_command(
         self.cmd
         + ['--config_file', 'tests/test_configs/latest.yaml', '--command_file', self.command_file, '--debug']		,		return_stdout=_UpperCAmelCase		,		)
     self.assertIn(
         f"""{self.gcloud} test-tpu --zone us-central1-a --command {self.base_output}; echo \"hello world\"; echo \"this is a second command\" --worker all"""		,		_UpperCAmelCase		,		)




  def  _UpperCAmelCase  (  self			)      ->			Dict:
     UpperCamelCase_						=  run_command(
         self.cmd
         + [
             '--config_file',
             'tests/test_configs/0_12_0.yaml',
             '--command_file',
             self.command_file,
             '--tpu_zone',
             self.tpu_zone,
             '--tpu_name',
             self.tpu_name,
             '--debug',
         ]		,		return_stdout=_UpperCAmelCase		,		)
     self.assertIn(
         f"""{self.gcloud} test-tpu --zone us-central1-a --command {self.base_output}; echo \"hello world\"; echo \"this is a second command\" --worker all"""		,		_UpperCAmelCase		,		)




  def  _UpperCAmelCase  (  self			)      ->			Union[str, Any]:
     UpperCamelCase_						=  run_command(
         self.cmd + ['--config_file', 'tests/test_configs/latest.yaml', '--install_accelerate', '--debug']		,		return_stdout=_UpperCAmelCase		,		)
     self.assertIn(
         f"""{self.gcloud} test-tpu --zone us-central1-a --command {self.base_output}; pip install accelerate -U; echo \"hello world\"; echo \"this is a second command\" --worker all"""		,		_UpperCAmelCase		,		)




  def  _UpperCAmelCase  (  self			)      ->			Dict:
     UpperCamelCase_						=  run_command(
         self.cmd
         + [
             '--config_file',
             'tests/test_configs/latest.yaml',
             '--install_accelerate',
             '--accelerate_version',
             '12.0.0',
             '--debug',
         ]		,		return_stdout=_UpperCAmelCase		,		)
     self.assertIn(
         f"""{self.gcloud} test-tpu --zone us-central1-a --command {self.base_output}; pip install accelerate==12.0.0; echo \"hello world\"; echo \"this is a second command\" --worker all"""		,		_UpperCAmelCase		,		)













import re
from pathlib import Path
from unittest import TestCase

import pytest


@pytest.mark.integration
class     _a							(	UpperCAmelCase__     ):






  """simple docstring"""





  def  _UpperCAmelCase  (  self		,		_UpperCAmelCase			)      ->			Dict:

     with open(_UpperCAmelCase		,		encoding='utf-8'			) as input_file:
        UpperCamelCase_						=  re.compile(R'(?!.*\b(?:encoding|rb|w|wb|w+|wb+|ab|ab+)\b)(?<=\s)(open)\((.*)\)'			)
        UpperCamelCase_						=  input_file.read()
        UpperCamelCase_						=  regexp.search(_UpperCAmelCase			)

     return match




  def  _UpperCAmelCase  (  self		,		_UpperCAmelCase			)      ->			Dict:

     with open(_UpperCAmelCase		,		encoding='utf-8'			) as input_file:
        UpperCamelCase_						=  re.compile(R'#[^\r\n]*print\(|\"[^\r\n]*print\(|\"\"\".*?print\(.*?\"\"\"|(print\()'		,		re.DOTALL			)
        UpperCamelCase_						=  input_file.read()
        # use `re.finditer` to handle the case where the ignored groups would be matched first by `re.search`
        UpperCamelCase_						=  regexp.finditer(_UpperCAmelCase			)

     UpperCamelCase_						=  [match for match in matches if match is not None and match.group(1			) is not None]
     return matches[0] if matches else None




  def  _UpperCAmelCase  (  self			)      ->			List[str]:
     UpperCamelCase_						=  Path('./datasets'			)
     UpperCamelCase_						=  list(dataset_paths.absolute().glob('**/*.py'			)			)

     for dataset in dataset_files:
        if self._no_encoding_on_file_open(str(_UpperCAmelCase			)			):
           raise AssertionError(f"""open(...) must use utf-8 encoding in {dataset}"""			)




  def  _UpperCAmelCase  (  self			)      ->			Optional[int]:
     UpperCamelCase_						=  Path('./datasets'			)
     UpperCamelCase_						=  list(dataset_paths.absolute().glob('**/*.py'			)			)

     for dataset in dataset_files:
        if self._no_print_statements(str(_UpperCAmelCase			)			):
           raise AssertionError(f"""print statement found in {dataset}. Use datasets.logger/logging instead."""			)





