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

      SCREAMING_SNAKE_CASE     :   str    =					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     :   Union[str, Any]    =					torch.distributed.is_available()







def snake_case_    (				lowercase__		):
  # Check we're not importing a "pkg_name" directory somewhere but the actual library by trying to grab the version
  UpperCAmelCase__			:				int												=       importlib.util.find_spec(lowercase__		) is not None
  if package_exists:
    try:
      UpperCAmelCase__			:				List[str]												=       importlib.metadata.metadata(lowercase__		)
      return True
    except importlib.metadata.PackageNotFoundError:
      return False







def snake_case_    (				):
  return _torch_distributed_available







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







def snake_case_    (				):
  return _is_package_available("transformer_engine"		)







@lru_cache
def snake_case_    (				lowercase__=True		):
  # 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__			:				List[str]												=       xm.xla_device()
      return True
    except RuntimeError:
      return False
  return _tpu_available







def snake_case_    (				):
  return _is_package_available("deepspeed"		)







def snake_case_    (				lowercase__=False		):
  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_    (				):
  UpperCAmelCase__			:				int												=       _is_package_available("bitsandbytes"		)
  if package_exists:
    UpperCAmelCase__			:				Tuple												=       version.parse(importlib.metadata.version("bitsandbytes"		)		)
    return compare_versions(lowercase__      ,					">="      ,					"0.39.0"		)
  return False







def snake_case_    (				):
  UpperCAmelCase__			:				Optional[Any]												=       _is_package_available("bitsandbytes"		)
  if package_exists:
    UpperCAmelCase__			:				Optional[int]												=       version.parse(importlib.metadata.version("bitsandbytes"		)		)
    return compare_versions(lowercase__      ,					">="      ,					"0.37.2"		)
  return False







def snake_case_    (				):
  return _is_package_available("bitsandbytes"		)







def snake_case_    (				):
  if strtobool(os.environ.get("ACCELERATE_USE_MEGATRON_LM"      ,					"False"		)		) == 1:
    UpperCAmelCase__			:				int												=       importlib.util.find_spec("megatron"		) is not None
    if package_exists:
      try:
        UpperCAmelCase__			:				Tuple												=       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 snake_case_    (				):
  return _is_package_available("safetensors"		)







def snake_case_    (				):
  return _is_package_available("transformers"		)







def snake_case_    (				):
  return _is_package_available("datasets"		)







def snake_case_    (				):
  return _is_package_available("aim"		)







def snake_case_    (				):
  return _is_package_available("tensorboard"		) or _is_package_available("tensorboardX"		)







def snake_case_    (				):
  return _is_package_available("wandb"		)







def snake_case_    (				):
  return _is_package_available("comet_ml"		)







def snake_case_    (				):
  return _is_package_available("boto3"		)







def snake_case_    (				):
  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 snake_case_    (				):
  return _is_package_available("sagemaker"		)







def snake_case_    (				):
  return _is_package_available("tqdm"		)







def snake_case_    (				):
  return _is_package_available("mlflow"		)







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







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

  UpperCAmelCase__			:				int												=       importlib.metadata.version("torch"		)
  if importlib.util.find_spec("intel_extension_for_pytorch"		) is None:
    return False
  UpperCAmelCase__			:				int												=       "N/A"
  try:
    UpperCAmelCase__			:				Any												=       importlib.metadata.version("intel_extension_for_pytorch"		)
  except importlib.metadata.PackageNotFoundError:
    return False
  UpperCAmelCase__			:				Any												=       get_major_and_minor_from_version(_torch_version		)
  UpperCAmelCase__			:				Optional[int]												=       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_    (				lowercase__=False		):
  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__			:				Optional[Any]												=       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 snake_case_    (				lowercase__=False		):
  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
      UpperCAmelCase__			:				str												=       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 math import cos, sin







def snake_case_    (				lowercase__		):
  UpperCAmelCase__			:				List[Any]												=       float(lowercase__		)
  return [[scaling_factor * int(x == y		) for x in range(2		)] for y in range(2		)]







def snake_case_    (				lowercase__		):
  UpperCAmelCase__					, UpperCAmelCase__			:				List[Any]												=       cos(lowercase__		), sin(lowercase__		)
  return [[c, -s], [s, c]]







def snake_case_    (				lowercase__		):
  UpperCAmelCase__					, UpperCAmelCase__			:				Dict												=       cos(lowercase__		), sin(lowercase__		)
  UpperCAmelCase__			:				Tuple												=       c * s
  return [[c * c, cs], [cs, s * s]]







def snake_case_    (				lowercase__		):
  UpperCAmelCase__					, UpperCAmelCase__			:				Dict												=       cos(lowercase__		), sin(lowercase__		)
  UpperCAmelCase__			:				Any												=       c * s
  return [[2 * c - 1, 2 * cs], [2 * cs, 2 * s - 1]]


print(F'    {scaling(5) = }')
print(F'  {rotation(4_5) = }')
print(F'{projection(4_5) = }')






print(F'{reflection(4_5) = }')



