





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__  :	Union[str, Any]     =True
except ImportError:
							UpperCAmelCase__  :	str     =False


# Cache this result has it's a C FFI call which can be pretty time-consuming
UpperCAmelCase__  :	Optional[int]     =torch.distributed.is_available()





def    _lowercase    (  _UpperCAmelCase )  ->     Dict:
				# 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(_UpperCAmelCase ) is not None
				if package_exists:
								try:
												lowerCamelCase		       =importlib.metadata.metadata(_UpperCAmelCase )
												return True
								except importlib.metadata.PackageNotFoundError:
												return False





def    _lowercase    (  )  ->     bool:
				return _torch_distributed_available





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





def    _lowercase    (  )  ->     List[str]:
				return _is_package_available("""transformer_engine""" )





@lru_cache
def    _lowercase    (  _UpperCAmelCase=True )  ->     str:
				# 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    _lowercase    (  )  ->     Tuple:
				return _is_package_available("""deepspeed""" )





def    _lowercase    (  _UpperCAmelCase=False )  ->     str:
				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    _lowercase    (  )  ->     Any:
				lowerCamelCase		       =_is_package_available("""bitsandbytes""" )
				if package_exists:
								lowerCamelCase		       =version.parse(importlib.metadata.version("""bitsandbytes""" ) )
								return compare_versions(_UpperCAmelCase	,					""">="""	,					"""0.39.0""" )
				return False





def    _lowercase    (  )  ->     List[Any]:
				lowerCamelCase		       =_is_package_available("""bitsandbytes""" )
				if package_exists:
								lowerCamelCase		       =version.parse(importlib.metadata.version("""bitsandbytes""" ) )
								return compare_versions(_UpperCAmelCase	,					""">="""	,					"""0.37.2""" )
				return False





def    _lowercase    (  )  ->     int:
				return _is_package_available("""bitsandbytes""" )





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





def    _lowercase    (  )  ->     Dict:
				return _is_package_available("""safetensors""" )





def    _lowercase    (  )  ->     int:
				return _is_package_available("""transformers""" )





def    _lowercase    (  )  ->     Any:
				return _is_package_available("""datasets""" )





def    _lowercase    (  )  ->     Optional[int]:
				return _is_package_available("""aim""" )





def    _lowercase    (  )  ->     Union[str, Any]:
				return _is_package_available("""tensorboard""" ) or _is_package_available("""tensorboardX""" )





def    _lowercase    (  )  ->     Tuple:
				return _is_package_available("""wandb""" )





def    _lowercase    (  )  ->     Tuple:
				return _is_package_available("""comet_ml""" )





def    _lowercase    (  )  ->     Union[str, Any]:
				return _is_package_available("""boto3""" )





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





def    _lowercase    (  )  ->     Tuple:
				return _is_package_available("""sagemaker""" )





def    _lowercase    (  )  ->     Union[str, Any]:
				return _is_package_available("""tqdm""" )





def    _lowercase    (  )  ->     str:
				return _is_package_available("""mlflow""" )





def    _lowercase    (  )  ->     Optional[int]:
				return is_torch_version(""">="""	,					"""1.12""" ) and torch.backends.mps.is_available() and torch.backends.mps.is_built()





def    _lowercase    (  )  ->     Any:
				def get_major_and_minor_from_version(_UpperCAmelCase ):
								return str(version.parse(_UpperCAmelCase ).major ) + "." + str(version.parse(_UpperCAmelCase ).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    _lowercase    (  _UpperCAmelCase=False )  ->     Union[str, 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(_UpperCAmelCase	,					"""npu""" ) and torch.npu.is_available()





@lru_cache
def    _lowercase    (  _UpperCAmelCase=False )  ->     str:
				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
												lowerCamelCase		       =torch.xpu.device_count()
												return torch.xpu.is_available()
								except RuntimeError:
												return False
				return hasattr(_UpperCAmelCase	,					"""xpu""" ) and torch.xpu.is_available()












from dataclasses import dataclass
from typing import List, Optional, Union

import numpy as np
import PIL

from ...utils import BaseOutput, is_invisible_watermark_available, is_torch_available, is_transformers_available

@dataclass
class 					__A   (  a			):
				__A            = 42


if is_transformers_available() and is_torch_available() and is_invisible_watermark_available():
							from .pipeline_stable_diffusion_xl import StableDiffusionXLPipeline
							from .pipeline_stable_diffusion_xl_imgaimg import StableDiffusionXLImgaImgPipeline





