


import os
import sys
import tempfile

import torch

from .state import AcceleratorState
from .utils import PrecisionType, PrepareForLaunch, is_mps_available, patch_environment






def 							__lowercase       (			__lowerCAmelCase							:    Dict ,   __lowerCAmelCase							:    str=() ,   __lowerCAmelCase							:    str=None ,   __lowerCAmelCase							:    List[str]="no" ,   __lowerCAmelCase							:    List[Any]="29500"       ):
							a__					=					False
							a__					=					False
							if any(key.startswith('KAGGLE'       ) for key in os.environ.keys()       ):
														a__					=					True
							elif "IPython" in sys.modules:
														a__					=					'google.colab' in str(sys.modules['IPython'].get_ipython()       )

							try:
														a__					=					PrecisionType(mixed_precision.lower()       )
							except ValueError:
														raise ValueError(
														    F'Unknown mixed_precision mode: {args.mixed_precision.lower()}. Choose between {PrecisionType.list()}.'       )

							if (in_colab or in_kaggle) and (os.environ.get('TPU_NAME' ,   _lowerCAmelCase       ) is not None):
														# TPU launch
														import torch_xla.distributed.xla_multiprocessing as xmp

														if len(AcceleratorState._shared_state       ) > 0:
																					raise ValueError(
																					    'To train on TPU in Colab or Kaggle Kernel, the `Accelerator` should only be initialized inside '
																					    'your training function. Restart your notebook and make sure no cells initializes an '
																					    '`Accelerator`.'       )
														if num_processes is None:
																					a__					=					8

														a__					=					PrepareForLaunch(_lowerCAmelCase ,   distributed_type='TPU'       )
														print(F'Launching a training on {num_processes} TPU cores.'       )
														xmp.spawn(_lowerCAmelCase ,   args=_lowerCAmelCase ,   nprocs=_lowerCAmelCase ,   start_method='fork'       )
							elif in_colab:
														# No need for a distributed launch otherwise as it's either CPU or one GPU.
														if torch.cuda.is_available():
																					print('Launching training on one GPU.'       )
														else:
																					print('Launching training on one CPU.'       )
														function(*_lowerCAmelCase       )
							else:
														if num_processes is None:
																					raise ValueError(
																					    'You have to specify the number of GPUs you would like to use, add `num_processes=...` to your call.'       )

														if num_processes > 1:
																					# Multi-GPU launch
																					from torch.multiprocessing import start_processes
																					from torch.multiprocessing.spawn import ProcessRaisedException

																					if len(AcceleratorState._shared_state       ) > 0:
																												raise ValueError(
																												    'To launch a multi-GPU training from your notebook, the `Accelerator` should only be initialized '
																												    'inside your training function. Restart your notebook and make sure no cells initializes an '
																												    '`Accelerator`.'       )

																					if torch.cuda.is_initialized():
																												raise ValueError(
																												    'To launch a multi-GPU training from your notebook, you need to avoid running any instruction '
																												    'using `torch.cuda` in any cell. Restart your notebook and make sure no cells use any CUDA '
																												    'function.'       )

																					# torch.distributed will expect a few environment variable to be here. We set the ones common to each
																					# process here (the other ones will be set be the launcher).
																					with patch_environment(
																					    world_size=_lowerCAmelCase ,   master_addr='127.0.01' ,   master_port=_lowerCAmelCase ,   mixed_precision=_lowerCAmelCase       ):
																												a__					=					PrepareForLaunch(_lowerCAmelCase ,   distributed_type='MULTI_GPU'       )
																												print(F'Launching training on {num_processes} GPUs.'       )
																												try:
																																			start_processes(_lowerCAmelCase ,   args=_lowerCAmelCase ,   nprocs=_lowerCAmelCase ,   start_method='fork'       )
																												except ProcessRaisedException as e:
																																			if "Cannot re-initialize CUDA in forked subprocess" in e.args[0]:
																																										raise RuntimeError(
																																										    'CUDA has been initialized before the `notebook_launcher` could create a forked subprocess. '
																																										    'This likely stems from an outside import causing issues once the `notebook_launcher()` is called. '
																																										    'Please review your imports and test them when running the `notebook_launcher()` to identify '
																																										    'which one is problematic.'       ) from e

														else:
																					# No need for a distributed launch otherwise as it's either CPU, GPU or MPS.
																					if is_mps_available():
																												a__					=					'1'
																												print('Launching training on MPS.'       )
																					elif torch.cuda.is_available():
																												print('Launching training on one GPU.'       )
																					else:
																												print('Launching training on CPU.'       )
																					function(*_lowerCAmelCase       )






def 							__lowercase       (			__lowerCAmelCase							:    str ,   __lowerCAmelCase							:    str=() ,   __lowerCAmelCase							:    Tuple=2       ):
							from torch.multiprocessing import start_processes

							with tempfile.NamedTemporaryFile() as tmp_file:
														# torch.distributed will expect a few environment variable to be here. We set the ones common to each
														# process here (the other ones will be set be the launcher).
														with patch_environment(
														    world_size=_lowerCAmelCase ,   master_addr='127.0.01' ,   master_port='29500' ,   accelerate_mixed_precision='no' ,   accelerate_debug_rdv_file=tmp_file.name ,   accelerate_use_cpu='yes' ,   ):
																					a__					=					PrepareForLaunch(_lowerCAmelCase ,   debug=_lowerCAmelCase       )
																					start_processes(_lowerCAmelCase ,   args=_lowerCAmelCase ,   nprocs=_lowerCAmelCase ,   start_method='fork'       )










snake_case							:	str					      =				{
    0: '''0''',
    1: '''1''',
    2: '''2''',
    3: '''3''',
    4: '''4''',
    5: '''5''',
    6: '''6''',
    7: '''7''',
    8: '''8''',
    9: '''9''',
    10: '''a''',
    11: '''b''',
    12: '''c''',
    13: '''d''',
    14: '''e''',
    15: '''f''',
}






def 							__lowercase       (			__lowerCAmelCase							:    float       ):
							assert type(__lowerCAmelCase       ) in (int, float) and decimal == int(__lowerCAmelCase       )
							a__					=					int(__lowerCAmelCase       )
							a__					=					''
							a__					=					False
							if decimal < 0:
														a__					=					True
														decimal *= -1
							while decimal > 0:
														a__				, a__					=					divmod(__lowerCAmelCase ,   1_6       )
														a__					=					values[remainder] + hexadecimal
							a__					=					'0x' + hexadecimal
							if negative:
														a__					=					'-' + hexadecimal
							return hexadecimal


if __name__ == "__main__":
						import doctest

						doctest.testmod()




