
import os
import sys
import tempfile

import torch

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

def a__       (			A_,	A_=(),	A_=None,	A_="no",	A_="29500"   ):






  '''simple docstring'''





  __magic_name__								=			False
  __magic_name__								=			False
  if any(key.startswith("""KAGGLE"""   ) for key in os.environ.keys()   ):
    __magic_name__								=			True
  elif "IPython" in sys.modules:
    __magic_name__								=			"""google.colab""" in str(sys.modules["""IPython"""].get_ipython()   )

  try:
    __magic_name__								=			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""",	A_   ) 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:
      __magic_name__								=			8

    __magic_name__								=			PrepareForLaunch(A_,	distributed_type="""TPU"""   )
    print(f'''Launching a training on {num_processes} TPU cores.'''   )
    xmp.spawn(A_,	args=A_,	nprocs=A_,	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(*A_   )
  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=A_,	master_addr="""127.0.01""",	master_port=A_,	mixed_precision=A_   ):
        __magic_name__								=			PrepareForLaunch(A_,	distributed_type="""MULTI_GPU"""   )
        print(f'''Launching training on {num_processes} GPUs.'''   )
        try:
          start_processes(A_,	args=A_,	nprocs=A_,	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():
        __magic_name__								=			"""1"""
        print("""Launching training on MPS."""   )
      elif torch.cuda.is_available():
        print("""Launching training on one GPU."""   )
      else:
        print("""Launching training on CPU."""   )
      function(*A_   )





def a__       (			A_,	A_=(),	A_=2   ):






  '''simple docstring'''





  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=A_,	master_addr="""127.0.01""",	master_port="""29500""",	accelerate_mixed_precision="""no""",	accelerate_debug_rdv_file=tmp_file.name,	accelerate_use_cpu="""yes""",	):
      __magic_name__								=			PrepareForLaunch(A_,	debug=A_   )
      start_processes(A_,	args=A_,	nprocs=A_,	start_method="""fork"""   )



# Copyright 2021 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import argparse
import os

from accelerate.utils import ComputeEnvironment

from .cluster import get_cluster_input
from .config_args import cache_dir, default_config_file, default_yaml_config_file, load_config_from_file  # noqa: F401
from .config_utils import _ask_field, _ask_options, _convert_compute_environment  # noqa: F401
from .sagemaker import get_sagemaker_input


__lowerCAmelCase     :	Optional[Any]       			=  'Launches a series of prompts to create and save a `default_config.yaml` configuration file for your training system. Should always be ran first on your machine'

def a__       (			):






  '''simple docstring'''





  __magic_name__								=			_ask_options(
      """In which compute environment are you running?""",	["""This machine""", """AWS (Amazon SageMaker)"""],	_convert_compute_environment,	)
  if compute_environment == ComputeEnvironment.AMAZON_SAGEMAKER:
    __magic_name__								=			get_sagemaker_input()
  else:
    __magic_name__								=			get_cluster_input()
  return config

def a__       (			A_=None   ):






  '''simple docstring'''





  if subparsers is not None:
    __magic_name__								=			subparsers.add_parser("""config""",	description=A_   )
  else:
    __magic_name__								=			argparse.ArgumentParser("""Accelerate config command""",	description=A_   )

  parser.add_argument(
      """--config_file""",	default=A_,	help=(
          """The path to use to store the config file. Will default to a file named default_config.yaml in the cache """
          """location, which is the content of the environment `HF_HOME` suffixed with 'accelerate', or if you don't have """
          """such an environment variable, your cache directory ('~/.cache' or the content of `XDG_CACHE_HOME`) suffixed """
          """with 'huggingface'."""
      ),	)

  if subparsers is not None:
    parser.set_defaults(func=A_   )
  return parser

def a__       (			A_   ):






  '''simple docstring'''





  __magic_name__								=			get_user_input()
  if args.config_file is not None:
    __magic_name__								=			args.config_file
  else:
    if not os.path.isdir(A_   ):
      os.makedirs(A_   )
    __magic_name__								=			default_yaml_config_file

  if config_file.endswith(""".json"""   ):
    config.to_json_file(A_   )
  else:
    config.to_yaml_file(A_   )
  print(f'''accelerate configuration saved at {config_file}'''   )

def a__       (			):






  '''simple docstring'''





  __magic_name__								=			config_command_parser()
  __magic_name__								=			parser.parse_args()
  config_command(A_   )


if __name__ == "__main__":
    main()

