






import inspect
import os
import unittest

import torch

import accelerate
from accelerate import Accelerator
from accelerate.test_utils import execute_subprocess_async, require_multi_gpu
from accelerate.utils import patch_environment


class     _a							(	unittest.TestCase     ):






  """simple docstring"""





  def  _UpperCAmelCase  (  self			)      ->			Union[str, Any]:
     UpperCamelCase_						=  inspect.getfile(accelerate.test_utils			)
     UpperCamelCase_						=  os.path.sep.join(mod_file.split(os.path.sep			)[:-1] + ['scripts', 'test_script.py']			)
     UpperCamelCase_						=  os.path.sep.join(
         mod_file.split(os.path.sep			)[:-1] + ['scripts', 'test_distributed_data_loop.py']			)
     UpperCamelCase_						=  os.path.sep.join(mod_file.split(os.path.sep			)[:-1] + ['scripts', 'test_ops.py']			)




  @require_multi_gpu
  def  _UpperCAmelCase  (  self			)      ->			Dict:
     print(f"""Found {torch.cuda.device_count()} devices."""			)
     UpperCamelCase_						=  ['torchrun', f"""--nproc_per_node={torch.cuda.device_count()}""", self.test_file_path]
     with patch_environment(omp_num_threads=1			):
        execute_subprocess_async(_UpperCAmelCase		,		env=os.environ.copy()			)




  @require_multi_gpu
  def  _UpperCAmelCase  (  self			)      ->			Optional[Any]:
     print(f"""Found {torch.cuda.device_count()} devices."""			)
     UpperCamelCase_						=  ['torchrun', f"""--nproc_per_node={torch.cuda.device_count()}""", self.operation_file_path]
     print(f"""Command: {cmd}"""			)
     with patch_environment(omp_num_threads=1			):
        execute_subprocess_async(_UpperCAmelCase		,		env=os.environ.copy()			)




  @require_multi_gpu
  def  _UpperCAmelCase  (  self			)      ->			Any:
     UpperCamelCase_						=  ['torchrun', f"""--nproc_per_node={torch.cuda.device_count()}""", inspect.getfile(self.__class__			)]
     with patch_environment(omp_num_threads=1			):
        execute_subprocess_async(_UpperCAmelCase		,		env=os.environ.copy()			)




  @require_multi_gpu
  def  _UpperCAmelCase  (  self			)      ->			List[str]:
     print(f"""Found {torch.cuda.device_count()} devices, using 2 devices only"""			)
     UpperCamelCase_						=  ['torchrun', f"""--nproc_per_node={torch.cuda.device_count()}""", self.data_loop_file_path]
     with patch_environment(omp_num_threads=1		,		cuda_visible_devices='0,1'			):
        execute_subprocess_async(_UpperCAmelCase		,		env=os.environ.copy()			)


if __name__ == "__main__":
 snake_case__   :						Dict													=   Accelerator()
 snake_case__   :						str													=   (accelerator.state.process_index + 2, 1_0)
 snake_case__   :						int													=   torch.randint(0, 1_0, shape).to(accelerator.device)

 snake_case__   :						List[Any]													=   """"""

 snake_case__   :						Any													=   accelerator.pad_across_processes(tensor)
 if tensora.shape[0] != accelerator.state.num_processes + 1:
  error_msg += f"Found shape {tensora.shape} but should have {accelerator.state.num_processes + 1} at dim 0."
 if not torch.equal(tensora[: accelerator.state.process_index + 2], tensor):
  error_msg += "Tensors have different values."
 if not torch.all(tensora[accelerator.state.process_index + 2 :] == 0):
  error_msg += "Padding was not done with the right value (0)."

 snake_case__   :						Optional[int]													=   accelerator.pad_across_processes(tensor, pad_first=True)
 if tensora.shape[0] != accelerator.state.num_processes + 1:
  error_msg += f"Found shape {tensora.shape} but should have {accelerator.state.num_processes + 1} at dim 0."
 snake_case__   :						Optional[Any]													=   accelerator.state.num_processes - accelerator.state.process_index - 1
 if not torch.equal(tensora[index:], tensor):
  error_msg += "Tensors have different values."
 if not torch.all(tensora[:index] == 0):
  error_msg += "Padding was not done with the right value (0)."

 # Raise error at the end to make sure we don't stop at the first failure.
 if len(error_msg) > 0:
  raise ValueError(error_msg)













import requests






def      _snake_case     (__lowercase     ,   __lowercase):
   UpperCamelCase_						=  {'Content-Type': 'application/json'}
   UpperCamelCase_						=  requests.post(__lowercase     ,   json={'text': message_body}     ,   headers=__lowercase)
   if response.status_code != 200:
      UpperCamelCase_						=  (
          'Request to slack returned an error '
          f"""{response.status_code}, the response is:\n{response.text}"""
      )
      raise ValueError(__lowercase)


if __name__ == "__main__":
 # Set the slack url to the one provided by Slack when you create the webhook at
 # https://my.slack.com/services/new/incoming-webhook/
 send_slack_message("""<YOUR MESSAGE BODY>""", """<SLACK CHANNEL URL>""")





