


'''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    				=							True
except ImportError:
		__UpperCAmelCase    				=							False


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


def 					_snake_case   (     A       )						->    Union[str, Any]:
							# Check we're not importing a "pkg_name" directory somewhere but the actual library by trying to grab the version
							lowerCAmelCase__          =	importlib.util.find_spec(A       ) is not None
							if package_exists:
														try:
																					lowerCAmelCase__          =	importlib.metadata.metadata(A       )
																					return True
														except importlib.metadata.PackageNotFoundError:
																					return False


def 					_snake_case   (     )						->    bool:
							return _torch_distributed_available


def 					_snake_case   (     )						->    Dict:
							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   (     )						->    List[str]:
							return importlib.metadata.version('''oneccl_bind_pt'''       )


def 					_snake_case   (     )						->    Dict:
							return _is_package_available('''transformer_engine'''       )


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


def 					_snake_case   (     )						->    List[Any]:
							return _is_package_available('''deepspeed'''       )


def 					_snake_case   (     A=False       )						->    Optional[Any]:
							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   (     )						->    List[str]:
							lowerCAmelCase__          =	_is_package_available('''bitsandbytes'''       )
							if package_exists:
														lowerCAmelCase__          =	version.parse(importlib.metadata.version('''bitsandbytes'''       )       )
														return compare_versions(A ,    '''>=''' ,    '''0.39.0'''       )
							return False


def 					_snake_case   (     )						->    str:
							lowerCAmelCase__          =	_is_package_available('''bitsandbytes'''       )
							if package_exists:
														lowerCAmelCase__          =	version.parse(importlib.metadata.version('''bitsandbytes'''       )       )
														return compare_versions(A ,    '''>=''' ,    '''0.37.2'''       )
							return False


def 					_snake_case   (     )						->    Tuple:
							return _is_package_available('''bitsandbytes'''       )


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


def 					_snake_case   (     )						->    Tuple:
							return _is_package_available('''safetensors'''       )


def 					_snake_case   (     )						->    Optional[int]:
							return _is_package_available('''transformers'''       )


def 					_snake_case   (     )						->    List[Any]:
							return _is_package_available('''datasets'''       )


def 					_snake_case   (     )						->    str:
							return _is_package_available('''aim'''       )


def 					_snake_case   (     )						->    Union[str, Any]:
							return _is_package_available('''tensorboard'''       ) or _is_package_available('''tensorboardX'''       )


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


def 					_snake_case   (     )						->    List[str]:
							return _is_package_available('''comet_ml'''       )


def 					_snake_case   (     )						->    str:
							return _is_package_available('''boto3'''       )


def 					_snake_case   (     )						->    Tuple:
							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''' ,    A       )
														return parse_flag_from_env('''ACCELERATE_ENABLE_RICH''' ,    A       )
							return False


def 					_snake_case   (     )						->    str:
							return _is_package_available('''sagemaker'''       )


def 					_snake_case   (     )						->    List[Any]:
							return _is_package_available('''tqdm'''       )


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


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


def 					_snake_case   (     )						->    Optional[int]:
							def get_major_and_minor_from_version(A       ):
														return str(version.parse(A       ).major       ) + "." + str(version.parse(A       ).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 					_snake_case   (     A=False       )						->    int:
							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(A ,    '''npu'''       ) and torch.npu.is_available()






@lru_cache
def 					_snake_case   (     A=False       )						->    Any:
							if not parse_flag_from_env('''ACCELERATE_USE_XPU''' ,    default=A       ):
														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(A ,    '''xpu'''       ) and torch.xpu.is_available()



'''simple docstring'''






from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_sentencepiece_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


__UpperCAmelCase    				=							{
    '''configuration_switch_transformers''': [
        '''SWITCH_TRANSFORMERS_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''SwitchTransformersConfig''',
        '''SwitchTransformersOnnxConfig''',
    ]
}

try:
		if not is_torch_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		__UpperCAmelCase    				=							[
		    '''SWITCH_TRANSFORMERS_PRETRAINED_MODEL_ARCHIVE_LIST''',
		    '''SwitchTransformersEncoderModel''',
		    '''SwitchTransformersForConditionalGeneration''',
		    '''SwitchTransformersModel''',
		    '''SwitchTransformersPreTrainedModel''',
		    '''SwitchTransformersTop1Router''',
		    '''SwitchTransformersSparseMLP''',
		]


if TYPE_CHECKING:
		from .configuration_switch_transformers import (
		    SWITCH_TRANSFORMERS_PRETRAINED_CONFIG_ARCHIVE_MAP,
		    SwitchTransformersConfig,
		    SwitchTransformersOnnxConfig,
		)

		try:
				if not is_torch_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_switch_transformers import (
				    SWITCH_TRANSFORMERS_PRETRAINED_MODEL_ARCHIVE_LIST,
				    SwitchTransformersEncoderModel,
				    SwitchTransformersForConditionalGeneration,
				    SwitchTransformersModel,
				    SwitchTransformersPreTrainedModel,
				    SwitchTransformersSparseMLP,
				    SwitchTransformersTopaRouter,
				)


else:
		import sys

		__UpperCAmelCase    				=							_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)