





import pprint

import requests

_lowerCamelCase   				=			'https://zenquotes.io/api'






def 				SCREAMING_SNAKE_CASE__							(       ):
  return requests.get(API_ENDPOINT_URL + """/today"""    ).json()






def 				SCREAMING_SNAKE_CASE__							(       ):
  return requests.get(API_ENDPOINT_URL + """/random"""    ).json()


if __name__ == "__main__":
 _lowerCamelCase   				=			random_quotes()
 pprint.pprint(response)






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   UpperCamelCase_       (     unittest.TestCase    ):


							def      _snake_case  (							self    :Any		)   ->   int:



									"""simple docstring"""



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


							@require_multi_gpu
							def      _snake_case  (							self    :Optional[Any]		)   ->   Tuple:



									"""simple docstring"""



									print(f'''Found {torch.cuda.device_count()} devices.'''		)
									SCREAMING_SNAKE_CASE__			=      ["""torchrun""", f'''--nproc_per_node={torch.cuda.device_count()}''', self.test_file_path]
									with patch_environment(omp_num_threads=1		):
											execute_subprocess_async(__A							,				env=os.environ.copy()		)


							@require_multi_gpu
							def      _snake_case  (							self    :Tuple		)   ->   Optional[Any]:



									"""simple docstring"""



									print(f'''Found {torch.cuda.device_count()} devices.'''		)
									SCREAMING_SNAKE_CASE__			=      ["""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(__A							,				env=os.environ.copy()		)


							@require_multi_gpu
							def      _snake_case  (							self    :Optional[Any]		)   ->   Union[str, Any]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__			=      ["""torchrun""", f'''--nproc_per_node={torch.cuda.device_count()}''', inspect.getfile(self.__class__		)]
									with patch_environment(omp_num_threads=1		):
											execute_subprocess_async(__A							,				env=os.environ.copy()		)


							@require_multi_gpu
							def      _snake_case  (							self    :Optional[int]		)   ->   str:



									"""simple docstring"""



									print(f'''Found {torch.cuda.device_count()} devices, using 2 devices only'''		)
									SCREAMING_SNAKE_CASE__			=      ["""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(__A							,				env=os.environ.copy()		)


if __name__ == "__main__":
	_lowerCamelCase   				=			Accelerator()
	_lowerCamelCase   				=			(accelerator.state.process_index + 2, 10)
	_lowerCamelCase   				=			torch.randint(0, 10, shape).to(accelerator.device)

	_lowerCamelCase   				=			''

	_lowerCamelCase   				=			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)."

	_lowerCamelCase   				=			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."
	_lowerCamelCase   				=			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)