



'''simple docstring'''
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__		:     Dict=()	,							lowerCAmelCase__		:     int=None	,							lowerCAmelCase__		:     List[str]="no"	,							lowerCAmelCase__		:     int="29500"       ):

			"""simple docstring"""





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

			try:
						__UpperCAmelCase      :					Optional[int]   =   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"""	,							UpperCamelCase_       ) 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:
									__UpperCAmelCase      :					Tuple   =   8

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






def      lowercase_		(      lowerCAmelCase__		:     Optional[Any]	,							lowerCAmelCase__		:     List[Any]=()	,							lowerCAmelCase__		:     Optional[int]=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=UpperCamelCase_	,							master_addr="""127.0.01"""	,							master_port="""29500"""	,							accelerate_mixed_precision="""no"""	,							accelerate_debug_rdv_file=tmp_file.name	,							accelerate_use_cpu="""yes"""	,							):
									__UpperCAmelCase      :					List[Any]   =   PrepareForLaunch(UpperCamelCase_	,							debug=UpperCamelCase_       )
									start_processes(UpperCamelCase_	,							args=UpperCamelCase_	,							nprocs=UpperCamelCase_	,							start_method="""fork"""       )







"""simple docstring"""





import unittest

from transformers import load_tool

from .test_tools_common import ToolTesterMixin




class 					_lowerCAmelCase  (	unittest.TestCase     ,lowercase   ):







 """simple docstring"""







 def 					_lowercase (			self							:			List[Any]	):
    __lowercase								=						load_tool("text-classification"	)
    self.tool.setup()
    __lowercase								=						load_tool("text-classification",					remote=UpperCAmelCase__	)


 def 					_lowercase (			self							:			str	):
    __lowercase								=						self.tool("That's quite cool",					["positive", "negative"]	)
    self.assertEqual(UpperCAmelCase__,					"positive"	)


 def 					_lowercase (			self							:			str	):
    __lowercase								=						self.remote_tool("That's quite cool",					["positive", "negative"]	)
    self.assertEqual(UpperCAmelCase__,					"positive"	)


 def 					_lowercase (			self							:			List[str]	):
    __lowercase								=						self.tool(text="That's quite cool",					labels=["positive", "negative"]	)
    self.assertEqual(UpperCAmelCase__,					"positive"	)



 def 					_lowercase (			self							:			Tuple	):
    __lowercase								=						self.remote_tool(text="That's quite cool",					labels=["positive", "negative"]	)
    self.assertEqual(UpperCAmelCase__,					"positive"	)




