


'''simple docstring'''
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

							__SCREAMING_SNAKE_CASE				:							int		       =		True
except ImportError:
							__SCREAMING_SNAKE_CASE				:							Dict		       =		False


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







def 			a_							(  UpperCamelCase_   ):
							A_ 						=		importlib.util.find_spec(_A   ) is not None
							if package_exists:
														try:
																					A_ 						=		importlib.metadata.metadata(_A   )
																					return True
														except importlib.metadata.PackageNotFoundError:
																					return False







def 			a_							(  ):
							return _torch_distributed_available







def 			a_							(  ):







							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 			a_							(  ):
							return importlib.metadata.version("oneccl_bind_pt"   )







def 			a_							(  ):
							return _is_package_available("transformer_engine"   )







@lru_cache
def 			a_							(  UpperCamelCase_=True   ):







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







def 			a_							(  ):
							return _is_package_available("deepspeed"   )







def 			a_							(  UpperCamelCase_=False   ):







							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 			a_							(  ):
							A_ 						=		_is_package_available("bitsandbytes"   )
							if package_exists:
														A_ 						=		version.parse(importlib.metadata.version("bitsandbytes"   )   )
														return compare_versions(_A	,     ">="	,     "0.39.0"   )
							return False







def 			a_							(  ):
							A_ 						=		_is_package_available("bitsandbytes"   )
							if package_exists:
														A_ 						=		version.parse(importlib.metadata.version("bitsandbytes"   )   )
														return compare_versions(_A	,     ">="	,     "0.37.2"   )
							return False







def 			a_							(  ):
							return _is_package_available("bitsandbytes"   )







def 			a_							(  ):







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







def 			a_							(  ):
							return _is_package_available("safetensors"   )







def 			a_							(  ):
							return _is_package_available("transformers"   )







def 			a_							(  ):
							return _is_package_available("datasets"   )







def 			a_							(  ):
							return _is_package_available("aim"   )







def 			a_							(  ):
							return _is_package_available("tensorboard"   ) or _is_package_available("tensorboardX"   )







def 			a_							(  ):
							return _is_package_available("wandb"   )







def 			a_							(  ):
							return _is_package_available("comet_ml"   )







def 			a_							(  ):
							return _is_package_available("boto3"   )







def 			a_							(  ):







							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"	,     _A   )
														return parse_flag_from_env("ACCELERATE_ENABLE_RICH"	,     _A   )
							return False







def 			a_							(  ):
							return _is_package_available("sagemaker"   )







def 			a_							(  ):
							return _is_package_available("tqdm"   )







def 			a_							(  ):
							return _is_package_available("mlflow"   )







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







def 			a_							(  ):







							def get_major_and_minor_from_version(UpperCamelCase_   ):
														return str(version.parse(_A   ).major   ) + "." + str(version.parse(_A   ).minor   )

							A_ 						=		importlib.metadata.version("torch"   )
							if importlib.util.find_spec("intel_extension_for_pytorch"   ) is None:
														return False
							A_ 						=		"N/A"
							try:
														A_ 						=		importlib.metadata.version("intel_extension_for_pytorch"   )
							except importlib.metadata.PackageNotFoundError:
														return False
							A_ 						=		get_major_and_minor_from_version(_torch_version   )
							A_ 						=		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 			a_							(  UpperCamelCase_=False   ):







							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
																					A_ 						=		torch.npu.device_count()
																					return torch.npu.is_available()
														except RuntimeError:
																					return False
							return hasattr(_A	,     "npu"   ) and torch.npu.is_available()







@lru_cache
def 			a_							(  UpperCamelCase_=False   ):







							if not parse_flag_from_env("ACCELERATE_USE_XPU"	,     default=_A   ):
														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
																					A_ 						=		torch.xpu.device_count()
																					return torch.xpu.is_available()
														except RuntimeError:
																					return False
							return hasattr(_A	,     "xpu"   ) and torch.xpu.is_available()









'''simple docstring'''
def 			a_							(  UpperCamelCase_   ):
							if not isinstance(UpperCamelCase_	,     UpperCamelCase_   ):
														A_ 						=		f"Input value of [number={number}] must be an integer"
														raise TypeError(UpperCamelCase_   )
							if number < 0 or number % 2 == 1:
														return False
							A_ 						=		int(number**0.5   )
							return number == number_sqrt * (number_sqrt + 1)


if __name__ == "__main__":
							import doctest

							doctest.testmod()





