





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

   lowerCAmelCase:	Dict							      =True
except ImportError:
   lowerCAmelCase:	str							      =False


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




def 			__snake_case						(      __A    )		->				Optional[Any]:
   lowercase    :			Tuple  =       importlib.util.find_spec(UpperCamelCase_    ) is not None
   if package_exists:
      try:
         lowercase    :			Tuple  =       importlib.metadata.metadata(UpperCamelCase_    )
         return True
      except importlib.metadata.PackageNotFoundError:
         return False




def 			__snake_case						(      )		->				List[str]:
   return _torch_distributed_available




def 			__snake_case						(      )		->				Any:






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




def 			__snake_case						(      )		->				Tuple:
   return _is_package_available("""transformer_engine"""    )




@lru_cache
def 			__snake_case						(      __A=True    )		->				Union[str, Any]:






   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    :			Optional[Any]  =       xm.xla_device()
         return True
      except RuntimeError:
         return False
   return _tpu_available




def 			__snake_case						(      )		->				Optional[Any]:
   return _is_package_available("""deepspeed"""    )




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




def 			__snake_case						(      )		->				Tuple:
   lowercase    :			str  =       _is_package_available("""bitsandbytes"""    )
   if package_exists:
      lowercase    :			List[str]  =       version.parse(importlib.metadata.version("""bitsandbytes"""    )    )
      return compare_versions(UpperCamelCase_ ,""">=""" ,"""0.37.2"""    )
   return False




def 			__snake_case						(      )		->				List[str]:
   return _is_package_available("""bitsandbytes"""    )




def 			__snake_case						(      )		->				List[str]:






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




def 			__snake_case						(      )		->				Tuple:
   return _is_package_available("""transformers"""    )




def 			__snake_case						(      )		->				Optional[int]:
   return _is_package_available("""datasets"""    )




def 			__snake_case						(      )		->				Union[str, Any]:
   return _is_package_available("""aim"""    )




def 			__snake_case						(      )		->				int:
   return _is_package_available("""tensorboard"""    ) or _is_package_available("""tensorboardX"""    )




def 			__snake_case						(      )		->				List[Any]:
   return _is_package_available("""wandb"""    )




def 			__snake_case						(      )		->				List[str]:
   return _is_package_available("""comet_ml"""    )




def 			__snake_case						(      )		->				Optional[Any]:
   return _is_package_available("""boto3"""    )




def 			__snake_case						(      )		->				Union[str, Any]:






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




def 			__snake_case						(      )		->				str:
   return _is_package_available("""tqdm"""    )




def 			__snake_case						(      )		->				List[str]:
   return _is_package_available("""mlflow"""    )




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




def 			__snake_case						(      )		->				Any:






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

   lowercase    :			List[str]  =       importlib.metadata.version("""torch"""    )
   if importlib.util.find_spec("""intel_extension_for_pytorch"""    ) is None:
      return False
   lowercase    :			Dict  =       """N/A"""
   try:
      lowercase    :			Optional[int]  =       importlib.metadata.version("""intel_extension_for_pytorch"""    )
   except importlib.metadata.PackageNotFoundError:
      return False
   lowercase    :			Optional[Any]  =       get_major_and_minor_from_version(_torch_version    )
   lowercase    :			Union[str, 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 			__snake_case						(      __A=False    )		->				Optional[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
         lowercase    :			Optional[Any]  =       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 			__snake_case						(      __A=False    )		->				Dict:






   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    :			Any  =       torch.xpu.device_count()
         return torch.xpu.is_available()
      except RuntimeError:
         return False
   return hasattr(UpperCamelCase_ ,"""xpu"""    ) and torch.xpu.is_available()









"""simple docstring"""
import argparse

from . import (
    BertConfig,
    BertGenerationConfig,
    BertGenerationDecoder,
    BertGenerationEncoder,
    load_tf_weights_in_bert_generation,
    logging,
)


logging.set_verbosity_info()




def 			__snake_case						(      __A ,__A ,__A ,__A ,__A    )		->				Optional[int]:
   # Initialise PyTorch model
   lowercase    :			Optional[Any]  =       BertConfig.from_pretrained(
       """bert-large-cased""" ,vocab_size=__A ,max_position_embeddings=512 ,is_decoder=__A ,add_cross_attention=__A ,)
   lowercase    :			List[str]  =       bert_config.to_dict()
   del bert_config_dict["type_vocab_size"]
   lowercase    :			Tuple  =       BertGenerationConfig(**__A    )
   if is_encoder:
      lowercase    :			Dict  =       BertGenerationEncoder(__A    )
   else:
      lowercase    :			Dict  =       BertGenerationDecoder(__A    )
   print(F'''Building PyTorch model from configuration: {config}'''    )

   # Load weights from tf checkpoint
   load_tf_weights_in_bert_generation(
       __A ,__A ,model_class="""bert""" ,is_encoder_named_decoder=__A ,is_encoder=__A ,)

   # Save pytorch-model
   print(F'''Save PyTorch model and config to {pytorch_dump_path}'''    )
   model.save_pretrained(__A    )


if __name__ == "__main__":
   lowerCAmelCase:	Dict							      =argparse.ArgumentParser()
   # Required parameters
   parser.add_argument(
       "--tf_hub_path", default=None, type=str, required=True, help="Path to the TensorFlow checkpoint path."
   )
   parser.add_argument(
       "--pytorch_dump_path", default=None, type=str, required=True, help="Path to the output PyTorch model."
   )
   parser.add_argument(
       "--is_encoder_named_decoder",
       action="store_true",
       help="If decoder has to be renamed to encoder in PyTorch model.",
   )
   parser.add_argument("--is_encoder", action="store_true", help="If model is an encoder.")
   parser.add_argument("--vocab_size", default=50358, type=int, help="Vocab size of model")
   lowerCAmelCase:	Optional[int]							      =parser.parse_args()
   convert_tf_checkpoint_to_pytorch(
       args.tf_hub_path,
       args.pytorch_dump_path,
       args.is_encoder_named_decoder,
       args.vocab_size,
       is_encoder=args.is_encoder,
   )


