

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

     _A						=     True
except ImportError:
     _A						=     False


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




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




def 				a__	(	)  ->   bool:
      return _torch_distributed_available




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




def 				a__	(	)  ->   Any:
      return _is_package_available("""transformer_engine"""						)




@lru_cache
def 				a__	(	lowerCAmelCase=True						)  ->   Any:
      # 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
                  UpperCAmelCase__ :       Optional[int]						=						xm.xla_device()
                  return True
            except RuntimeError:
                  return False
      return _tpu_available




def 				a__	(	)  ->   List[Any]:
      return _is_package_available("""deepspeed"""						)




def 				a__	(	lowerCAmelCase=False						)  ->   List[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 				a__	(	)  ->   str:
      UpperCAmelCase__ :       Optional[Any]						=						_is_package_available("""bitsandbytes"""						)
      if package_exists:
            UpperCAmelCase__ :       Optional[int]						=						version.parse(importlib.metadata.version("""bitsandbytes"""						)						)
            return compare_versions(lowerCAmelCase ,  """>=""" ,  """0.39.0"""						)
      return False




def 				a__	(	)  ->   Optional[Any]:
      UpperCAmelCase__ :       Optional[Any]						=						_is_package_available("""bitsandbytes"""						)
      if package_exists:
            UpperCAmelCase__ :       List[Any]						=						version.parse(importlib.metadata.version("""bitsandbytes"""						)						)
            return compare_versions(lowerCAmelCase ,  """>=""" ,  """0.37.2"""						)
      return False




def 				a__	(	)  ->   str:
      return _is_package_available("""bitsandbytes"""						)




def 				a__	(	)  ->   List[str]:
      if strtobool(os.environ.get("""ACCELERATE_USE_MEGATRON_LM""" ,  """False"""						)						) == 1:
            UpperCAmelCase__ :       Tuple						=						importlib.util.find_spec("""megatron"""						) is not None
            if package_exists:
                  try:
                        UpperCAmelCase__ :       int						=						parse(importlib.metadata.version("""megatron-lm"""						)						)
                        return compare_versions(lowerCAmelCase ,  """>=""" ,  """2.2.0"""						)
                  except Exception as e:
                        warnings.warn(F"""Parse Megatron version failed. Exception:{e}"""						)
                        return False




def 				a__	(	)  ->   Tuple:
      return _is_package_available("""safetensors"""						)




def 				a__	(	)  ->   List[str]:
      return _is_package_available("""transformers"""						)




def 				a__	(	)  ->   Optional[Any]:
      return _is_package_available("""datasets"""						)




def 				a__	(	)  ->   Optional[Any]:
      return _is_package_available("""aim"""						)




def 				a__	(	)  ->   Dict:
      return _is_package_available("""tensorboard"""						) or _is_package_available("""tensorboardX"""						)




def 				a__	(	)  ->   int:
      return _is_package_available("""wandb"""						)




def 				a__	(	)  ->   Dict:
      return _is_package_available("""comet_ml"""						)




def 				a__	(	)  ->   str:
      return _is_package_available("""boto3"""						)




def 				a__	(	)  ->   List[str]:
      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""" ,  lowerCAmelCase						)
            return parse_flag_from_env("""ACCELERATE_ENABLE_RICH""" ,  lowerCAmelCase						)
      return False




def 				a__	(	)  ->   List[Any]:
      return _is_package_available("""sagemaker"""						)




def 				a__	(	)  ->   Any:
      return _is_package_available("""tqdm"""						)




def 				a__	(	)  ->   List[Any]:
      return _is_package_available("""mlflow"""						)




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




def 				a__	(	)  ->   List[Any]:
      def get_major_and_minor_from_version(lowerCAmelCase						):
            return str(version.parse(lowerCAmelCase						).major						) + "." + str(version.parse(lowerCAmelCase						).minor						)

      UpperCAmelCase__ :       Any						=						importlib.metadata.version("""torch"""						)
      if importlib.util.find_spec("""intel_extension_for_pytorch"""						) is None:
            return False
      UpperCAmelCase__ :       Union[str, Any]						=						"""N/A"""
      try:
            UpperCAmelCase__ :       List[Any]						=						importlib.metadata.version("""intel_extension_for_pytorch"""						)
      except importlib.metadata.PackageNotFoundError:
            return False
      UpperCAmelCase__ :       int						=						get_major_and_minor_from_version(_torch_version						)
      UpperCAmelCase__ :       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 				a__	(	lowerCAmelCase=False						)  ->   str:
      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
                  UpperCAmelCase__ :       Union[str, Any]						=						torch.npu.device_count()
                  return torch.npu.is_available()
            except RuntimeError:
                  return False
      return hasattr(lowerCAmelCase ,  """npu"""						) and torch.npu.is_available()





@lru_cache
def 				a__	(	lowerCAmelCase=False						)  ->   Optional[int]:
      if not parse_flag_from_env("""ACCELERATE_USE_XPU""" ,  default=lowerCAmelCase						):
            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
                  UpperCAmelCase__ :       Dict						=						torch.xpu.device_count()
                  return torch.xpu.is_available()
            except RuntimeError:
                  return False
      return hasattr(lowerCAmelCase ,  """xpu"""						) and torch.xpu.is_available()




"""simple docstring"""
from typing import TYPE_CHECKING

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


_A						=     {
    """configuration_gpt2""": ["""GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP""", """GPT2Config""", """GPT2OnnxConfig"""],
    """tokenization_gpt2""": ["""GPT2Tokenizer"""],
}

try:
    if not is_tokenizers_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    _A						=     ["""GPT2TokenizerFast"""]

try:
    if not is_torch_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    _A						=     [
        """GPT2_PRETRAINED_MODEL_ARCHIVE_LIST""",
        """GPT2DoubleHeadsModel""",
        """GPT2ForQuestionAnswering""",
        """GPT2ForSequenceClassification""",
        """GPT2ForTokenClassification""",
        """GPT2LMHeadModel""",
        """GPT2Model""",
        """GPT2PreTrainedModel""",
        """load_tf_weights_in_gpt2""",
    ]

try:
    if not is_tf_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    _A						=     [
        """TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST""",
        """TFGPT2DoubleHeadsModel""",
        """TFGPT2ForSequenceClassification""",
        """TFGPT2LMHeadModel""",
        """TFGPT2MainLayer""",
        """TFGPT2Model""",
        """TFGPT2PreTrainedModel""",
    ]

try:
    if not is_keras_nlp_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    _A						=     ["""TFGPT2Tokenizer"""]

try:
    if not is_flax_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    _A						=     ["""FlaxGPT2LMHeadModel""", """FlaxGPT2Model""", """FlaxGPT2PreTrainedModel"""]

if TYPE_CHECKING:
    from .configuration_gpta import GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP, GPTaConfig, GPTaOnnxConfig
    from .tokenization_gpta import GPTaTokenizer

    try:
        if not is_tokenizers_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .tokenization_gpta_fast import GPTaTokenizerFast

    try:
        if not is_torch_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_gpta import (
            GPT2_PRETRAINED_MODEL_ARCHIVE_LIST,
            GPTaDoubleHeadsModel,
            GPTaForQuestionAnswering,
            GPTaForSequenceClassification,
            GPTaForTokenClassification,
            GPTaLMHeadModel,
            GPTaModel,
            GPTaPreTrainedModel,
            load_tf_weights_in_gpta,
        )

    try:
        if not is_tf_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_tf_gpta import (
            TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST,
            TFGPTaDoubleHeadsModel,
            TFGPTaForSequenceClassification,
            TFGPTaLMHeadModel,
            TFGPTaMainLayer,
            TFGPTaModel,
            TFGPTaPreTrainedModel,
        )

    try:
        if not is_keras_nlp_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .tokenization_gpta_tf import TFGPTaTokenizer

    try:
        if not is_flax_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_flax_gpta import FlaxGPTaLMHeadModel, FlaxGPTaModel, FlaxGPTaPreTrainedModel

else:
    import sys

    _A						=     _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)

