

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       :  str        = False


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



def        _lowerCAmelCase      (						UpperCAmelCase     :							List[Any]				):


					'''simple docstring'''






					UpperCamelCase__		:    Tuple         =importlib.util.find_spec(UpperCAmelCase				) is not None
					if package_exists:
										try:
															UpperCamelCase__		:    Union[str, Any]         =importlib.metadata.metadata(UpperCAmelCase				)
															return True
										except importlib.metadata.PackageNotFoundError:
															return False



def        _lowerCAmelCase      (						):


					'''simple docstring'''






					return _torch_distributed_available



def        _lowerCAmelCase      (						):


					'''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        _lowerCAmelCase      (						):


					'''simple docstring'''






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



def        _lowerCAmelCase      (						):


					'''simple docstring'''






					return _is_package_available('''transformer_engine'''				)



@lru_cache
def        _lowerCAmelCase      (						UpperCAmelCase     :							Any=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
															UpperCamelCase__		:    List[str]         =xm.xla_device()
															return True
										except RuntimeError:
															return False
					return _tpu_available



def        _lowerCAmelCase      (						):


					'''simple docstring'''






					return _is_package_available('''deepspeed'''				)



def        _lowerCAmelCase      (						UpperCAmelCase     :							Optional[int]=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        _lowerCAmelCase      (						):


					'''simple docstring'''






					UpperCamelCase__		:    Any         =_is_package_available('''bitsandbytes'''				)
					if package_exists:
										UpperCamelCase__		:    Optional[int]         =version.parse(importlib.metadata.version('''bitsandbytes'''				)				)
										return compare_versions(UpperCAmelCase      ,							'''>='''      ,							'''0.39.0'''				)
					return False



def        _lowerCAmelCase      (						):


					'''simple docstring'''






					UpperCamelCase__		:    Optional[int]         =_is_package_available('''bitsandbytes'''				)
					if package_exists:
										UpperCamelCase__		:    Optional[Any]         =version.parse(importlib.metadata.version('''bitsandbytes'''				)				)
										return compare_versions(UpperCAmelCase      ,							'''>='''      ,							'''0.37.2'''				)
					return False



def        _lowerCAmelCase      (						):


					'''simple docstring'''






					return _is_package_available('''bitsandbytes'''				)



def        _lowerCAmelCase      (						):


					'''simple docstring'''






					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__		:    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        _lowerCAmelCase      (						):


					'''simple docstring'''






					return _is_package_available('''safetensors'''				)



def        _lowerCAmelCase      (						):


					'''simple docstring'''






					return _is_package_available('''transformers'''				)



def        _lowerCAmelCase      (						):


					'''simple docstring'''






					return _is_package_available('''datasets'''				)



def        _lowerCAmelCase      (						):


					'''simple docstring'''






					return _is_package_available('''aim'''				)



def        _lowerCAmelCase      (						):


					'''simple docstring'''






					return _is_package_available('''tensorboard'''				) or _is_package_available('''tensorboardX'''				)



def        _lowerCAmelCase      (						):


					'''simple docstring'''






					return _is_package_available('''wandb'''				)



def        _lowerCAmelCase      (						):


					'''simple docstring'''






					return _is_package_available('''comet_ml'''				)



def        _lowerCAmelCase      (						):


					'''simple docstring'''






					return _is_package_available('''boto3'''				)



def        _lowerCAmelCase      (						):


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



def        _lowerCAmelCase      (						):


					'''simple docstring'''






					return _is_package_available('''sagemaker'''				)



def        _lowerCAmelCase      (						):


					'''simple docstring'''






					return _is_package_available('''tqdm'''				)



def        _lowerCAmelCase      (						):


					'''simple docstring'''






					return _is_package_available('''mlflow'''				)



def        _lowerCAmelCase      (						):


					'''simple docstring'''






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



def        _lowerCAmelCase      (						):


					'''simple docstring'''






					def get_major_and_minor_from_version(UpperCAmelCase     :							Union[str, Any]				):
										return str(version.parse(UpperCAmelCase				).major				) + "." + str(version.parse(UpperCAmelCase				).minor				)

					UpperCamelCase__		:    Any         =importlib.metadata.version('''torch'''				)
					if importlib.util.find_spec('''intel_extension_for_pytorch'''				) is None:
										return False
					UpperCamelCase__		:    Any         ='''N/A'''
					try:
										UpperCamelCase__		:    Optional[int]         =importlib.metadata.version('''intel_extension_for_pytorch'''				)
					except importlib.metadata.PackageNotFoundError:
										return False
					UpperCamelCase__		:    List[str]         =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        _lowerCAmelCase      (						UpperCAmelCase     :							List[str]=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
															UpperCamelCase__		:    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        _lowerCAmelCase      (						UpperCAmelCase     :							Tuple=False				):


					'''simple docstring'''






					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
															UpperCamelCase__		:    int         =torch.xpu.device_count()
															return torch.xpu.is_available()
										except RuntimeError:
															return False
					return hasattr(UpperCAmelCase      ,							'''xpu'''				) and torch.xpu.is_available()





"""simple docstring"""





def        _lowerCAmelCase      (						UpperCAmelCase     :							list[list[int]]				):


					'''simple docstring'''






					UpperCamelCase__		:    Dict         =[list(UpperCAmelCase				) for row in matrix]
					if matrix and isinstance(UpperCAmelCase      ,							UpperCAmelCase				):
										if isinstance(matrix[0]      ,							UpperCAmelCase				):
															UpperCamelCase__		:    List[Any]         =0
															for row in matrix:
																				if prev_len == 0:
																									UpperCamelCase__		:    Optional[Any]         =len(UpperCAmelCase				)
																									UpperCamelCase__		:    Optional[int]         =True
																				else:
																									UpperCamelCase__		:    List[str]         =prev_len == len(UpperCAmelCase				)
										else:
															UpperCamelCase__		:    Tuple         =True
					else:
										UpperCamelCase__		:    Optional[Any]         =False

					return result



def        _lowerCAmelCase      (						UpperCAmelCase     :							list[list[int]]				):


					'''simple docstring'''






					if check_matrix(UpperCAmelCase				) and len(UpperCAmelCase				) > 0:
										UpperCamelCase__		:    Optional[int]         =[list(UpperCAmelCase				) for row in a]
										UpperCamelCase__		:    Any         =len(UpperCAmelCase				)
										if isinstance(a[0]      ,							UpperCAmelCase				):
															UpperCamelCase__		:    Tuple         =len(a[0]				)
										else:
															for dat in a:
																				print(UpperCAmelCase				)
															return

										# horizotal printing increasing
										for i in range(0      ,							UpperCAmelCase				):
															print(a[0][i]				)
										# vertical printing down
										for i in range(1      ,							UpperCAmelCase				):
															print(a[i][mat_col - 1]				)
										# horizotal printing decreasing
										if mat_row > 1:
															for i in range(mat_col - 2      ,							-1      ,							-1				):
																				print(a[mat_row - 1][i]				)
        # vertical printing up
										for i in range(mat_row - 2      ,							0      ,							-1				):
															print(a[i][0]				)
										UpperCamelCase__		:    Tuple         =[row[1 : mat_col - 1] for row in a[1 : mat_row - 1]]
										if len(UpperCAmelCase				) > 0:
															spiral_print_clockwise(UpperCAmelCase				)
										else:
															return
					else:
										print('''Not a valid matrix'''				)
										return



def        _lowerCAmelCase      (						UpperCAmelCase     :							list[list]				):


					'''simple docstring'''






					if matrix:
										return list(matrix.pop(0				)				) + spiral_traversal(list(zip(*UpperCAmelCase				)				)[::-1]				)
					else:
										return []


# driver code
if __name__ == "__main__":
				import doctest

				doctest.testmod()

				_SCREAMING_SNAKE_CASE       :  int        = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 1_0, 1_1, 1_2]]
				spiral_print_clockwise(a)


