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

					__lowercase							:				List[str]					=       True
except ImportError:
					__lowercase							:				List[Any]					=       False


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




def lowercase_		(				_lowercase			):
					'''simple docstring'''

					lowerCamelCase_   : List[Any]       =						importlib.util.find_spec(_lowercase			) is not None
					if package_exists:
										try:
															lowerCamelCase_   : int       =						importlib.metadata.metadata(_lowercase			)
															return True
										except importlib.metadata.PackageNotFoundError:
															return False




def lowercase_		(				):
					'''simple docstring'''

					return _torch_distributed_available




def lowercase_		(				):
					'''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_		(				):
					'''simple docstring'''

					return importlib.metadata.version('''oneccl_bind_pt'''			)




def lowercase_		(				):
					'''simple docstring'''

					return _is_package_available('''transformer_engine'''			)




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




def lowercase_		(				):
					'''simple docstring'''

					return _is_package_available('''deepspeed'''			)




def lowercase_		(				_lowercase=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 lowercase_		(				):
					'''simple docstring'''

					lowerCamelCase_   : List[Any]       =						_is_package_available('''bitsandbytes'''			)
					if package_exists:
										lowerCamelCase_   : List[Any]       =						version.parse(importlib.metadata.version('''bitsandbytes'''			)			)
										return compare_versions(_lowercase     ,    '''>='''     ,    '''0.39.0'''			)
					return False




def lowercase_		(				):
					'''simple docstring'''

					lowerCamelCase_   : Optional[int]       =						_is_package_available('''bitsandbytes'''			)
					if package_exists:
										lowerCamelCase_   : Tuple       =						version.parse(importlib.metadata.version('''bitsandbytes'''			)			)
										return compare_versions(_lowercase     ,    '''>='''     ,    '''0.37.2'''			)
					return False




def lowercase_		(				):
					'''simple docstring'''

					return _is_package_available('''bitsandbytes'''			)




def lowercase_		(				):
					'''simple docstring'''

					if strtobool(os.environ.get('''ACCELERATE_USE_MEGATRON_LM'''     ,    '''False'''			)			) == 1:
										lowerCamelCase_   : int       =						importlib.util.find_spec('''megatron'''			) is not None
										if package_exists:
															try:
																				lowerCamelCase_   : List[Any]       =						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_		(				):
					'''simple docstring'''

					return _is_package_available('''safetensors'''			)




def lowercase_		(				):
					'''simple docstring'''

					return _is_package_available('''transformers'''			)




def lowercase_		(				):
					'''simple docstring'''

					return _is_package_available('''datasets'''			)




def lowercase_		(				):
					'''simple docstring'''

					return _is_package_available('''aim'''			)




def lowercase_		(				):
					'''simple docstring'''

					return _is_package_available('''tensorboard'''			) or _is_package_available('''tensorboardX'''			)




def lowercase_		(				):
					'''simple docstring'''

					return _is_package_available('''wandb'''			)




def lowercase_		(				):
					'''simple docstring'''

					return _is_package_available('''comet_ml'''			)




def lowercase_		(				):
					'''simple docstring'''

					return _is_package_available('''boto3'''			)




def lowercase_		(				):
					'''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_		(				):
					'''simple docstring'''

					return _is_package_available('''sagemaker'''			)




def lowercase_		(				):
					'''simple docstring'''

					return _is_package_available('''tqdm'''			)




def lowercase_		(				):
					'''simple docstring'''

					return _is_package_available('''mlflow'''			)




def lowercase_		(				):
					'''simple docstring'''

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




def lowercase_		(				):
					'''simple docstring'''

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

					lowerCamelCase_   : Dict       =						importlib.metadata.version('''torch'''			)
					if importlib.util.find_spec('''intel_extension_for_pytorch'''			) is None:
										return False
					lowerCamelCase_   : List[str]       =						'''N/A'''
					try:
										lowerCamelCase_   : int       =						importlib.metadata.version('''intel_extension_for_pytorch'''			)
					except importlib.metadata.PackageNotFoundError:
										return False
					lowerCamelCase_   : int       =						get_major_and_minor_from_version(_torch_version			)
					lowerCamelCase_   : str       =						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=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
															lowerCamelCase_   : str       =						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=False			):
					'''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
															lowerCamelCase_   : Optional[int]       =						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_sentencepiece_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


__lowercase							:				Any					=       {
    '''configuration_camembert''': ['''CAMEMBERT_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''CamembertConfig''', '''CamembertOnnxConfig'''],
}

try:
					if not is_sentencepiece_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					__lowercase							:				Any					=       ['''CamembertTokenizer''']

try:
					if not is_tokenizers_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					__lowercase							:				str					=       ['''CamembertTokenizerFast''']

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					__lowercase							:				List[Any]					=       [
					    '''CAMEMBERT_PRETRAINED_MODEL_ARCHIVE_LIST''',
					    '''CamembertForCausalLM''',
					    '''CamembertForMaskedLM''',
					    '''CamembertForMultipleChoice''',
					    '''CamembertForQuestionAnswering''',
					    '''CamembertForSequenceClassification''',
					    '''CamembertForTokenClassification''',
					    '''CamembertModel''',
					    '''CamembertPreTrainedModel''',
					]

try:
					if not is_tf_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					__lowercase							:				Any					=       [
					    '''TF_CAMEMBERT_PRETRAINED_MODEL_ARCHIVE_LIST''',
					    '''TFCamembertForCausalLM''',
					    '''TFCamembertForMaskedLM''',
					    '''TFCamembertForMultipleChoice''',
					    '''TFCamembertForQuestionAnswering''',
					    '''TFCamembertForSequenceClassification''',
					    '''TFCamembertForTokenClassification''',
					    '''TFCamembertModel''',
					    '''TFCamembertPreTrainedModel''',
					]


if TYPE_CHECKING:
					from .configuration_camembert import CAMEMBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, CamembertConfig, CamembertOnnxConfig

					try:
										if not is_sentencepiece_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .tokenization_camembert import CamembertTokenizer

					try:
										if not is_tokenizers_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .tokenization_camembert_fast import CamembertTokenizerFast

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_camembert import (
										    CAMEMBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
										    CamembertForCausalLM,
										    CamembertForMaskedLM,
										    CamembertForMultipleChoice,
										    CamembertForQuestionAnswering,
										    CamembertForSequenceClassification,
										    CamembertForTokenClassification,
										    CamembertModel,
										    CamembertPreTrainedModel,
										)

					try:
										if not is_tf_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_tf_camembert import (
										    TF_CAMEMBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
										    TFCamembertForCausalLM,
										    TFCamembertForMaskedLM,
										    TFCamembertForMultipleChoice,
										    TFCamembertForQuestionAnswering,
										    TFCamembertForSequenceClassification,
										    TFCamembertForTokenClassification,
										    TFCamembertModel,
										    TFCamembertPreTrainedModel,
										)

else:
					import sys

					__lowercase							:				Union[str, Any]					=       _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)


