




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

      lowercase						:   Union[str, Any]      						=							True
except ImportError:
      lowercase						:   Optional[int]      						=							False


# Cache this result has it's a C FFI call which can be pretty time-consuming
lowercase						:   Union[str, Any]      						=							torch.distributed.is_available()




def 		a_(			lowerCamelCase   )					->int:






       '''simple docstring'''




       lowercase	:		Any    =   importlib.util.find_spec(lowerCamelCase   ) is not None
       if package_exists:
              try:
                     lowercase	:		Optional[int]    =   importlib.metadata.metadata(lowerCamelCase   )
                     return True
              except importlib.metadata.PackageNotFoundError:
                     return False




def 		a_(			)					->bool:






       '''simple docstring'''




       return _torch_distributed_available




def 		a_(			)					->Dict:






       '''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 		a_(			)					->Optional[int]:






       '''simple docstring'''




       return importlib.metadata.version('''oneccl_bind_pt'''   )




def 		a_(			)					->Tuple:






       '''simple docstring'''




       return _is_package_available('''transformer_engine'''   )




@lru_cache
def 		a_(			lowerCamelCase=True   )					->Any:






       '''simple docstring'''




       if torch.cuda.is_available():
              return False
       if _tpu_available and check_device:
              try:
                     # Will raise a RuntimeError if no XLA configuration is found
                     lowercase	:		List[str]    =   xm.xla_device()
                     return True
              except RuntimeError:
                     return False
       return _tpu_available




def 		a_(			)					->Dict:






       '''simple docstring'''




       return _is_package_available('''deepspeed'''   )




def 		a_(			lowerCamelCase=False   )					->int:






       '''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 		a_(			)					->List[str]:






       '''simple docstring'''




       lowercase	:		Union[str, Any]    =   _is_package_available('''bitsandbytes'''   )
       if package_exists:
              lowercase	:		int    =   version.parse(importlib.metadata.version('''bitsandbytes'''   )   )
              return compare_versions(lowerCamelCase ,					'''>=''' ,					'''0.39.0'''   )
       return False




def 		a_(			)					->Union[str, Any]:






       '''simple docstring'''




       lowercase	:		List[Any]    =   _is_package_available('''bitsandbytes'''   )
       if package_exists:
              lowercase	:		Dict    =   version.parse(importlib.metadata.version('''bitsandbytes'''   )   )
              return compare_versions(lowerCamelCase ,					'''>=''' ,					'''0.37.2'''   )
       return False




def 		a_(			)					->Optional[Any]:






       '''simple docstring'''




       return _is_package_available('''bitsandbytes'''   )




def 		a_(			)					->Tuple:






       '''simple docstring'''




       if strtobool(os.environ.get('''ACCELERATE_USE_MEGATRON_LM''' ,					'''False'''   )   ) == 1:
              lowercase	:		Any    =   importlib.util.find_spec('''megatron'''   ) is not None
              if package_exists:
                     try:
                            lowercase	:		List[Any]    =   parse(importlib.metadata.version('''megatron-lm'''   )   )
                            return compare_versions(lowerCamelCase ,					'''>=''' ,					'''2.2.0'''   )
                     except Exception as e:
                            warnings.warn(f"""Parse Megatron version failed. Exception:{e}"""   )
                            return False




def 		a_(			)					->List[Any]:






       '''simple docstring'''




       return _is_package_available('''safetensors'''   )




def 		a_(			)					->Tuple:






       '''simple docstring'''




       return _is_package_available('''transformers'''   )




def 		a_(			)					->List[Any]:






       '''simple docstring'''




       return _is_package_available('''datasets'''   )




def 		a_(			)					->Tuple:






       '''simple docstring'''




       return _is_package_available('''aim'''   )




def 		a_(			)					->Any:






       '''simple docstring'''




       return _is_package_available('''tensorboard'''   ) or _is_package_available('''tensorboardX'''   )




def 		a_(			)					->Dict:






       '''simple docstring'''




       return _is_package_available('''wandb'''   )




def 		a_(			)					->int:






       '''simple docstring'''




       return _is_package_available('''comet_ml'''   )




def 		a_(			)					->int:






       '''simple docstring'''




       return _is_package_available('''boto3'''   )




def 		a_(			)					->Dict:






       '''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''' ,					lowerCamelCase   )
              return parse_flag_from_env('''ACCELERATE_ENABLE_RICH''' ,					lowerCamelCase   )
       return False




