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

		UpperCAmelCase__   : List[Any]					=		True
except ImportError:
		UpperCAmelCase__   : Optional[Any]					=		False


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







def   A     (      UpperCamelCase_					:     List[Any]      )					->       Any:







			'''simple docstring'''



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







def   A     (      )					->       bool:







			'''simple docstring'''



			return _torch_distributed_available







def   A     (      )					->       Any:







			'''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     (      )					->       Any:







			'''simple docstring'''



			return importlib.metadata.version("oneccl_bind_pt"      )







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







			'''simple docstring'''



			return _is_package_available("transformer_engine"      )







@lru_cache
def   A     (      UpperCamelCase_					:     Dict=True      )					->       List[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
									lowerCAmelCase__								=							xm.xla_device()
									return True
						except RuntimeError:
									return False
			return _tpu_available







def   A     (      )					->       int:







			'''simple docstring'''



			return _is_package_available("deepspeed"      )







def   A     (      UpperCamelCase_					:     Any=False      )					->       List[str]:







			'''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     (      )					->       Any:







			'''simple docstring'''



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







def   A     (      )					->       Optional[int]:







			'''simple docstring'''



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







def   A     (      )					->       List[Any]:







			'''simple docstring'''



			return _is_package_available("bitsandbytes"      )







def   A     (      )					->       int:







			'''simple docstring'''



			if strtobool(os.environ.get("ACCELERATE_USE_MEGATRON_LM"						,	"False"      )      ) == 1:
						lowerCAmelCase__								=							importlib.util.find_spec("megatron"      ) is not None
						if package_exists:
									try:
												lowerCAmelCase__								=							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     (      )					->       List[str]:







			'''simple docstring'''



			return _is_package_available("safetensors"      )







def   A     (      )					->       Dict:







			'''simple docstring'''



			return _is_package_available("transformers"      )







def   A     (      )					->       int:







			'''simple docstring'''



			return _is_package_available("datasets"      )







def   A     (      )					->       str:







			'''simple docstring'''



			return _is_package_available("aim"      )







def   A     (      )					->       Dict:







			'''simple docstring'''



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







def   A     (      )					->       List[str]:







			'''simple docstring'''



			return _is_package_available("wandb"      )







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







			'''simple docstring'''



			return _is_package_available("comet_ml"      )







def   A     (      )					->       List[Any]:







			'''simple docstring'''



			return _is_package_available("boto3"      )







def   A     (      )					->       Tuple:







			'''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     (      )					->       Tuple:







			'''simple docstring'''



			return _is_package_available("sagemaker"      )







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







			'''simple docstring'''



			return _is_package_available("tqdm"      )







def   A     (      )					->       str:







			'''simple docstring'''



			return _is_package_available("mlflow"      )







def   A     (      )					->       Optional[int]:







			'''simple docstring'''



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







def   A     (      )					->       List[Any]:







			'''simple docstring'''



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

			lowerCAmelCase__								=							importlib.metadata.version("torch"      )
			if importlib.util.find_spec("intel_extension_for_pytorch"      ) is None:
						return False
			lowerCAmelCase__								=							"N/A"
			try:
						lowerCAmelCase__								=							importlib.metadata.version("intel_extension_for_pytorch"      )
			except importlib.metadata.PackageNotFoundError:
						return False
			lowerCAmelCase__								=							get_major_and_minor_from_version(_torch_version      )
			lowerCAmelCase__								=							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_					:     List[str]=False      )					->       int:







			'''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
									lowerCAmelCase__								=							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_					:     List[Any]=False      )					->       Union[str, Any]:







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







'''simple docstring'''

from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


UpperCAmelCase__   : Any					=		{
    "configuration_fsmt": ["FSMT_PRETRAINED_CONFIG_ARCHIVE_MAP", "FSMTConfig"],
    "tokenization_fsmt": ["FSMTTokenizer"],
}

try:
		if not is_torch_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		UpperCAmelCase__   : str					=		["FSMTForConditionalGeneration", "FSMTModel", "PretrainedFSMTModel"]


if TYPE_CHECKING:
		from .configuration_fsmt import FSMT_PRETRAINED_CONFIG_ARCHIVE_MAP, FSMTConfig
		from .tokenization_fsmt import FSMTTokenizer

		try:
				if not is_torch_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_fsmt import FSMTForConditionalGeneration, FSMTModel, PretrainedFSMTModel

else:
		import sys

		UpperCAmelCase__   : int					=		_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)





