


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				:						Optional[int]			   = False


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




def 			UpperCamelCase			(					_a						)    ->							str:
     '''simple docstring'''





     lowercase_				:Optional[int]       			=				importlib.util.find_spec(UpperCamelCase__						) is not None
     if package_exists:
          try:
               lowercase_				:Optional[int]       			=				importlib.metadata.metadata(UpperCamelCase__						)
               return True
          except importlib.metadata.PackageNotFoundError:
               return False




def 			UpperCamelCase			(					)    ->							Tuple:
     '''simple docstring'''





     return _torch_distributed_available




def 			UpperCamelCase			(					)    ->							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 			UpperCamelCase			(					)    ->							str:
     '''simple docstring'''





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




def 			UpperCamelCase			(					)    ->							Tuple:
     '''simple docstring'''





     return _is_package_available('''transformer_engine'''						)




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




def 			UpperCamelCase			(					)    ->							Optional[Any]:
     '''simple docstring'''





     return _is_package_available('''deepspeed'''						)




def 			UpperCamelCase			(					_a=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 			UpperCamelCase			(					)    ->							Union[str, Any]:
     '''simple docstring'''





     lowercase_				:str       			=				_is_package_available('''bitsandbytes'''						)
     if package_exists:
          lowercase_				:Union[str, Any]       			=				version.parse(importlib.metadata.version('''bitsandbytes'''						)						)
          return compare_versions(UpperCamelCase__				,						'''>='''				,						'''0.39.0'''						)
     return False




def 			UpperCamelCase			(					)    ->							List[Any]:
     '''simple docstring'''





     lowercase_				:Optional[Any]       			=				_is_package_available('''bitsandbytes'''						)
     if package_exists:
          lowercase_				:List[Any]       			=				version.parse(importlib.metadata.version('''bitsandbytes'''						)						)
          return compare_versions(UpperCamelCase__				,						'''>='''				,						'''0.37.2'''						)
     return False




def 			UpperCamelCase			(					)    ->							Optional[int]:
     '''simple docstring'''





     return _is_package_available('''bitsandbytes'''						)




def 			UpperCamelCase			(					)    ->							Union[str, Any]:
     '''simple docstring'''





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





     return _is_package_available('''safetensors'''						)




def 			UpperCamelCase			(					)    ->							Tuple:
     '''simple docstring'''





     return _is_package_available('''transformers'''						)




def 			UpperCamelCase			(					)    ->							Dict:
     '''simple docstring'''





     return _is_package_available('''datasets'''						)




def 			UpperCamelCase			(					)    ->							str:
     '''simple docstring'''





     return _is_package_available('''aim'''						)




def 			UpperCamelCase			(					)    ->							Optional[int]:
     '''simple docstring'''





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




def 			UpperCamelCase			(					)    ->							Any:
     '''simple docstring'''





     return _is_package_available('''wandb'''						)




def 			UpperCamelCase			(					)    ->							Tuple:
     '''simple docstring'''





     return _is_package_available('''comet_ml'''						)




def 			UpperCamelCase			(					)    ->							str:
     '''simple docstring'''





     return _is_package_available('''boto3'''						)




def 			UpperCamelCase			(					)    ->							str:
     '''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 			UpperCamelCase			(					)    ->							Union[str, Any]:
     '''simple docstring'''





     return _is_package_available('''sagemaker'''						)




def 			UpperCamelCase			(					)    ->							Optional[int]:
     '''simple docstring'''





     return _is_package_available('''tqdm'''						)




def 			UpperCamelCase			(					)    ->							List[Any]:
     '''simple docstring'''





     return _is_package_available('''mlflow'''						)




def 			UpperCamelCase			(					)    ->							int:
     '''simple docstring'''





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




def 			UpperCamelCase			(					)    ->							Optional[Any]:
     '''simple docstring'''





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

     lowercase_				:Optional[int]       			=				importlib.metadata.version('''torch'''						)
     if importlib.util.find_spec('''intel_extension_for_pytorch'''						) is None:
          return False
     lowercase_				:Optional[int]       			=				'''N/A'''
     try:
          lowercase_				:int       			=				importlib.metadata.version('''intel_extension_for_pytorch'''						)
     except importlib.metadata.PackageNotFoundError:
          return False
     lowercase_				:Optional[int]       			=				get_major_and_minor_from_version(_torch_version						)
     lowercase_				:List[Any]       			=				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			(					_a=False						)    ->							Any:
     '''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
               lowercase_				:List[str]       			=				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 			UpperCamelCase			(					_a=False						)    ->							Optional[int]:
     '''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
               lowercase_				:Optional[int]       			=				torch.xpu.device_count()
               return torch.xpu.is_available()
          except RuntimeError:
               return False
     return hasattr(UpperCamelCase__				,						'''xpu'''						) and torch.xpu.is_available()








from typing import TYPE_CHECKING

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


_lowerCamelCase       =	{
    'configuration_gptsan_japanese': ['GPTSAN_JAPANESE_PRETRAINED_CONFIG_ARCHIVE_MAP', 'GPTSanJapaneseConfig'],
    'tokenization_gptsan_japanese': ['GPTSanJapaneseTokenizer'],
}

try:
	if not is_torch_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	_lowerCamelCase       =	[
	    'GPTSAN_JAPANESE_PRETRAINED_MODEL_ARCHIVE_LIST',
	    'GPTSanJapaneseForConditionalGeneration',
	    'GPTSanJapaneseModel',
	    'GPTSanJapanesePreTrainedModel',
	]
	_lowerCamelCase       =	[
	    'GPTSanJapaneseTokenizer',
	]


if TYPE_CHECKING:
	from .configuration_gptsan_japanese import GPTSAN_JAPANESE_PRETRAINED_CONFIG_ARCHIVE_MAP, GPTSanJapaneseConfig
	from .tokenization_gptsan_japanese import GPTSanJapaneseTokenizer

	try:
		if not is_torch_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_gptsan_japanese import (
		    GPTSAN_JAPANESE_PRETRAINED_MODEL_ARCHIVE_LIST,
		    GPTSanJapaneseForConditionalGeneration,
		    GPTSanJapaneseModel,
		    GPTSanJapanesePreTrainedModel,
		)
		from .tokenization_gptsan_japanese import GPTSanJapaneseTokenizer


else:
	import sys

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