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

     lowercase_  							=			True
except ImportError:
     lowercase_  							=			False


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







def 					__lowerCAmelCase				(		__SCREAMING_SNAKE_CASE       :					Optional[Any]   ):







    '''simple docstring'''
    # Check we're not importing a "pkg_name" directory somewhere but the actual library by trying to grab the version
    __snake_case       :				Union[str, Any] 			=    importlib.util.find_spec(__SCREAMING_SNAKE_CASE   ) is not None
    if package_exists:
        try:
            __snake_case       :				Any 			=    importlib.metadata.metadata(__SCREAMING_SNAKE_CASE   )
            return True
        except importlib.metadata.PackageNotFoundError:
            return False







def 					__lowerCAmelCase				(		):







    '''simple docstring'''
    return _torch_distributed_available







def 					__lowerCAmelCase				(		):







    '''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				(		):







    '''simple docstring'''
    return importlib.metadata.version("""oneccl_bind_pt"""   )







def 					__lowerCAmelCase				(		):







    '''simple docstring'''
    return _is_package_available("""transformer_engine"""   )







@lru_cache
def 					__lowerCAmelCase				(		__SCREAMING_SNAKE_CASE       :					str=True   ):







    '''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
            __snake_case       :				Tuple 			=    xm.xla_device()
            return True
        except RuntimeError:
            return False
    return _tpu_available







def 					__lowerCAmelCase				(		):







    '''simple docstring'''
    return _is_package_available("""deepspeed"""   )







