
import functools
from math import sqrt
from time import time


def 					__lowerCAmelCase    (    a__		,					*a__		,					**a__						) ->						Optional[int]:
				__a    							=					time()
				__a    							=					func(*__A		,					**__A						)
				__a    							=					time()
				if int(end - start						) > 0:
								print(F"""{func.__name__} runtime: {(end - start):0.4f} s"""						)
				else:
								print(F"""{func.__name__} runtime: {(end - start) * 1000:0.4f} ms"""						)
				return output


def 					__lowerCAmelCase    (    a__						) ->						str:



				if n < 0:
								raise Exception('''n is negative'''						)
				if n == 0:
								return [0]
				__a    							=					[0, 1]
				for _ in range(n - 1						):
								fib.append(fib[-1] + fib[-2]						)
				return fib


def 					__lowerCAmelCase    (    a__						) ->						str:



				def fib_recursive_term(a__						) -> int:
								if i < 0:
												raise Exception('''n is negative'''						)
								if i < 2:
												return i
								return fib_recursive_term(i - 1						) + fib_recursive_term(i - 2						)

				if n < 0:
								raise Exception('''n is negative'''						)
				return [fib_recursive_term(__A						) for i in range(n + 1						)]


def 					__lowerCAmelCase    (    a__						) ->						List[Any]:



				@functools.cache
				def fib_recursive_term(a__						) -> int:
								if i < 0:
												raise Exception('''n is negative'''						)
								if i < 2:
												return i
								return fib_recursive_term(i - 1						) + fib_recursive_term(i - 2						)

				if n < 0:
								raise Exception('''n is negative'''						)
				return [fib_recursive_term(__A						) for i in range(n + 1						)]


def 					__lowerCAmelCase    (    a__						) ->						Dict:



				if n < 0:
								raise Exception('''n is negative'''						)
				# Cache must be outside recursuive function
				# other it will reset every time it calls itself.
				__a    							=					{0: 0, 1: 1, 2: 1}  # Prefilled cache

				def rec_fn_memoized(a__						) -> int:
								if num in cache:
												return cache[num]

								__a    							=					rec_fn_memoized(num - 1						) + rec_fn_memoized(num - 2						)
								__a    							=					value
								return value

				return [rec_fn_memoized(__A						) for i in range(n + 1						)]


def 					__lowerCAmelCase    (    a__						) ->						Any:



				if n < 0:
								raise Exception('''n is negative'''						)
				if n >= 1475:
								raise Exception('''n is too large'''						)
				__a    							=					sqrt(5						)
				__a    							=					(1 + sqrt_a) / 2
				return [round(phi**i / sqrt_a						) for i in range(n + 1						)]


if __name__ == "__main__":
					A  :			Optional[Any]     				=				3_0
					time_func(fib_iterative, num)
					time_func(fib_recursive, num)  # Around 3s runtime
					time_func(fib_recursive_cached, num)  # Around 0ms runtime
					time_func(fib_memoization, num)
					time_func(fib_binet, num)

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  :			List[str]     				=				True
except ImportError:
					A  :			List[Any]     				=				False


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


def 					__lowerCAmelCase    (    a__						) ->						List[str]:
				# 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(a__						) is not None
				if package_exists:
								try:
												__a    							=					importlib.metadata.metadata(a__						)
												return True
								except importlib.metadata.PackageNotFoundError:
												return False


def 					__lowerCAmelCase    (    ) ->						bool:
				return _torch_distributed_available


def 					__lowerCAmelCase    (    ) ->						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 					__lowerCAmelCase    (    ) ->						Union[str, Any]:
				return importlib.metadata.version('''oneccl_bind_pt'''						)


def 					__lowerCAmelCase    (    ) ->						Dict:
				return _is_package_available('''transformer_engine'''						)


@lru_cache
def 					__lowerCAmelCase    (    a__=True						) ->						Union[str, 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 					__lowerCAmelCase    (    ) ->						Any:
				return _is_package_available('''deepspeed'''						)


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


def 					__lowerCAmelCase    (    ) ->						Any:
				__a    							=					_is_package_available('''bitsandbytes'''						)
				if package_exists:
								__a    							=					version.parse(importlib.metadata.version('''bitsandbytes'''						)						)
								return compare_versions(a__		,					'''>='''		,					'''0.37.2'''						)
				return False


def 					__lowerCAmelCase    (    ) ->						int:
				return _is_package_available('''bitsandbytes'''						)


def 					__lowerCAmelCase    (    ) ->						str:
				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(a__		,					'''>='''		,					'''2.2.0'''						)
												except Exception as e:
																warnings.warn(F"""Parse Megatron version failed. Exception:{e}"""						)
																return False


def 					__lowerCAmelCase    (    ) ->						List[str]:
				return _is_package_available('''safetensors'''						)


def 					__lowerCAmelCase    (    ) ->						Optional[Any]:
				return _is_package_available('''transformers'''						)


def 					__lowerCAmelCase    (    ) ->						int:
				return _is_package_available('''datasets'''						)


def 					__lowerCAmelCase    (    ) ->						Optional[int]:
				return _is_package_available('''aim'''						)


def 					__lowerCAmelCase    (    ) ->						List[Any]:
				return _is_package_available('''tensorboard'''						) or _is_package_available('''tensorboardX'''						)


def 					__lowerCAmelCase    (    ) ->						List[Any]:
				return _is_package_available('''wandb'''						)


def 					__lowerCAmelCase    (    ) ->						Optional[int]:
				return _is_package_available('''comet_ml'''						)


def 					__lowerCAmelCase    (    ) ->						str:
				return _is_package_available('''boto3'''						)


def 					__lowerCAmelCase    (    ) ->						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'''		,					a__						)
								return parse_flag_from_env('''ACCELERATE_ENABLE_RICH'''		,					a__						)
				return False


def 					__lowerCAmelCase    (    ) ->						Any:
				return _is_package_available('''sagemaker'''						)


def 					__lowerCAmelCase    (    ) ->						int:
				return _is_package_available('''tqdm'''						)


def 					__lowerCAmelCase    (    ) ->						Union[str, Any]:
				return _is_package_available('''mlflow'''						)


def 					__lowerCAmelCase    (    ) ->						Optional[Any]:
				return is_torch_version('''>='''		,					'''1.12'''						) and torch.backends.mps.is_available() and torch.backends.mps.is_built()


def 					__lowerCAmelCase    (    ) ->						str:
				def get_major_and_minor_from_version(a__						):
								return str(version.parse(a__						).major						) + "." + str(version.parse(a__						).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 					__lowerCAmelCase    (    a__=False						) ->						List[Any]:
				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(a__		,					'''npu'''						) and torch.npu.is_available()






@lru_cache
def 					__lowerCAmelCase    (    a__=False						) ->						Union[str, Any]:
				if not parse_flag_from_env('''ACCELERATE_USE_XPU'''		,					default=a__						):
								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(a__		,					'''xpu'''						) and torch.xpu.is_available()