


'''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       :   Any        = 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       :   Union[str, Any]        = torch.distributed.is_available()



def 						_UpperCamelCase							( UpperCamelCase__		):






				"""simple docstring"""



				__magic_name__				:					str						       =       importlib.util.find_spec(UpperCamelCase__		) is not None
				if package_exists:
								try:
												__magic_name__				:					List[str]						       =       importlib.metadata.metadata(UpperCamelCase__		)
												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							( UpperCamelCase__=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
												__magic_name__				:					Union[str, Any]						       =       xm.xla_device()
												return True
								except RuntimeError:
												return False
				return _tpu_available



def 						_UpperCamelCase							( ):






				"""simple docstring"""



				return _is_package_available("deepspeed"		)



def 						_UpperCamelCase							( UpperCamelCase__=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"""



				__magic_name__				:					List[str]						       =       _is_package_available("bitsandbytes"		)
				if package_exists:
								__magic_name__				:					Any						       =       version.parse(importlib.metadata.version("bitsandbytes"		)		)
								return compare_versions(UpperCamelCase__     ,   ">="     ,   "0.39.0"		)
				return False



def 						_UpperCamelCase							( ):






				"""simple docstring"""



				__magic_name__				:					Optional[Any]						       =       _is_package_available("bitsandbytes"		)
				if package_exists:
								__magic_name__				:					Dict						       =       version.parse(importlib.metadata.version("bitsandbytes"		)		)
								return compare_versions(UpperCamelCase__     ,   ">="     ,   "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:
								__magic_name__				:					Dict						       =       importlib.util.find_spec("megatron"		) is not None
								if package_exists:
												try:
																__magic_name__				:					Optional[Any]						       =       parse(importlib.metadata.version("megatron-lm"		)		)
																return compare_versions(UpperCamelCase__     ,   ">="     ,   "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"     ,   UpperCamelCase__		)
								return parse_flag_from_env("ACCELERATE_ENABLE_RICH"     ,   UpperCamelCase__		)
				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(UpperCamelCase__		):
								return str(version.parse(UpperCamelCase__		).major		) + "." + str(version.parse(UpperCamelCase__		).minor		)

				__magic_name__				:					Any						       =       importlib.metadata.version("torch"		)
				if importlib.util.find_spec("intel_extension_for_pytorch"		) is None:
								return False
				__magic_name__				:					Any						       =       "N/A"
				try:
								__magic_name__				:					Tuple						       =       importlib.metadata.version("intel_extension_for_pytorch"		)
				except importlib.metadata.PackageNotFoundError:
								return False
				__magic_name__				:					Union[str, Any]						       =       get_major_and_minor_from_version(_torch_version		)
				__magic_name__				:					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							( UpperCamelCase__=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
												__magic_name__				:					Optional[int]						       =       torch.npu.device_count()
												return torch.npu.is_available()
								except RuntimeError:
												return False
				return hasattr(UpperCamelCase__     ,   "npu"		) and torch.npu.is_available()




@lru_cache
def 						_UpperCamelCase							( UpperCamelCase__=False		):






				"""simple docstring"""



				if not parse_flag_from_env("ACCELERATE_USE_XPU"     ,   default=UpperCamelCase__		):
								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
												__magic_name__				:					Optional[Any]						       =       torch.xpu.device_count()
												return torch.xpu.is_available()
								except RuntimeError:
												return False
				return hasattr(UpperCamelCase__     ,   "xpu"		) and torch.xpu.is_available()



'''simple docstring'''







def 						_UpperCamelCase							( UpperCamelCase__		):






				"""simple docstring"""



				if not isinstance(UpperCamelCase__     ,   UpperCamelCase__		) or number < 0:
								raise ValueError("Input must be a non-negative integer"		)

				__magic_name__				:					str						       =       number & ~(number - 1)
				__magic_name__				:					Optional[int]						       =       0
				while intermediate:
								intermediate >>= 1
								index += 1
				return index - 1


if __name__ == "__main__":
		import doctest

		doctest.testmod(verbose=True)