def 					__lowerCAmelCase				(		__SCREAMING_SNAKE_CASE       :					Optional[Any]=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 					__lowerCAmelCase				(		):







    '''simple docstring'''
    __snake_case       :				int 			=    _is_package_available("""bitsandbytes"""   )
    if package_exists:
        __snake_case       :				Any 			=    version.parse(importlib.metadata.version("""bitsandbytes"""   )   )
        return compare_versions(__SCREAMING_SNAKE_CASE		,							""">="""		,							"""0.39.0"""   )
    return False







def 					__lowerCAmelCase				(		):







    '''simple docstring'''
    __snake_case       :				Union[str, Any] 			=    _is_package_available("""bitsandbytes"""   )
    if package_exists:
        __snake_case       :				str 			=    version.parse(importlib.metadata.version("""bitsandbytes"""   )   )
        return compare_versions(__SCREAMING_SNAKE_CASE		,							""">="""		,							"""0.37.2"""   )
    return False







def 					__lowerCAmelCase				(		):







    '''simple docstring'''
    return _is_package_available("""bitsandbytes"""   )







def 					__lowerCAmelCase				(		):







    '''simple docstring'''
    if strtobool(os.environ.get("""ACCELERATE_USE_MEGATRON_LM"""		,							"""False"""   )   ) == 1:
        __snake_case       :				List[Any] 			=    importlib.util.find_spec("""megatron"""   ) is not None
        if package_exists:
            try:
                __snake_case       :				Dict 			=    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				(		):







    '''simple docstring'''
    return _is_package_available("""safetensors"""   )







def 					__lowerCAmelCase				(		):







    '''simple docstring'''
    return _is_package_available("""transformers"""   )







def 					__lowerCAmelCase				(		):







    '''simple docstring'''
    return _is_package_available("""datasets"""   )







def 					__lowerCAmelCase				(		):







    '''simple docstring'''
    return _is_package_available("""aim"""   )







def 					__lowerCAmelCase				(		):







    '''simple docstring'''
    return _is_package_available("""tensorboard"""   ) or _is_package_available("""tensorboardX"""   )







def 					__lowerCAmelCase				(		):







    '''simple docstring'''
    return _is_package_available("""wandb"""   )







def 					__lowerCAmelCase				(		):







    '''simple docstring'''
    return _is_package_available("""comet_ml"""   )







def 					__lowerCAmelCase				(		):







    '''simple docstring'''
    return _is_package_available("""boto3"""   )







def 					__lowerCAmelCase				(		):







    '''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				(		):







    '''simple docstring'''
    return _is_package_available("""sagemaker"""   )







def 					__lowerCAmelCase				(		):







    '''simple docstring'''
    return _is_package_available("""tqdm"""   )







def 					__lowerCAmelCase				(		):







    '''simple docstring'''
    return _is_package_available("""mlflow"""   )







def 					__lowerCAmelCase				(		):







    '''simple docstring'''
    return is_torch_version(""">="""		,							"""1.12"""   ) and torch.backends.mps.is_available() and torch.backends.mps.is_built()







def 					__lowerCAmelCase				(		):







    '''simple docstring'''
    def get_major_and_minor_from_version(__SCREAMING_SNAKE_CASE       :					Dict   ):
        return str(version.parse(__SCREAMING_SNAKE_CASE   ).major   ) + "." + str(version.parse(__SCREAMING_SNAKE_CASE   ).minor   )

    __snake_case       :				Union[str, Any] 			=    importlib.metadata.version("""torch"""   )
    if importlib.util.find_spec("""intel_extension_for_pytorch"""   ) is None:
        return False
    __snake_case       :				List[Any] 			=    """N/A"""
    try:
        __snake_case       :				Tuple 			=    importlib.metadata.version("""intel_extension_for_pytorch"""   )
    except importlib.metadata.PackageNotFoundError:
        return False
    __snake_case       :				int 			=    get_major_and_minor_from_version(_torch_version   )
    __snake_case       :				Any 			=    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       :					List[str]=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
            __snake_case       :				str 			=    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       :					Any=False   ):







    '''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
            __snake_case       :				int 			=    torch.xpu.device_count()
            return torch.xpu.is_available()
        except RuntimeError:
            return False
    return hasattr(__SCREAMING_SNAKE_CASE		,							"""xpu"""   ) and torch.xpu.is_available()




import torch
from torch import autograd







class      SCREAMING_SNAKE_CASE__					(  autograd.Function    ):

       @staticmethod
       def 			snake_case__    (							_lowerCAmelCase					:     Any			,			_lowerCAmelCase					:     torch.tensor			,			_lowerCAmelCase					:     float			,			_lowerCAmelCase					:     bool			):
           __snake_case       :				Optional[int] 			=    inputs.numel()
           __snake_case       :				str 			=    int(0.005 * nb_elems			) + 1
           if sigmoid:
               __snake_case       :				Union[str, Any] 			=    (torch.sigmoid(_lowerCAmelCase			) > threshold).type(inputs.type()			)
           else:
               __snake_case       :				Any 			=    (inputs > threshold).type(inputs.type()			)
           if mask.sum() < nb_min:
               # We limit the pruning so that at least 0.5% (half a percent) of the weights are remaining
               __snake_case       :				Dict 			=    inputs.flatten().kthvalue(max(nb_elems - nb_min			,			1			)			).values
               __snake_case       :				List[str] 			=    (inputs > k_threshold).type(inputs.type()			)
           return mask





       @staticmethod
       def 			snake_case__    (							_lowerCAmelCase					:     str			,			_lowerCAmelCase					:     Tuple			):
           return gradOutput, None, None







class      SCREAMING_SNAKE_CASE__					(  autograd.Function    ):

       @staticmethod
       def 			snake_case__    (							_lowerCAmelCase					:     Optional[int]			,			_lowerCAmelCase					:     torch.tensor			,			_lowerCAmelCase					:     float			):
           __snake_case       :				str 			=    inputs.clone()
           __snake_case			, __snake_case       :				Dict 			=    inputs.flatten().sort(descending=_lowerCAmelCase			)
           __snake_case       :				Optional[Any] 			=    int(threshold * inputs.numel()			)

           # flat_out and mask access the same memory.
           __snake_case       :				Optional[int] 			=    mask.flatten()
           __snake_case       :				Dict 			=    0
           __snake_case       :				Optional[Any] 			=    1
           return mask





       @staticmethod
       def 			snake_case__    (							_lowerCAmelCase					:     Any			,			_lowerCAmelCase					:     Optional[Any]			):
           return gradOutput, None







class      SCREAMING_SNAKE_CASE__					(  __UpperCamelCase    ):

       @staticmethod
       def 			snake_case__    (							_lowerCAmelCase					:     torch.tensor			,			_lowerCAmelCase					:     float			):
           __snake_case       :				List[str] 			=    inputs.clone()
           __snake_case			, __snake_case       :				str 			=    inputs.abs().flatten().sort(descending=_lowerCAmelCase			)
           __snake_case       :				List[Any] 			=    int(threshold * inputs.numel()			)

           # flat_out and mask access the same memory.
           __snake_case       :				List[Any] 			=    mask.flatten()
           __snake_case       :				int 			=    0
           __snake_case       :				Optional[int] 			=    1
           return mask



