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

			_SCREAMING_SNAKE_CASE:    List[Any]     						=							True
except ImportError:
			_SCREAMING_SNAKE_CASE:    Union[str, Any]     						=							False


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






def  UpperCAmelCase__(    lowerCamelCase_	):



			"""simple docstring"""





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






def  UpperCAmelCase__(    ):



			"""simple docstring"""





			return _torch_distributed_available






def  UpperCAmelCase__(    ):



			"""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  UpperCAmelCase__(    ):



			"""simple docstring"""





			return importlib.metadata.version("oneccl_bind_pt"	)






def  UpperCAmelCase__(    ):



			"""simple docstring"""





			return _is_package_available("transformer_engine"	)






@lru_cache
def  UpperCAmelCase__(    lowerCamelCase_=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
									_snake_case														=   xm.xla_device()
									return True
						except RuntimeError:
									return False
			return _tpu_available






def  UpperCAmelCase__(    ):



			"""simple docstring"""





			return _is_package_available("deepspeed"	)






def  UpperCAmelCase__(    lowerCamelCase_=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  UpperCAmelCase__(    ):



			"""simple docstring"""





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






def  UpperCAmelCase__(    ):



			"""simple docstring"""





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






def  UpperCAmelCase__(    ):



			"""simple docstring"""





			return _is_package_available("bitsandbytes"	)






def  UpperCAmelCase__(    ):



			"""simple docstring"""





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






def  UpperCAmelCase__(    ):



			"""simple docstring"""





			return _is_package_available("safetensors"	)






def  UpperCAmelCase__(    ):



			"""simple docstring"""





			return _is_package_available("transformers"	)






def  UpperCAmelCase__(    ):



			"""simple docstring"""





			return _is_package_available("datasets"	)






def  UpperCAmelCase__(    ):



			"""simple docstring"""





			return _is_package_available("aim"	)






def  UpperCAmelCase__(    ):



			"""simple docstring"""





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






def  UpperCAmelCase__(    ):



			"""simple docstring"""





			return _is_package_available("wandb"	)






def  UpperCAmelCase__(    ):



			"""simple docstring"""





			return _is_package_available("comet_ml"	)






def  UpperCAmelCase__(    ):



			"""simple docstring"""





			return _is_package_available("boto3"	)






def  UpperCAmelCase__(    ):



			"""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"				,						__SCREAMING_SNAKE_CASE	)
						return parse_flag_from_env("ACCELERATE_ENABLE_RICH"				,						__SCREAMING_SNAKE_CASE	)
			return False






def  UpperCAmelCase__(    ):



			"""simple docstring"""





			return _is_package_available("sagemaker"	)






def  UpperCAmelCase__(    ):



			"""simple docstring"""





			return _is_package_available("tqdm"	)






def  UpperCAmelCase__(    ):



			"""simple docstring"""





			return _is_package_available("mlflow"	)






def  UpperCAmelCase__(    ):



			"""simple docstring"""





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






def  UpperCAmelCase__(    ):



			"""simple docstring"""





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

			_snake_case														=   importlib.metadata.version("torch"	)
			if importlib.util.find_spec("intel_extension_for_pytorch"	) is None:
						return False
			_snake_case														=   """N/A"""
			try:
						_snake_case														=   importlib.metadata.version("intel_extension_for_pytorch"	)
			except importlib.metadata.PackageNotFoundError:
						return False
			_snake_case														=   get_major_and_minor_from_version(_torch_version	)
			_snake_case														=   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  UpperCAmelCase__(    lowerCamelCase_=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
									_snake_case														=   torch.npu.device_count()
									return torch.npu.is_available()
						except RuntimeError:
									return False
			return hasattr(__SCREAMING_SNAKE_CASE				,						"npu"	) and torch.npu.is_available()







@lru_cache
def  UpperCAmelCase__(    lowerCamelCase_=False	):



			"""simple docstring"""





			if not parse_flag_from_env("ACCELERATE_USE_XPU"				,						default=__SCREAMING_SNAKE_CASE	):
						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
									_snake_case														=   torch.xpu.device_count()
									return torch.xpu.is_available()
						except RuntimeError:
									return False
			return hasattr(__SCREAMING_SNAKE_CASE				,						"xpu"	) and torch.xpu.is_available()



'''simple docstring'''
import heapq







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





  """simple docstring"""

  __A		:  Dict       				=		[(0, start)]  # cost from start node,end node
  __A		:  Union[str, Any]       				=		set()
  while heap:
    ((__A)				,       (__A))		:  int       				=		heapq.heappop(__SCREAMING_SNAKE_CASE			)
    if u in visited:
      continue
    visited.add(__SCREAMING_SNAKE_CASE			)
    if u == end:
      return cost
    for v, c in graph[u]:
      if v in visited:
        continue
      __A		:  List[str]       				=		cost + c
      heapq.heappush(__SCREAMING_SNAKE_CASE      ,  (next_item, v)			)
  return -1


A__ :		Any					={
    'A': [['B', 2], ['C', 5]],
    'B': [['A', 2], ['D', 3], ['E', 1], ['F', 1]],
    'C': [['A', 5], ['F', 3]],
    'D': [['B', 3]],
    'E': [['B', 4], ['F', 3]],
    'F': [['C', 3], ['E', 3]],
}
A__ :		List[str]					={
    'B': [['C', 1]],
    'C': [['D', 1]],
    'D': [['F', 1]],
    'E': [['B', 1], ['F', 3]],
    'F': [],
}
A__ :		List[Any]					={
    'B': [['C', 1]],
    'C': [['D', 1]],
    'D': [['F', 1]],
    'E': [['B', 1], ['G', 2]],
    'F': [],
    'G': [['F', 1]],
}

A__ :		List[str]					=dijkstra(G, 'E', 'C')
print(short_distance)  # E -- 3 --> F -- 3 --> C == 6

A__ :		Optional[Any]					=dijkstra(Ga, 'E', 'F')
print(short_distance)  # E -- 3 --> F == 3

A__ :		Any					=dijkstra(Ga, 'E', 'F')
print(short_distance)  # E -- 2 --> G -- 1 --> F == 3

if __name__ == "__main__":
     import doctest

     doctest.testmod()



