





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


def   a_					(_lowerCAmelCase  :   int       )->				str:
    if not isinstance(_lowerCAmelCase			,	_lowerCAmelCase       ):
        snake_case:						Optional[Any]         =   (
            """operation can not be conducted on a object of type """
            F"{type(_lowerCAmelCase       ).__name__}"
        )
        raise TypeError(_lowerCAmelCase       )
    snake_case:						List[Any]         =   """"""
    for _ in range(0			,	32       ):
        bit_string += str(number % 2       )
        snake_case:						Any         =   number >> 1
    return bit_string

def   a_					(_lowerCAmelCase  :   int       )->				str:
    if number < 0:
        raise ValueError("""the value of input must be positive"""       )
    elif isinstance(_lowerCAmelCase			,	_lowerCAmelCase       ):
        raise TypeError("""Input value must be a 'int' type"""       )
    elif isinstance(_lowerCAmelCase			,	_lowerCAmelCase       ):
        raise TypeError("""'<' not supported between instances of 'str' and 'int'"""       )
    snake_case:						Optional[Any]         =   0
    # iterator over [1 to 32],since we are dealing with 32 bit integer
    for _ in range(1			,	33       ):
        # left shift the bits by unity
        snake_case:						Dict         =   result << 1
        # get the end bit
        snake_case:						Union[str, Any]         =   number % 2
        # right shift the bits by unity
        snake_case:						Union[str, Any]         =   number >> 1
        # add that bit to our ans
        snake_case:						Tuple         =   result | end_bit
    return get_reverse_bit_string(_lowerCAmelCase       )


if __name__ == "__main__":
    import doctest

    doctest.testmod()


