





'''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__							:							List[Any]			=True
except ImportError:
    a__							:							Tuple			=False


# Cache this result has it's a C FFI call which can be pretty time-consuming
a__							:							List[str]			=torch.distributed.is_available()
def     lowercase__       (       __lowercase						:  Tuple					)			->				List[Any]:



       """simple docstring"""






       __UpperCamelCase	=  importlib.util.find_spec(__lowercase					) is not None
       if package_exists:
              try:
                     __UpperCamelCase	=  importlib.metadata.metadata(__lowercase					)
                     return True
              except importlib.metadata.PackageNotFoundError:
                     return False
def     lowercase__       (       )			->				bool:



       """simple docstring"""






       return _torch_distributed_available
def     lowercase__       (       )			->				str:



       """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     lowercase__       (       )			->				Optional[int]:



       """simple docstring"""






       return importlib.metadata.version('oneccl_bind_pt'					)
def     lowercase__       (       )			->				Union[str, Any]:



       """simple docstring"""






       return _is_package_available('transformer_engine'					)
@lru_cache
def     lowercase__       (       __lowercase						:  Union[str, Any]=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
                     __UpperCamelCase	=  xm.xla_device()
                     return True
              except RuntimeError:
                     return False
       return _tpu_available
def     lowercase__       (       )			->				Union[str, Any]:



       """simple docstring"""






       return _is_package_available('deepspeed'					)
def     lowercase__       (       __lowercase						:  Optional[int]=False					)			->				Dict:



       """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     lowercase__       (       )			->				Union[str, Any]:



       """simple docstring"""






       __UpperCamelCase	=  _is_package_available('bitsandbytes'					)
       if package_exists:
              __UpperCamelCase	=  version.parse(importlib.metadata.version('bitsandbytes'					)					)
              return compare_versions(__lowercase    ,  '>='    ,  '0.39.0'					)
       return False
def     lowercase__       (       )			->				List[Any]:



       """simple docstring"""






       __UpperCamelCase	=  _is_package_available('bitsandbytes'					)
       if package_exists:
              __UpperCamelCase	=  version.parse(importlib.metadata.version('bitsandbytes'					)					)
              return compare_versions(__lowercase    ,  '>='    ,  '0.37.2'					)
       return False
def     lowercase__       (       )			->				Any:



       """simple docstring"""






       return _is_package_available('bitsandbytes'					)
def     lowercase__       (       )			->				Optional[int]:



       """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(__lowercase    ,  '>='    ,  '2.2.0'					)
                     except Exception as e:
                            warnings.warn(F'''Parse Megatron version failed. Exception:{e}'''					)
                            return False
def     lowercase__       (       )			->				Any:



       """simple docstring"""






       return _is_package_available('safetensors'					)
def     lowercase__       (       )			->				int:



       """simple docstring"""






       return _is_package_available('transformers'					)
def     lowercase__       (       )			->				Any:



       """simple docstring"""






       return _is_package_available('datasets'					)
def     lowercase__       (       )			->				str:



       """simple docstring"""






       return _is_package_available('aim'					)
def     lowercase__       (       )			->				Optional[Any]:



       """simple docstring"""






       return _is_package_available('tensorboard'					) or _is_package_available('tensorboardX'					)
def     lowercase__       (       )			->				List[str]:



       """simple docstring"""






       return _is_package_available('wandb'					)
def     lowercase__       (       )			->				Optional[Any]:



       """simple docstring"""






       return _is_package_available('comet_ml'					)
def     lowercase__       (       )			->				Optional[int]:



       """simple docstring"""






       return _is_package_available('boto3'					)
def     lowercase__       (       )			->				Optional[int]:



       """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'    ,  __lowercase					)
              return parse_flag_from_env('ACCELERATE_ENABLE_RICH'    ,  __lowercase					)
       return False
def     lowercase__       (       )			->				Any:



       """simple docstring"""






       return _is_package_available('sagemaker'					)
def     lowercase__       (       )			->				Dict:



       """simple docstring"""






       return _is_package_available('tqdm'					)
def     lowercase__       (       )			->				str:



       """simple docstring"""






       return _is_package_available('mlflow'					)
def     lowercase__       (       )			->				Any:



       """simple docstring"""






       return is_torch_version('>='    ,  '1.12'					) and torch.backends.mps.is_available() and torch.backends.mps.is_built()
def     lowercase__       (       )			->				str:



       """simple docstring"""






       def get_major_and_minor_from_version(__lowercase						:  Union[str, Any]					):
              return str(version.parse(__lowercase					).major					) + "." + str(version.parse(__lowercase					).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     lowercase__       (       __lowercase						:  Optional[int]=False					)			->				Union[str, 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
                     __UpperCamelCase	=  torch.npu.device_count()
                     return torch.npu.is_available()
              except RuntimeError:
                     return False
       return hasattr(__lowercase    ,  'npu'					) and torch.npu.is_available()


@lru_cache
def     lowercase__       (       __lowercase						:  List[Any]=False					)			->				List[str]:



       """simple docstring"""






       if not parse_flag_from_env('ACCELERATE_USE_XPU'    ,  default=__lowercase					):
              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(__lowercase    ,  'xpu'					) and torch.xpu.is_available()







'''simple docstring'''
def     lowercase__       (       __lowercase						:  list    ,  __lowercase						:  int    ,  __lowercase						:  int    ,  __lowercase						:  int					)			->				int:



       """simple docstring"""






       __UpperCamelCase	=  int((lower_bound + upper_bound) // 2					)
       if array[r] == value:
              return r
       if lower_bound >= upper_bound:
              return -1
       if array[r] < value:
              return binary_search(__lowercase    ,  r + 1    ,  __lowercase    ,  __lowercase					)
       else:
              return binary_search(__lowercase    ,  __lowercase    ,  r - 1    ,  __lowercase					)
def     lowercase__       (       __lowercase						:  int    ,  __lowercase						:  list					)			->				list:



       """simple docstring"""






       __UpperCamelCase	=  0
       if matrix[index][0] == value:
              return [index, 0]
       while index < len(__lowercase					) and matrix[index][0] < value:
              __UpperCamelCase	=  binary_search(matrix[index]    ,  0    ,  len(matrix[index]					) - 1    ,  __lowercase					)
              if r != -1:
                     return [index, r]
              index += 1
       return [-1, -1]


if __name__ == "__main__":
    import doctest

    doctest.testmod()
