





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										=					True
except ImportError:
     _UpperCAmelCase										=					False


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




def 			lowerCAmelCase_			(				UpperCamelCase_	)  ->		Any:
       # Check we're not importing a "pkg_name" directory somewhere but the actual library by trying to grab the version
       UpperCamelCase_ 							=	importlib.util.find_spec(UpperCamelCase_	) is not None
       if package_exists:
              try:
                     UpperCamelCase_ 							=	importlib.metadata.metadata(UpperCamelCase_	)
                     return True
              except importlib.metadata.PackageNotFoundError:
                     return False




def 			lowerCAmelCase_			(				)  ->		bool:
       return _torch_distributed_available




def 			lowerCAmelCase_			(				)  ->		int:
       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_			(				)  ->		Dict:
       return importlib.metadata.version("oneccl_bind_pt"	)




def 			lowerCAmelCase_			(				)  ->		List[str]:
       return _is_package_available("transformer_engine"	)




@lru_cache
def 			lowerCAmelCase_			(				UpperCamelCase_=True	)  ->		Dict:
       # 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
                     UpperCamelCase_ 							=	xm.xla_device()
                     return True
              except RuntimeError:
                     return False
       return _tpu_available




def 			lowerCAmelCase_			(				)  ->		List[Any]:
       return _is_package_available("deepspeed"	)




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




def 			lowerCAmelCase_			(				)  ->		int:
       UpperCamelCase_ 							=	_is_package_available("bitsandbytes"	)
       if package_exists:
              UpperCamelCase_ 							=	version.parse(importlib.metadata.version("bitsandbytes"	)	)
              return compare_versions(UpperCamelCase_       ,		">="       ,		"0.37.2"	)
       return False




def 			lowerCAmelCase_			(				)  ->		List[str]:
       return _is_package_available("bitsandbytes"	)




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




def 			lowerCAmelCase_			(				)  ->		Dict:
       return _is_package_available("transformers"	)




def 			lowerCAmelCase_			(				)  ->		int:
       return _is_package_available("datasets"	)




def 			lowerCAmelCase_			(				)  ->		int:
       return _is_package_available("aim"	)




def 			lowerCAmelCase_			(				)  ->		str:
       return _is_package_available("tensorboard"	) or _is_package_available("tensorboardX"	)




def 			lowerCAmelCase_			(				)  ->		str:
       return _is_package_available("wandb"	)




def 			lowerCAmelCase_			(				)  ->		Optional[Any]:
       return _is_package_available("comet_ml"	)




def 			lowerCAmelCase_			(				)  ->		Optional[Any]:
       return _is_package_available("boto3"	)




def 			lowerCAmelCase_			(				)  ->		Optional[int]:
       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 			lowerCAmelCase_			(				)  ->		Tuple:
       return _is_package_available("sagemaker"	)




def 			lowerCAmelCase_			(				)  ->		str:
       return _is_package_available("tqdm"	)




def 			lowerCAmelCase_			(				)  ->		List[str]:
       return _is_package_available("mlflow"	)




def 			lowerCAmelCase_			(				)  ->		Optional[int]:
       return is_torch_version(">="       ,		"1.12"	) and torch.backends.mps.is_available() and torch.backends.mps.is_built()




def 			lowerCAmelCase_			(				)  ->		int:
       def get_major_and_minor_from_version(UpperCamelCase_	):
              return str(version.parse(UpperCamelCase_	).major	) + "." + str(version.parse(UpperCamelCase_	).minor	)

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








from itertools import compress, repeat
from math import ceil, sqrt




def 			lowerCAmelCase_			(				UpperCamelCase_	)  ->		list[int]:

       if num <= 2:
              return []
       if num == 3:
              return [2]

       # Odd sieve for numbers in range [3, num - 1]
       UpperCamelCase_ 							=	bytearray(b"\x01"	) * ((num >> 1) - 1)

       for i in range(3       ,		int(sqrt(UpperCamelCase_	)	) + 1       ,		2	):
              if sieve[(i >> 1) - 1]:
                     UpperCamelCase_ 							=	i**2
                     UpperCamelCase_ 							=	repeat(
                         0       ,		ceil((num - i_squared) / (i << 1)	)	)

       return [2] + list(compress(range(3       ,		UpperCamelCase_       ,		2	)       ,		UpperCamelCase_	)	)


if __name__ == "__main__":
     import doctest

     doctest.testmod()

