





import importlib
import importlib.metadata
import os
import warnings
from distutils.util import strtobool
from functools import lru_cache

import torch
from packaging import version
from packaging.version import parse

from .environment import parse_flag_from_env
from .versions import compare_versions, is_torch_version


try:
				import torch_xla.core.xla_model as xm  # noqa: F401

				__lowercase							:Tuple							=	True
except ImportError:
				__lowercase							:Any							=	False


# Cache this result has it's a C FFI call which can be pretty time-consuming
__lowercase							:int							=	torch.distributed.is_available()







def    UpperCAmelCase				(  _lowerCamelCase   :	Optional[int]  ):





						'''simple docstring'''


						SCREAMING_SNAKE_CASE__  :					str =       importlib.util.find_spec(_lowerCamelCase  ) is not None
						if package_exists:
												try:
																		SCREAMING_SNAKE_CASE__  :					Optional[Any] =       importlib.metadata.metadata(_lowerCamelCase  )
																		return True
												except importlib.metadata.PackageNotFoundError:
																		return False







def    UpperCAmelCase				(  ):





						'''simple docstring'''


						return _torch_distributed_available







def    UpperCAmelCase				(  ):





						'''simple docstring'''


						try:
												pass
						except ImportError:
												print(
												    "Intel(R) oneCCL Bindings for PyTorch* is required to run DDP on Intel(R) GPUs, but it is not"
												    " detected. If you see \"ValueError: Invalid backend: 'ccl'\" error, please install Intel(R) oneCCL"
												    " Bindings for PyTorch*."  )
						return (
						    importlib.util.find_spec("torch_ccl"  ) is not None
						    or importlib.util.find_spec("oneccl_bindings_for_pytorch"  ) is not None
						)







def    UpperCAmelCase				(  ):





						'''simple docstring'''


						return importlib.metadata.version("oneccl_bind_pt"  )







def    UpperCAmelCase				(  ):





						'''simple docstring'''


						return _is_package_available("transformer_engine"  )







@lru_cache
def    UpperCAmelCase				(  _lowerCamelCase   :	Any=True  ):





						'''simple docstring'''


						if torch.cuda.is_available():
												return False
						if _tpu_available and check_device:
												try:
																		# Will raise a RuntimeError if no XLA configuration is found
																		SCREAMING_SNAKE_CASE__  :					List[Any] =       xm.xla_device()
																		return True
												except RuntimeError:
																		return False
						return _tpu_available







def    UpperCAmelCase				(  ):





						'''simple docstring'''


						return _is_package_available("deepspeed"  )







def    UpperCAmelCase				(  _lowerCamelCase   :	Tuple=False  ):





						'''simple docstring'''


						if is_tpu_available():
												return not ignore_tpu
						if torch.cuda.is_available():
												return torch.cuda.is_bfaa_supported()
						if is_npu_available():
												return False
						return True







def    UpperCAmelCase				(  ):





						'''simple docstring'''


						SCREAMING_SNAKE_CASE__  :					List[Any] =       _is_package_available("bitsandbytes"  )
						if package_exists:
												SCREAMING_SNAKE_CASE__  :					Optional[int] =       version.parse(importlib.metadata.version("bitsandbytes"  )  )
												return compare_versions(_lowerCamelCase      , ">="      , "0.39.0"  )
						return False







def    UpperCAmelCase				(  ):





						'''simple docstring'''


						SCREAMING_SNAKE_CASE__  :					Tuple =       _is_package_available("bitsandbytes"  )
						if package_exists:
												SCREAMING_SNAKE_CASE__  :					List[str] =       version.parse(importlib.metadata.version("bitsandbytes"  )  )
												return compare_versions(_lowerCamelCase      , ">="      , "0.37.2"  )
						return False







def    UpperCAmelCase				(  ):





						'''simple docstring'''


						return _is_package_available("bitsandbytes"  )







def    UpperCAmelCase				(  ):





						'''simple docstring'''


						if strtobool(os.environ.get("ACCELERATE_USE_MEGATRON_LM"      , "False"  )  ) == 1:
												SCREAMING_SNAKE_CASE__  :					List[str] =       importlib.util.find_spec("megatron"  ) is not None
												if package_exists:
																		try:
																								SCREAMING_SNAKE_CASE__  :					List[Any] =       parse(importlib.metadata.version("megatron-lm"  )  )
																								return compare_versions(_lowerCamelCase      , ">="      , "2.2.0"  )
																		except Exception as e:
																								warnings.warn(f"""Parse Megatron version failed. Exception:{e}"""  )
																								return False







def    UpperCAmelCase				(  ):





						'''simple docstring'''


						return _is_package_available("safetensors"  )







def    UpperCAmelCase				(  ):





						'''simple docstring'''


						return _is_package_available("transformers"  )