def 		a_(			)					->Optional[int]:






       '''simple docstring'''




       return _is_package_available('''sagemaker'''   )




def 		a_(			)					->Any:






       '''simple docstring'''




       return _is_package_available('''tqdm'''   )




def 		a_(			)					->str:






       '''simple docstring'''




       return _is_package_available('''mlflow'''   )




def 		a_(			)					->Any:






       '''simple docstring'''




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




def 		a_(			)					->Optional[int]:






       '''simple docstring'''




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

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






       '''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
                     lowercase	:		List[str]    =   torch.npu.device_count()
                     return torch.npu.is_available()
              except RuntimeError:
                     return False
       return hasattr(lowerCamelCase ,					'''npu'''   ) and torch.npu.is_available()





@lru_cache
def 		a_(			lowerCamelCase=False   )					->Dict:






       '''simple docstring'''




       if not parse_flag_from_env('''ACCELERATE_USE_XPU''' ,					default=lowerCamelCase   ):
              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
                     lowercase	:		Optional[Any]    =   torch.xpu.device_count()
                     return torch.xpu.is_available()
              except RuntimeError:
                     return False
       return hasattr(lowerCamelCase ,					'''xpu'''   ) and torch.xpu.is_available()










'''simple docstring'''






from __future__ import annotations

from enum import Enum, unique
from typing import TypeVar

# Create a generic variable that can be 'Enum', or any subclass.
lowercase						:   Any      						=							TypeVar('''T''', bound='''Enum''')

@unique
class 	SCREAMING_SNAKE_CASE_		(							lowerCamelCase_					):
 __snake_case						:  Union[str, Any]       =   8_0
 __snake_case						:  Optional[Any]       =   7_0
 __snake_case						:  List[str]       =   6_0
 __snake_case						:  str       =   5_0
 __snake_case						:  Tuple       =   4_0
 __snake_case						:  Union[str, Any]       =   3_0
 __snake_case						:  Dict       =   2_0
 __snake_case						:  str       =   1_0






@unique
class 	SCREAMING_SNAKE_CASE_		(							lowerCamelCase_					):
 __snake_case						:  Optional[Any]       =   2_4
 __snake_case						:  List[str]       =   2_1
 __snake_case						:  Any       =   1_8
 __snake_case						:  Union[str, Any]       =   1_5
 __snake_case						:  Dict       =   1_2
 __snake_case						:  Union[str, Any]       =   9
 __snake_case						:  List[str]       =   6
 __snake_case						:  Optional[int]       =   3
 __snake_case						:  Tuple       =   2
 __snake_case						:  Any       =   1
 __snake_case						:  Optional[int]       =   -1
 __snake_case						:  Optional[int]       =   -2
 __snake_case						:  str       =   -3
 __snake_case						:  Optional[Any]       =   -6
 __snake_case						:  Optional[int]       =   -9
 __snake_case						:  List[Any]       =   -1_2
 __snake_case						:  str       =   -1_5
 __snake_case						:  str       =   -1_8
 __snake_case						:  Dict       =   -2_1
 __snake_case						:  int       =   -2_4



 @classmethod
 def  SCREAMING_SNAKE_CASE(	cls			):






        '''simple docstring'''




        return {unit.name: unit.value for unit in cls if unit.value > 0}





 @classmethod
 def  SCREAMING_SNAKE_CASE(	cls			):






        '''simple docstring'''




        return {unit.name: unit.value for unit in cls if unit.value < 0}






def 		a_(			lowerCamelCase   )					->str:






       '''simple docstring'''




       lowercase	:		Tuple    =   SIUnit.get_positive() if value > 0 else SIUnit.get_negative()
       for name_prefix, value_prefix in prefixes.items():
              lowercase	:		Dict    =   value / (10**value_prefix)
              if numerical_part > 1:
                     return f"""{numerical_part!s} {name_prefix}"""
       return str(lowerCamelCase   )




def 		a_(			lowerCamelCase   )					->str:






       '''simple docstring'''




       for prefix in BinaryUnit:
              lowercase	:		Dict    =   value / (2**prefix.value)
              if numerical_part > 1:
                     return f"""{numerical_part!s} {prefix.name}"""
       return str(lowerCamelCase   )


if __name__ == "__main__":
      import doctest

      doctest.testmod()




