

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

   _a					 =				True
except ImportError:
   _a					 =				False


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




def     _A    (    UpperCamelCase_	:			Tuple)      ->		Any:
   '''simple docstring'''


   __lowercase								=		importlib.util.find_spec(UpperCAmelCase_) is not None
   if package_exists:
      try:
         __lowercase								=		importlib.metadata.metadata(UpperCAmelCase_)
         return True
      except importlib.metadata.PackageNotFoundError:
         return False




def     _A    (    )      ->		List[str]:
   '''simple docstring'''


   return _torch_distributed_available




def     _A    (    )      ->		Optional[int]:
   '''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[Any]:
   '''simple docstring'''


   return importlib.metadata.version("oneccl_bind_pt")




def     _A    (    )      ->		List[Any]:
   '''simple docstring'''


   return _is_package_available("transformer_engine")




@lru_cache
def     _A    (    UpperCamelCase_	:			Optional[int]=True)      ->		Union[str, 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								=		xm.xla_device()
         return True
      except RuntimeError:
         return False
   return _tpu_available




def     _A    (    )      ->		Optional[int]:
   '''simple docstring'''


   return _is_package_available("deepspeed")




def     _A    (    UpperCamelCase_	:			str=False)      ->		List[Any]:
   '''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    (    )      ->		Optional[Any]:
   '''simple docstring'''


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




def     _A    (    )      ->		List[Any]:
   '''simple docstring'''


   __lowercase								=		_is_package_available("bitsandbytes")
   if package_exists:
      __lowercase								=		version.parse(importlib.metadata.version("bitsandbytes"))
      return compare_versions(UpperCAmelCase_,     ">=",     "0.37.2")
   return False




def     _A    (    )      ->		str:
   '''simple docstring'''


   return _is_package_available("bitsandbytes")




def     _A    (    )      ->		Optional[int]:
   '''simple docstring'''


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


   return _is_package_available("safetensors")




def     _A    (    )      ->		Tuple:
   '''simple docstring'''


   return _is_package_available("transformers")




def     _A    (    )      ->		Union[str, Any]:
   '''simple docstring'''


   return _is_package_available("datasets")




def     _A    (    )      ->		Any:
   '''simple docstring'''


   return _is_package_available("aim")




def     _A    (    )      ->		Optional[Any]:
   '''simple docstring'''


   return _is_package_available("tensorboard") or _is_package_available("tensorboardX")




def     _A    (    )      ->		str:
   '''simple docstring'''


   return _is_package_available("wandb")




def     _A    (    )      ->		Dict:
   '''simple docstring'''


   return _is_package_available("comet_ml")




def     _A    (    )      ->		List[Any]:
   '''simple docstring'''


   return _is_package_available("boto3")




def     _A    (    )      ->		Optional[Any]:
   '''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",     UpperCAmelCase_)
      return parse_flag_from_env("ACCELERATE_ENABLE_RICH",     UpperCAmelCase_)
   return False




def     _A    (    )      ->		List[Any]:
   '''simple docstring'''


   return _is_package_available("sagemaker")




def     _A    (    )      ->		Optional[Any]:
   '''simple docstring'''


   return _is_package_available("tqdm")




def     _A    (    )      ->		Any:
   '''simple docstring'''


   return _is_package_available("mlflow")




def     _A    (    )      ->		Union[str, Any]:
   '''simple docstring'''


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




def     _A    (    )      ->		Any:
   '''simple docstring'''


   def get_major_and_minor_from_version(UpperCamelCase_	:			Optional[Any]):
      return str(version.parse(UpperCAmelCase_).major) + "." + str(version.parse(UpperCAmelCase_).minor)

   __lowercase								=		importlib.metadata.version("torch")
   if importlib.util.find_spec("intel_extension_for_pytorch") is None:
      return False
   __lowercase								=		"N/A"
   try:
      __lowercase								=		importlib.metadata.version("intel_extension_for_pytorch")
   except importlib.metadata.PackageNotFoundError:
      return False
   __lowercase								=		get_major_and_minor_from_version(_torch_version)
   __lowercase								=		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    (    UpperCamelCase_	:			Dict=False)      ->		Any:
   '''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								=		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     _A    (    UpperCamelCase_	:			int=False)      ->		List[str]:
   '''simple docstring'''


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










from __future__ import annotations

import random







class 		__UpperCAmelCase:





     """simple docstring"""



     __UpperCAmelCase						:			Optional[int]							=     6

     def __init__(   self			:							int     )      ->      Optional[Any]:






         """simple docstring"""
         a__  			=							list(range(1    ,					Dice.NUM_SIDES + 1     )     )






     def 					__SCREAMING_SNAKE_CASE		(   self			:							Union[str, Any]     )      ->      List[str]:






         """simple docstring"""
         return random.choice(self.sides     )






def 							__lowerCAmelCase			(UpperCAmelCase_ ,     UpperCAmelCase_ = 2		):
    a__  			=							[Dice() for i in range(UpperCAmelCase_		)]
    a__  			=							[0] * (len(UpperCAmelCase_		) * Dice.NUM_SIDES + 1)
    for _ in range(UpperCAmelCase_		):
        count_of_sum[sum(dice.roll() for dice in dices		)] += 1
    a__  			=							[round((count * 100) / num_throws ,     2		) for count in count_of_sum]
    return probability[num_dice:]  # remove probability of sums that never appear


if __name__ == "__main__":
 import doctest

 doctest.testmod()






