





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

	_lowerCamelCase       =	True
except ImportError:
	_lowerCamelCase       =	False


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






def  SCREAMING_SNAKE_CASE__							(				UpperCamelCase__:							Optional[int]			):
		# Check we're not importing a "pkg_name" directory somewhere but the actual library by trying to grab the version
		SCREAMING_SNAKE_CASE__								=					importlib.util.find_spec(UpperCamelCase__			) is not None
		if package_exists:
				try:
						SCREAMING_SNAKE_CASE__								=					importlib.metadata.metadata(UpperCamelCase__			)
						return True
				except importlib.metadata.PackageNotFoundError:
						return False






def  SCREAMING_SNAKE_CASE__							(				):
		return _torch_distributed_available






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






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






@lru_cache
def  SCREAMING_SNAKE_CASE__							(				UpperCamelCase__:							str=True			):
		# Due to bugs on the amp series GPUs, we disable torch-xla on them
		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__								=					xm.xla_device()
						return True
				except RuntimeError:
						return False
		return _tpu_available






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






def  SCREAMING_SNAKE_CASE__							(				UpperCamelCase__:							List[Any]=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  SCREAMING_SNAKE_CASE__							(				):
		SCREAMING_SNAKE_CASE__								=					_is_package_available("""bitsandbytes"""			)
		if package_exists:
				SCREAMING_SNAKE_CASE__								=					version.parse(importlib.metadata.version("""bitsandbytes"""			)			)
				return compare_versions(UpperCamelCase__    ,      """>="""    ,      """0.39.0"""			)
		return False






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






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






def  SCREAMING_SNAKE_CASE__							(				):
		if strtobool(os.environ.get("""ACCELERATE_USE_MEGATRON_LM"""    ,      """False"""			)			) == 1:
				SCREAMING_SNAKE_CASE__								=					importlib.util.find_spec("""megatron"""			) is not None
				if package_exists:
						try:
								SCREAMING_SNAKE_CASE__								=					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  SCREAMING_SNAKE_CASE__							(				):
		return _is_package_available("""safetensors"""			)






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






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






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






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






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






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






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






def  SCREAMING_SNAKE_CASE__							(				):
		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  SCREAMING_SNAKE_CASE__							(				):
		return _is_package_available("""sagemaker"""			)






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






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






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






def  SCREAMING_SNAKE_CASE__							(				):
		def get_major_and_minor_from_version(UpperCamelCase__:							str			):
				return str(version.parse(UpperCamelCase__			).major			) + "." + str(version.parse(UpperCamelCase__			).minor			)

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






"""simple docstring"""





import numpy as np




def 		lowerCAmelCase_	(  lowercase_   :							str		):

 '''simple docstring'''






 __SCREAMING_SNAKE_CASE :			Dict												=       np.exp(lowercase_		)

 # Add up the all the exponentials
 __SCREAMING_SNAKE_CASE :			Tuple												=       np.sum(lowercase_		)

 # Divide every exponent by the sum of all exponents
 __SCREAMING_SNAKE_CASE :			List[Any]												=       exponent_vector / sum_of_exponents

 return softmax_vector


if __name__ == "__main__":
    print(softmax((0,)))