def    UpperCAmelCase				(  ):





						'''simple docstring'''


						return _is_package_available("datasets"  )







def    UpperCAmelCase				(  ):





						'''simple docstring'''


						return _is_package_available("aim"  )







def    UpperCAmelCase				(  ):





						'''simple docstring'''


						return _is_package_available("tensorboard"  ) or _is_package_available("tensorboardX"  )







def    UpperCAmelCase				(  ):





						'''simple docstring'''


						return _is_package_available("wandb"  )







def    UpperCAmelCase				(  ):





						'''simple docstring'''


						return _is_package_available("comet_ml"  )







def    UpperCAmelCase				(  ):





						'''simple docstring'''


						return _is_package_available("boto3"  )







def    UpperCAmelCase				(  ):





						'''simple docstring'''


						if _is_package_available("rich"  ):
												if "ACCELERATE_DISABLE_RICH" in os.environ:
																		warnings.warn(
																		    "`ACCELERATE_DISABLE_RICH` is deprecated and will be removed in v0.22.0 and deactivated by default. Please use `ACCELERATE_ENABLE_RICH` if you wish to use `rich`."  )
																		return not parse_flag_from_env("ACCELERATE_DISABLE_RICH"      , _lowerCamelCase  )
												return parse_flag_from_env("ACCELERATE_ENABLE_RICH"      , _lowerCamelCase  )
						return False







def    UpperCAmelCase				(  ):





						'''simple docstring'''


						return _is_package_available("sagemaker"  )







def    UpperCAmelCase				(  ):





						'''simple docstring'''


						return _is_package_available("tqdm"  )







def    UpperCAmelCase				(  ):





						'''simple docstring'''


						return _is_package_available("mlflow"  )







def    UpperCAmelCase				(  ):





						'''simple docstring'''


						return is_torch_version(">="      , "1.12"  ) and torch.backends.mps.is_available() and torch.backends.mps.is_built()







def    UpperCAmelCase				(  ):





						'''simple docstring'''


						def get_major_and_minor_from_version(_lowerCamelCase   :	Dict  ):
												return str(version.parse(_lowerCamelCase  ).major  ) + "." + str(version.parse(_lowerCamelCase  ).minor  )

						SCREAMING_SNAKE_CASE__  :					Dict =       importlib.metadata.version("torch"  )
						if importlib.util.find_spec("intel_extension_for_pytorch"  ) is None:
												return False
						SCREAMING_SNAKE_CASE__  :					Dict =       """N/A"""
						try:
												SCREAMING_SNAKE_CASE__  :					str =       importlib.metadata.version("intel_extension_for_pytorch"  )
						except importlib.metadata.PackageNotFoundError:
												return False
						SCREAMING_SNAKE_CASE__  :					Tuple =       get_major_and_minor_from_version(_torch_version  )
						SCREAMING_SNAKE_CASE__  :					Tuple =       get_major_and_minor_from_version(_ipex_version  )
						if torch_major_and_minor != ipex_major_and_minor:
												warnings.warn(
												    f"""Intel Extension for PyTorch {ipex_major_and_minor} needs to work with PyTorch {ipex_major_and_minor}.*,"""
												    f""" but PyTorch {_torch_version} is found. Please switch to the matching version and run again."""  )
												return False
						return True







@lru_cache
def    UpperCAmelCase				(  _lowerCamelCase   :	List[Any]=False  ):





						'''simple docstring'''


						if importlib.util.find_spec("torch"  ) is None or importlib.util.find_spec("torch_npu"  ) is None:
												return False

						import torch
						import torch_npu  # noqa: F401

						if check_device:
												try:
																		# Will raise a RuntimeError if no NPU is found
																		SCREAMING_SNAKE_CASE__  :					Dict =       torch.npu.device_count()
																		return torch.npu.is_available()
												except RuntimeError:
																		return False
						return hasattr(_lowerCamelCase      , "npu"  ) and torch.npu.is_available()







@lru_cache
def    UpperCAmelCase				(  _lowerCamelCase   :	List[Any]=False  ):





						'''simple docstring'''


						if not parse_flag_from_env("ACCELERATE_USE_XPU"      , default=_lowerCamelCase  ):
												return False
						if is_ipex_available():
												import torch

												if is_torch_version("<="      , "1.12"  ):
																		return False
						else:
												return False

						import intel_extension_for_pytorch  # noqa: F401

						if check_device:
												try:
																		# Will raise a RuntimeError if no XPU  is found
																		SCREAMING_SNAKE_CASE__  :					int =       torch.xpu.device_count()
																		return torch.xpu.is_available()
												except RuntimeError:
																		return False
						return hasattr(_lowerCamelCase      , "xpu"  ) and torch.xpu.is_available()







def    a__    (	A       ):
   return " ".join([word[::-1] for word in input_str.split()]       )


if __name__ == "__main__":
 import doctest

 doctest.testmod()


