




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__   :    Tuple 					=      True
except ImportError:
   lowercase__   :    List[Any] 					=      False


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

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

def       SCREAMING_SNAKE_CASE							(     )    ->  bool:
     return _torch_distributed_available

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

def       SCREAMING_SNAKE_CASE							(     )    ->  str:
     return _is_package_available("transformer_engine")

@lru_cache
def       SCREAMING_SNAKE_CASE							(     __UpperCamelCase=True)    ->  Optional[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
               a											=   xm.xla_device()
               return True
          except RuntimeError:
               return False
     return _tpu_available

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

def       SCREAMING_SNAKE_CASE							(     __UpperCamelCase=False)    ->  Tuple:
     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       SCREAMING_SNAKE_CASE							(     )    ->  Union[str, Any]:
     a											=   _is_package_available("bitsandbytes")
     if package_exists:
          a											=   version.parse(importlib.metadata.version("bitsandbytes"))
          return compare_versions(__UpperCamelCase	,      ">="	,      "0.39.0")
     return False

def       SCREAMING_SNAKE_CASE							(     )    ->  Union[str, Any]:
     a											=   _is_package_available("bitsandbytes")
     if package_exists:
          a											=   version.parse(importlib.metadata.version("bitsandbytes"))
          return compare_versions(__UpperCamelCase	,      ">="	,      "0.37.2")
     return False

def       SCREAMING_SNAKE_CASE							(     )    ->  Optional[int]:
     return _is_package_available("bitsandbytes")

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

def       SCREAMING_SNAKE_CASE							(     )    ->  Optional[Any]:
     return _is_package_available("transformers")

def       SCREAMING_SNAKE_CASE							(     )    ->  Any:
     return _is_package_available("datasets")

def       SCREAMING_SNAKE_CASE							(     )    ->  Dict:
     return _is_package_available("aim")

def       SCREAMING_SNAKE_CASE							(     )    ->  Optional[Any]:
     return _is_package_available("tensorboard") or _is_package_available("tensorboardX")

def       SCREAMING_SNAKE_CASE							(     )    ->  List[str]:
     return _is_package_available("wandb")

def       SCREAMING_SNAKE_CASE							(     )    ->  Optional[Any]:
     return _is_package_available("comet_ml")

def       SCREAMING_SNAKE_CASE							(     )    ->  Tuple:
     return _is_package_available("boto3")

def       SCREAMING_SNAKE_CASE							(     )    ->  Optional[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       SCREAMING_SNAKE_CASE							(     )    ->  str:
     return _is_package_available("sagemaker")

def       SCREAMING_SNAKE_CASE							(     )    ->  Optional[Any]:
     return _is_package_available("tqdm")

def       SCREAMING_SNAKE_CASE							(     )    ->  int:
     return _is_package_available("mlflow")

def       SCREAMING_SNAKE_CASE							(     )    ->  Union[str, Any]:
     return is_torch_version(">="	,      "1.12") and torch.backends.mps.is_available() and torch.backends.mps.is_built()

def       SCREAMING_SNAKE_CASE							(     )    ->  int:
     def get_major_and_minor_from_version(__UpperCamelCase):
          return str(version.parse(__UpperCamelCase).major) + "." + str(version.parse(__UpperCamelCase).minor)

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







from __future__ import annotations

def       SCREAMING_SNAKE_CASE							(     __UpperCamelCase)    ->  int | None:
     for r in range(1	,      __UpperCamelCase):
          a											=   []
          for x in range(n - 1):
               a											=   pow(__UpperCamelCase	,      __UpperCamelCase	,      __UpperCamelCase)
               if val in li:
                    break
               li.append(__UpperCamelCase)
          else:
               return r
     return None


if __name__ == "__main__":
   lowercase__   :    Tuple 					=      int(input("Enter a prime number q: "))
   lowercase__   :    List[Any] 					=      find_primitive(q)
   if a is None:
      print(F'Cannot find the primitive for the value: {a!r}')
   else:
      lowercase__   :    Any 					=      int(input("Enter private key of A: "))
      lowercase__   :    Optional[int] 					=      pow(a, a_private, q)
      lowercase__   :    Optional[Any] 					=      int(input("Enter private key of B: "))
      lowercase__   :    Any 					=      pow(a, b_private, q)

      lowercase__   :    Optional[Any] 					=      pow(b_public, a_private, q)
      lowercase__   :    List[str] 					=      pow(a_public, b_private, q)

      print("The key value generated by A is: ", a_secret)
      print("The key value generated by B is: ", b_secret)

