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

					UpperCamelCase__ :						str    							=					True
except ImportError:
					UpperCamelCase__ :						Any    							=					False


# Cache this result has it's a C FFI call which can be pretty time-consuming
UpperCamelCase__ :						str    							=					torch.distributed.is_available()
def 				lowerCAmelCase_		(			SCREAMING_SNAKE_CASE_  )       ->       List[Any]:




			"""simple docstring"""
			# 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(SCREAMING_SNAKE_CASE_  ) is not None
			if package_exists:
						try:
									_SCREAMING_SNAKE_CASE       	=			importlib.metadata.metadata(SCREAMING_SNAKE_CASE_  )
									return True
						except importlib.metadata.PackageNotFoundError:
									return False
def 				lowerCAmelCase_		(			)       ->       Optional[int]:




			"""simple docstring"""
			return _torch_distributed_available
def 				lowerCAmelCase_		(			)       ->       Tuple:




			"""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 				lowerCAmelCase_		(			)       ->       int:




			"""simple docstring"""
			return importlib.metadata.version("""oneccl_bind_pt"""  )
def 				lowerCAmelCase_		(			)       ->       int:




			"""simple docstring"""
			return _is_package_available("""transformer_engine"""  )
@lru_cache
def 				lowerCAmelCase_		(			SCREAMING_SNAKE_CASE_=True  )       ->       Any:




			"""simple docstring"""
			# 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 				lowerCAmelCase_		(			)       ->       Optional[Any]:




			"""simple docstring"""
			return _is_package_available("""deepspeed"""  )
def 				lowerCAmelCase_		(			SCREAMING_SNAKE_CASE_=False  )       ->       Union[str, Any]:




			"""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 				lowerCAmelCase_		(			)       ->       Any:




			"""simple docstring"""
			_SCREAMING_SNAKE_CASE       	=			_is_package_available("""bitsandbytes"""  )
			if package_exists:
						_SCREAMING_SNAKE_CASE       	=			version.parse(importlib.metadata.version("""bitsandbytes"""  )  )
						return compare_versions(SCREAMING_SNAKE_CASE_      , """>="""      , """0.39.0"""  )
			return False
def 				lowerCAmelCase_		(			)       ->       Optional[int]:




			"""simple docstring"""
			_SCREAMING_SNAKE_CASE       	=			_is_package_available("""bitsandbytes"""  )
			if package_exists:
						_SCREAMING_SNAKE_CASE       	=			version.parse(importlib.metadata.version("""bitsandbytes"""  )  )
						return compare_versions(SCREAMING_SNAKE_CASE_      , """>="""      , """0.37.2"""  )
			return False
def 				lowerCAmelCase_		(			)       ->       str:




			"""simple docstring"""
			return _is_package_available("""bitsandbytes"""  )
def 				lowerCAmelCase_		(			)       ->       Dict:




			"""simple docstring"""
			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(SCREAMING_SNAKE_CASE_      , """>="""      , """2.2.0"""  )
									except Exception as e:
												warnings.warn(F"Parse Megatron version failed. Exception:{e}"  )
												return False
def 				lowerCAmelCase_		(			)       ->       int:




			"""simple docstring"""
			return _is_package_available("""safetensors"""  )
def 				lowerCAmelCase_		(			)       ->       Union[str, Any]:




			"""simple docstring"""
			return _is_package_available("""transformers"""  )
def 				lowerCAmelCase_		(			)       ->       Optional[Any]:




			"""simple docstring"""
			return _is_package_available("""datasets"""  )
def 				lowerCAmelCase_		(			)       ->       List[str]:




			"""simple docstring"""
			return _is_package_available("""aim"""  )
def 				lowerCAmelCase_		(			)       ->       List[str]:




			"""simple docstring"""
			return _is_package_available("""tensorboard"""  ) or _is_package_available("""tensorboardX"""  )
def 				lowerCAmelCase_		(			)       ->       Optional[int]:




			"""simple docstring"""
			return _is_package_available("""wandb"""  )
def 				lowerCAmelCase_		(			)       ->       Union[str, Any]:




			"""simple docstring"""
			return _is_package_available("""comet_ml"""  )
def 				lowerCAmelCase_		(			)       ->       Any:




			"""simple docstring"""
			return _is_package_available("""boto3"""  )
def 				lowerCAmelCase_		(			)       ->       Tuple:




			"""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"""      , SCREAMING_SNAKE_CASE_  )
						return parse_flag_from_env("""ACCELERATE_ENABLE_RICH"""      , SCREAMING_SNAKE_CASE_  )
			return False
def 				lowerCAmelCase_		(			)       ->       Tuple:




			"""simple docstring"""
			return _is_package_available("""sagemaker"""  )
def 				lowerCAmelCase_		(			)       ->       Union[str, Any]:




			"""simple docstring"""
			return _is_package_available("""tqdm"""  )
def 				lowerCAmelCase_		(			)       ->       Optional[Any]:




			"""simple docstring"""
			return _is_package_available("""mlflow"""  )
def 				lowerCAmelCase_		(			)       ->       List[Any]:




			"""simple docstring"""
			return is_torch_version(""">="""      , """1.12"""  ) and torch.backends.mps.is_available() and torch.backends.mps.is_built()
def 				lowerCAmelCase_		(			)       ->       List[str]:




			"""simple docstring"""
			def get_major_and_minor_from_version(SCREAMING_SNAKE_CASE_  ):
						return str(version.parse(SCREAMING_SNAKE_CASE_  ).major  ) + "." + str(version.parse(SCREAMING_SNAKE_CASE_  ).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 				lowerCAmelCase_		(			SCREAMING_SNAKE_CASE_=False  )       ->       int:




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







@lru_cache
def 				lowerCAmelCase_		(			SCREAMING_SNAKE_CASE_=False  )       ->       Tuple:




			"""simple docstring"""
			if not parse_flag_from_env("""ACCELERATE_USE_XPU"""      , default=SCREAMING_SNAKE_CASE_  ):
						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(SCREAMING_SNAKE_CASE_      , """xpu"""  ) and torch.xpu.is_available()








'''simple docstring'''



def 				lowerCAmelCase_		(			SCREAMING_SNAKE_CASE_  )       ->       str:




   """simple docstring"""
   return " ".join(sorted(set(sentence.split()  )  )  )


if __name__ == "__main__":
     import doctest

     doctest.testmod()






