




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

  _lowerCAmelCase  :				Any						=				True
except ImportError:
  _lowerCAmelCase  :				int						=				False


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



def   lowerCAmelCase						(						_lowerCAmelCase							:				Dict		):




 """simple docstring"""







 UpperCAmelCase__								=  importlib.util.find_spec(_lowerCAmelCase		) is not None
 if package_exists:
  try:
   UpperCAmelCase__								=  importlib.metadata.metadata(_lowerCAmelCase		)
   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						(						_lowerCAmelCase							:				Dict=True		):




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



def   lowerCAmelCase						(						):




 """simple docstring"""







 return _is_package_available("deepspeed"		)



def   lowerCAmelCase						(						_lowerCAmelCase							:				List[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"""







 UpperCAmelCase__								=  _is_package_available("bitsandbytes"		)
 if package_exists:
  UpperCAmelCase__								=  version.parse(importlib.metadata.version("bitsandbytes"		)		)
  return compare_versions(_lowerCAmelCase  ,							">="  ,							"0.39.0"		)
 return False



def   lowerCAmelCase						(						):




 """simple docstring"""







 UpperCAmelCase__								=  _is_package_available("bitsandbytes"		)
 if package_exists:
  UpperCAmelCase__								=  version.parse(importlib.metadata.version("bitsandbytes"		)		)
  return compare_versions(_lowerCAmelCase  ,							">="  ,							"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:
  UpperCAmelCase__								=  importlib.util.find_spec("megatron"		) is not None
  if package_exists:
   try:
    UpperCAmelCase__								=  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   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"  ,							_lowerCAmelCase		)
  return parse_flag_from_env("ACCELERATE_ENABLE_RICH"  ,							_lowerCAmelCase		)
 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(_lowerCAmelCase							:				Any		):
  return str(version.parse(_lowerCAmelCase		).major		) + "." + str(version.parse(_lowerCAmelCase		).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						(						_lowerCAmelCase							:				Any=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
   UpperCAmelCase__								=  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   lowerCAmelCase						(						_lowerCAmelCase							:				int=False		):




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











from __future__ import annotations



def   lowerCAmelCase						(						_lowerCAmelCase							:				int  ,							_lowerCAmelCase							:				int  ,							_lowerCAmelCase							:				int		):




 """simple docstring"""







 assert (
     c % greatest_common_divisor(_lowerCAmelCase  ,							_lowerCAmelCase		) == 0
 )  # greatest_common_divisor(a,b) function implemented below
 ((UpperCAmelCase__)	,	(UpperCAmelCase__)	,	(UpperCAmelCase__))								=  extended_gcd(_lowerCAmelCase  ,							_lowerCAmelCase		)  # extended_gcd(a,b) function implemented below
 UpperCAmelCase__								=  c / d
 return (r * x, r * y)



def   lowerCAmelCase						(						_lowerCAmelCase							:				int  ,							_lowerCAmelCase							:				int  ,							_lowerCAmelCase							:				int  ,							_lowerCAmelCase							:				int = 2		):




 """simple docstring"""







 ((UpperCAmelCase__)	,	(UpperCAmelCase__))								=  diophantine(_lowerCAmelCase  ,							_lowerCAmelCase  ,							_lowerCAmelCase		)  # Initial value
 UpperCAmelCase__								=  greatest_common_divisor(_lowerCAmelCase  ,							_lowerCAmelCase		)
 UpperCAmelCase__								=  a // d
 UpperCAmelCase__								=  b // d

 for i in range(_lowerCAmelCase		):
  UpperCAmelCase__								=  xa + i * q
  UpperCAmelCase__								=  ya - i * p
  print(_lowerCAmelCase  ,							_lowerCAmelCase		)



def   lowerCAmelCase						(						_lowerCAmelCase							:				int  ,							_lowerCAmelCase							:				int		):




 """simple docstring"""







 if a < b:
  UpperCAmelCase__	,	UpperCAmelCase__								=  b, a

 while a % b != 0:
  UpperCAmelCase__	,	UpperCAmelCase__								=  b, a % b

 return b



def   lowerCAmelCase						(						_lowerCAmelCase							:				int  ,							_lowerCAmelCase							:				int		):




 """simple docstring"""







 assert a >= 0 and b >= 0

 if b == 0:
  UpperCAmelCase__	,	UpperCAmelCase__	,	UpperCAmelCase__								=  a, 1, 0
 else:
  ((UpperCAmelCase__)	,	(UpperCAmelCase__)	,	(UpperCAmelCase__))								=  extended_gcd(_lowerCAmelCase  ,							a % b		)
  UpperCAmelCase__								=  q
  UpperCAmelCase__								=  p - q * (a // b)

 assert a % d == 0 and b % d == 0
 assert d == a * x + b * y

 return (d, x, y)


if __name__ == "__main__":
  from doctest import testmod

  testmod(name="diophantine", verbose=True)
  testmod(name="diophantine_all_soln", verbose=True)
  testmod(name="extended_gcd", verbose=True)
  testmod(name="greatest_common_divisor", verbose=True)





