code: '''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
  
  	lowercase__    :       Any						=			True
  except ImportError:
  	lowercase__    :       Optional[Any]						=			False
  
  
  # Cache this result has it's a C FFI call which can be pretty time-consuming
  lowercase__    :       Optional[int]						=			torch.distributed.is_available()
  
  def      SCREAMING_SNAKE_CASE_  (		snake_case__							)  ->			List[Any]:
  							# Check we're not importing a "pkg_name" directory somewhere but the actual library by trying to grab the version
  							lowerCAmelCase				=	importlib.util.find_spec(lowercase__							) is not None
  							if package_exists:
  														try:
  																					lowerCAmelCase				=	importlib.metadata.metadata(lowercase__							)
  																					return True
  														except importlib.metadata.PackageNotFoundError:
  																					return False
  
  def      SCREAMING_SNAKE_CASE_  (		)  ->			Optional[Any]:
  							return _torch_distributed_available
  
  def      SCREAMING_SNAKE_CASE_  (		)  ->			int:
  							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_  (		)  ->			List[str]:
  							return _is_package_available('''transformer_engine'''							)
  
  @lru_cache
  def      SCREAMING_SNAKE_CASE_  (		snake_case__=True							)  ->			List[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
  																					lowerCAmelCase				=	xm.xla_device()
  																					return True
  														except RuntimeError:
  																					return False
  							return _tpu_available
  
  def      SCREAMING_SNAKE_CASE_  (		)  ->			int:
  							return _is_package_available('''deepspeed'''							)
  
  def      SCREAMING_SNAKE_CASE_  (		snake_case__=False							)  ->			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      SCREAMING_SNAKE_CASE_  (		)  ->			Tuple:
  							lowerCAmelCase				=	_is_package_available('''bitsandbytes'''							)
  							if package_exists:
  														lowerCAmelCase				=	version.parse(importlib.metadata.version('''bitsandbytes'''							)							)
  														return compare_versions(lowercase__     ,						'''>='''     ,						'''0.39.0'''							)
  							return False
  
  def      SCREAMING_SNAKE_CASE_  (		)  ->			Optional[int]:
  							lowerCAmelCase				=	_is_package_available('''bitsandbytes'''							)
  							if package_exists:
  														lowerCAmelCase				=	version.parse(importlib.metadata.version('''bitsandbytes'''							)							)
  														return compare_versions(lowercase__     ,						'''>='''     ,						'''0.37.2'''							)
  							return False
  
  def      SCREAMING_SNAKE_CASE_  (		)  ->			Optional[Any]:
  							return _is_package_available('''bitsandbytes'''							)
  
  def      SCREAMING_SNAKE_CASE_  (		)  ->			Dict:
  							if strtobool(os.environ.get('''ACCELERATE_USE_MEGATRON_LM'''     ,						'''False'''							)							) == 1:
  														lowerCAmelCase				=	importlib.util.find_spec('''megatron'''							) is not None
  														if package_exists:
  																					try:
  																												lowerCAmelCase				=	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      SCREAMING_SNAKE_CASE_  (		)  ->			List[Any]:
  							return _is_package_available('''safetensors'''							)
  
  def      SCREAMING_SNAKE_CASE_  (		)  ->			str:
  							return _is_package_available('''transformers'''							)
  
  def      SCREAMING_SNAKE_CASE_  (		)  ->			int:
  							return _is_package_available('''datasets'''							)
  
  def      SCREAMING_SNAKE_CASE_  (		)  ->			List[Any]:
  							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_  (		)  ->			Any:
  							return _is_package_available('''wandb'''							)
  
  def      SCREAMING_SNAKE_CASE_  (		)  ->			Tuple:
  							return _is_package_available('''comet_ml'''							)
  
  def      SCREAMING_SNAKE_CASE_  (		)  ->			List[str]:
  							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'''     ,						lowercase__							)
  														return parse_flag_from_env('''ACCELERATE_ENABLE_RICH'''     ,						lowercase__							)
  							return False
  
  def      SCREAMING_SNAKE_CASE_  (		)  ->			Tuple:
  							return _is_package_available('''sagemaker'''							)
  
  def      SCREAMING_SNAKE_CASE_  (		)  ->			List[str]:
  							return _is_package_available('''tqdm'''							)
  
  def      SCREAMING_SNAKE_CASE_  (		)  ->			Optional[Any]:
  							return _is_package_available('''mlflow'''							)
  
  def      SCREAMING_SNAKE_CASE_  (		)  ->			Optional[int]:
  							return is_torch_version('''>='''     ,						'''1.12'''							) and torch.backends.mps.is_available() and torch.backends.mps.is_built()
  
  def      SCREAMING_SNAKE_CASE_  (		)  ->			Any:
  							def get_major_and_minor_from_version(snake_case__							):
  														return str(version.parse(lowercase__							).major							) + "." + str(version.parse(lowercase__							).minor							)
  
  							lowerCAmelCase				=	importlib.metadata.version('''torch'''							)
  							if importlib.util.find_spec('''intel_extension_for_pytorch'''							) is None:
  														return False
  							lowerCAmelCase				=	'''N/A'''
  							try:
  														lowerCAmelCase				=	importlib.metadata.version('''intel_extension_for_pytorch'''							)
  							except importlib.metadata.PackageNotFoundError:
  														return False
  							lowerCAmelCase				=	get_major_and_minor_from_version(_torch_version							)
  							lowerCAmelCase				=	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_  (		snake_case__=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
  																					lowerCAmelCase				=	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      SCREAMING_SNAKE_CASE_  (		snake_case__=False							)  ->			Optional[int]:
  							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
  																					lowerCAmelCase				=	torch.xpu.device_count()
  																					return torch.xpu.is_available()
  														except RuntimeError:
  																					return False
  							return hasattr(lowercase__     ,						'''xpu'''							) and torch.xpu.is_available()
  
  
  
  
style_context: def      SCREAMING_SNAKE_CASE_  (		snake_case__     ,						snake_case__							)  ->			int:
  							return (input_a, input_a).count(0							) % 2
  
  def      SCREAMING_SNAKE_CASE_  (		)  ->			None:
  							assert xor_gate(0     ,						0							) == 0
  							assert xor_gate(0     ,						1							) == 1
  							assert xor_gate(1     ,						0							) == 1
  							assert xor_gate(1     ,						1							) == 0
  
  
  if __name__ == "__main__":
  	print(xor_gate(0, 0))
  	print(xor_gate(0, 1))
  
  
  
  