


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

						__magic_name__   :   Any  							=True
except ImportError:
						__magic_name__   :   Optional[Any]  							=False


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




def      __snake_case       (       lowerCamelCase_ :				int						):
				# Check we're not importing a "pkg_name" directory somewhere but the actual library by trying to grab the version
				__magic_name__	  = importlib.util.find_spec(lowercase__						) is not None
				if package_exists:
								try:
												__magic_name__	  = importlib.metadata.metadata(lowercase__						)
												return True
								except importlib.metadata.PackageNotFoundError:
												return False




def      __snake_case       (       ):
				return _torch_distributed_available




def      __snake_case       (       ):
				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      __snake_case       (       ):
				return importlib.metadata.version("oneccl_bind_pt"						)




def      __snake_case       (       ):
				return _is_package_available("transformer_engine"						)




@lru_cache
def      __snake_case       (       lowerCamelCase_ :				Dict=True						):
				# Due to bugs on the amp series GPUs, we disable torch-xla on them
				if torch.cuda.is_available():
								return False
				if _tpu_available and check_device:
								try:
												# Will raise a RuntimeError if no XLA configuration is found
												__magic_name__	  = xm.xla_device()
												return True
								except RuntimeError:
												return False
				return _tpu_available




def      __snake_case       (       ):
				return _is_package_available("deepspeed"						)




def      __snake_case       (       lowerCamelCase_ :				List[str]=False						):
				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      __snake_case       (       ):
				__magic_name__	  = _is_package_available("bitsandbytes"						)
				if package_exists:
								__magic_name__	  = version.parse(importlib.metadata.version("bitsandbytes"						)						)
								return compare_versions(lowercase__	,  ">="	,  "0.39.0"						)
				return False




def      __snake_case       (       ):
				__magic_name__	  = _is_package_available("bitsandbytes"						)
				if package_exists:
								__magic_name__	  = version.parse(importlib.metadata.version("bitsandbytes"						)						)
								return compare_versions(lowercase__	,  ">="	,  "0.37.2"						)
				return False




def      __snake_case       (       ):
				return _is_package_available("bitsandbytes"						)




def      __snake_case       (       ):
				if strtobool(os.environ.get("ACCELERATE_USE_MEGATRON_LM"	,  "False"						)						) == 1:
								__magic_name__	  = importlib.util.find_spec("megatron"						) is not None
								if package_exists:
												try:
																__magic_name__	  = 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      __snake_case       (       ):
				return _is_package_available("safetensors"						)




def      __snake_case       (       ):
				return _is_package_available("transformers"						)




def      __snake_case       (       ):
				return _is_package_available("datasets"						)




def      __snake_case       (       ):
				return _is_package_available("aim"						)




def      __snake_case       (       ):
				return _is_package_available("tensorboard"						) or _is_package_available("tensorboardX"						)




def      __snake_case       (       ):
				return _is_package_available("wandb"						)




def      __snake_case       (       ):
				return _is_package_available("comet_ml"						)




def      __snake_case       (       ):
				return _is_package_available("boto3"						)




def      __snake_case       (       ):
				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      __snake_case       (       ):
				return _is_package_available("sagemaker"						)




def      __snake_case       (       ):
				return _is_package_available("tqdm"						)




def      __snake_case       (       ):
				return _is_package_available("mlflow"						)




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




def      __snake_case       (       ):
				def get_major_and_minor_from_version(lowerCamelCase_ :				Any						):
								return str(version.parse(lowercase__						).major						) + "." + str(version.parse(lowercase__						).minor						)

				__magic_name__	  = importlib.metadata.version("torch"						)
				if importlib.util.find_spec("intel_extension_for_pytorch"						) is None:
								return False
				__magic_name__	  = "N/A"
				try:
								__magic_name__	  = importlib.metadata.version("intel_extension_for_pytorch"						)
				except importlib.metadata.PackageNotFoundError:
								return False
				__magic_name__	  = get_major_and_minor_from_version(_torch_version						)
				__magic_name__	  = 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      __snake_case       (       lowerCamelCase_ :				List[Any]=False						):
				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
												__magic_name__	  = 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      __snake_case       (       lowerCamelCase_ :				Optional[Any]=False						):
				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
												__magic_name__	  = torch.xpu.device_count()
												return torch.xpu.is_available()
								except RuntimeError:
												return False
				return hasattr(lowercase__	,  "xpu"						) and torch.xpu.is_available()







'''simple docstring'''
from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available


__magic_name__   :   List[Any]  							={'configuration_yoso': ['YOSO_PRETRAINED_CONFIG_ARCHIVE_MAP', 'YosoConfig']}

try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						__magic_name__   :   Union[str, Any]  							=[
						    'YOSO_PRETRAINED_MODEL_ARCHIVE_LIST',
						    'YosoForMaskedLM',
						    'YosoForMultipleChoice',
						    'YosoForQuestionAnswering',
						    'YosoForSequenceClassification',
						    'YosoForTokenClassification',
						    'YosoLayer',
						    'YosoModel',
						    'YosoPreTrainedModel',
						]


if TYPE_CHECKING:
						from .configuration_yoso import YOSO_PRETRAINED_CONFIG_ARCHIVE_MAP, YosoConfig

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_yoso import (
												    YOSO_PRETRAINED_MODEL_ARCHIVE_LIST,
												    YosoForMaskedLM,
												    YosoForMultipleChoice,
												    YosoForQuestionAnswering,
												    YosoForSequenceClassification,
												    YosoForTokenClassification,
												    YosoLayer,
												    YosoModel,
												    YosoPreTrainedModel,
												)


else:
						import sys

						__magic_name__   :   Optional[int]  							=_LazyModule(__name__, globals()['__file__'], _import_structure)



