


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

				UpperCAmelCase_		:       Dict							       =		True
except ImportError:
				UpperCAmelCase_		:       Dict							       =		False


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







def       snake_case_       (  SCREAMING_SNAKE_CASE__					):







				"""simple docstring"""





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







def       snake_case_       (  ):







				"""simple docstring"""





				return _torch_distributed_available







def       snake_case_       (  ):







				"""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       snake_case_       (  ):







				"""simple docstring"""





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







def       snake_case_       (  ):







				"""simple docstring"""





				return _is_package_available("""transformer_engine"""					)







@lru_cache
def       snake_case_       (  SCREAMING_SNAKE_CASE__=True					):







				"""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
												_SCREAMING_SNAKE_CASE			:	int							=				xm.xla_device()
												return True
								except RuntimeError:
												return False
				return _tpu_available







def       snake_case_       (  ):







				"""simple docstring"""





				return _is_package_available("""deepspeed"""					)







def       snake_case_       (  SCREAMING_SNAKE_CASE__=False					):







				"""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       snake_case_       (  ):







				"""simple docstring"""





				_SCREAMING_SNAKE_CASE			:	Any							=				_is_package_available("""bitsandbytes"""					)
				if package_exists:
								_SCREAMING_SNAKE_CASE			:	List[str]							=				version.parse(importlib.metadata.version("""bitsandbytes"""					)					)
								return compare_versions(SCREAMING_SNAKE_CASE_							,				""">="""							,				"""0.39.0"""					)
				return False







def       snake_case_       (  ):







				"""simple docstring"""





				_SCREAMING_SNAKE_CASE			:	Dict							=				_is_package_available("""bitsandbytes"""					)
				if package_exists:
								_SCREAMING_SNAKE_CASE			:	str							=				version.parse(importlib.metadata.version("""bitsandbytes"""					)					)
								return compare_versions(SCREAMING_SNAKE_CASE_							,				""">="""							,				"""0.37.2"""					)
				return False







def       snake_case_       (  ):







				"""simple docstring"""





				return _is_package_available("""bitsandbytes"""					)







def       snake_case_       (  ):







				"""simple docstring"""





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







def       snake_case_       (  ):







				"""simple docstring"""





				return _is_package_available("""safetensors"""					)







def       snake_case_       (  ):







				"""simple docstring"""





				return _is_package_available("""transformers"""					)







def       snake_case_       (  ):







				"""simple docstring"""





				return _is_package_available("""datasets"""					)







def       snake_case_       (  ):







				"""simple docstring"""





				return _is_package_available("""aim"""					)







def       snake_case_       (  ):







				"""simple docstring"""





				return _is_package_available("""tensorboard"""					) or _is_package_available("""tensorboardX"""					)







def       snake_case_       (  ):







				"""simple docstring"""





				return _is_package_available("""wandb"""					)







def       snake_case_       (  ):







				"""simple docstring"""





				return _is_package_available("""comet_ml"""					)







def       snake_case_       (  ):







				"""simple docstring"""





				return _is_package_available("""boto3"""					)







def       snake_case_       (  ):







				"""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"""							,				SCREAMING_SNAKE_CASE_					)
								return parse_flag_from_env("""ACCELERATE_ENABLE_RICH"""							,				SCREAMING_SNAKE_CASE_					)
				return False







def       snake_case_       (  ):







				"""simple docstring"""





				return _is_package_available("""sagemaker"""					)







def       snake_case_       (  ):







				"""simple docstring"""





				return _is_package_available("""tqdm"""					)







def       snake_case_       (  ):







				"""simple docstring"""





				return _is_package_available("""mlflow"""					)







def       snake_case_       (  ):







				"""simple docstring"""





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







def       snake_case_       (  ):







				"""simple docstring"""





				def get_major_and_minor_from_version(SCREAMING_SNAKE_CASE__					):
								return str(version.parse(SCREAMING_SNAKE_CASE_					).major					) + "." + str(version.parse(SCREAMING_SNAKE_CASE_					).minor					)

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







				"""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
												_SCREAMING_SNAKE_CASE			:	List[Any]							=				torch.npu.device_count()
												return torch.npu.is_available()
								except RuntimeError:
												return False
				return hasattr(SCREAMING_SNAKE_CASE_							,				"""npu"""					) and torch.npu.is_available()







@lru_cache
def       snake_case_       (  SCREAMING_SNAKE_CASE__=False					):







				"""simple docstring"""





				if not parse_flag_from_env("""ACCELERATE_USE_XPU"""							,				default=SCREAMING_SNAKE_CASE_					):
								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
												_SCREAMING_SNAKE_CASE			:	Dict							=				torch.xpu.device_count()
												return torch.xpu.is_available()
								except RuntimeError:
												return False
				return hasattr(SCREAMING_SNAKE_CASE_							,				"""xpu"""					) and torch.xpu.is_available()








'''simple docstring'''


def       snake_case_       (  SCREAMING_SNAKE_CASE__							,				SCREAMING_SNAKE_CASE__					):







				"""simple docstring"""





				if len(str(SCREAMING_SNAKE_CASE__					)					) == 1 or len(str(SCREAMING_SNAKE_CASE__					)					) == 1:
								return a * b

				_SCREAMING_SNAKE_CASE			:	Optional[Any]							=				max(len(str(SCREAMING_SNAKE_CASE__					)					)							,				len(str(SCREAMING_SNAKE_CASE__					)					)					)
				_SCREAMING_SNAKE_CASE			:	Tuple							=				ma // 2

				_SCREAMING_SNAKE_CASE		,	_SCREAMING_SNAKE_CASE			:	Optional[int]							=				divmod(SCREAMING_SNAKE_CASE__							,				10**ma					)
				_SCREAMING_SNAKE_CASE		,	_SCREAMING_SNAKE_CASE			:	Optional[int]							=				divmod(SCREAMING_SNAKE_CASE__							,				10**ma					)

				_SCREAMING_SNAKE_CASE			:	Dict							=				karatsuba(SCREAMING_SNAKE_CASE__							,				SCREAMING_SNAKE_CASE__					)
				_SCREAMING_SNAKE_CASE			:	List[Any]							=				karatsuba((aa + aa)							,				(ba + ba)					)
				_SCREAMING_SNAKE_CASE			:	List[Any]							=				karatsuba(SCREAMING_SNAKE_CASE__							,				SCREAMING_SNAKE_CASE__					)

				return (z * 10 ** (2 * ma)) + ((y - z - x) * 10 ** (ma)) + (x)







def       snake_case_       (  ):







				"""simple docstring"""





				print(karatsuba(1_5463							,				2_3489					)					)


if __name__ == "__main__":
				main()




