




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 lowercase						(     SCREAMING_SNAKE_CASE   ) ->       Optional[Any]:


			'''simple docstring'''







			SCREAMING_SNAKE_CASE_			=	importlib.util.find_spec(SCREAMING_SNAKE_CASE   ) is not None
			if package_exists:
						try:
									SCREAMING_SNAKE_CASE_			=	importlib.metadata.metadata(SCREAMING_SNAKE_CASE   )
									return True
						except importlib.metadata.PackageNotFoundError:
									return False

def lowercase						(     ) ->       bool:


			'''simple docstring'''







			return _torch_distributed_available

def lowercase						(     ) ->       Union[str, Any]:


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


			'''simple docstring'''







			return importlib.metadata.version('oneccl_bind_pt'   )

def lowercase						(     ) ->       Optional[int]:


			'''simple docstring'''







			return _is_package_available('transformer_engine'   )

@lru_cache
def lowercase						(     SCREAMING_SNAKE_CASE=True   ) ->       Dict:


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

def lowercase						(     ) ->       Optional[Any]:


			'''simple docstring'''







			return _is_package_available('deepspeed'   )

def lowercase						(     SCREAMING_SNAKE_CASE=False   ) ->       Optional[Any]:


			'''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 lowercase						(     ) ->       Optional[int]:


			'''simple docstring'''







			SCREAMING_SNAKE_CASE_			=	_is_package_available('bitsandbytes'   )
			if package_exists:
						SCREAMING_SNAKE_CASE_			=	version.parse(importlib.metadata.version('bitsandbytes'   )   )
						return compare_versions(SCREAMING_SNAKE_CASE					,						'>='					,						'0.39.0'   )
			return False

def lowercase						(     ) ->       Optional[int]:


			'''simple docstring'''







			SCREAMING_SNAKE_CASE_			=	_is_package_available('bitsandbytes'   )
			if package_exists:
						SCREAMING_SNAKE_CASE_			=	version.parse(importlib.metadata.version('bitsandbytes'   )   )
						return compare_versions(SCREAMING_SNAKE_CASE					,						'>='					,						'0.37.2'   )
			return False

def lowercase						(     ) ->       Optional[Any]:


			'''simple docstring'''







			return _is_package_available('bitsandbytes'   )

def lowercase						(     ) ->       Any:


			'''simple docstring'''







			if strtobool(os.environ.get('ACCELERATE_USE_MEGATRON_LM'					,						'False'   )   ) == 1:
						SCREAMING_SNAKE_CASE_			=	importlib.util.find_spec('megatron'   ) is not None
						if package_exists:
									try:
												SCREAMING_SNAKE_CASE_			=	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 lowercase						(     ) ->       Any:


			'''simple docstring'''







			return _is_package_available('safetensors'   )

def lowercase						(     ) ->       int:


			'''simple docstring'''







			return _is_package_available('transformers'   )

def lowercase						(     ) ->       str:


			'''simple docstring'''







			return _is_package_available('datasets'   )

def lowercase						(     ) ->       Any:


			'''simple docstring'''







			return _is_package_available('aim'   )

def lowercase						(     ) ->       List[Any]:


			'''simple docstring'''







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

def lowercase						(     ) ->       List[Any]:


			'''simple docstring'''







			return _is_package_available('wandb'   )

def lowercase						(     ) ->       List[Any]:


			'''simple docstring'''







			return _is_package_available('comet_ml'   )

def lowercase						(     ) ->       List[Any]:


			'''simple docstring'''







			return _is_package_available('boto3'   )

def lowercase						(     ) ->       Union[str, Any]:


			'''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 lowercase						(     ) ->       Optional[Any]:


			'''simple docstring'''







			return _is_package_available('sagemaker'   )

def lowercase						(     ) ->       Dict:


			'''simple docstring'''







			return _is_package_available('tqdm'   )

def lowercase						(     ) ->       Any:


			'''simple docstring'''







			return _is_package_available('mlflow'   )

def lowercase						(     ) ->       Any:


			'''simple docstring'''







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

def lowercase						(     ) ->       Dict:


			'''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_			=	importlib.metadata.version('torch'   )
			if importlib.util.find_spec('intel_extension_for_pytorch'   ) is None:
						return False
			SCREAMING_SNAKE_CASE_			=	'N/A'
			try:
						SCREAMING_SNAKE_CASE_			=	importlib.metadata.version('intel_extension_for_pytorch'   )
			except importlib.metadata.PackageNotFoundError:
						return False
			SCREAMING_SNAKE_CASE_			=	get_major_and_minor_from_version(_torch_version   )
			SCREAMING_SNAKE_CASE_			=	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						(     SCREAMING_SNAKE_CASE=False   ) ->       Dict:


			'''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_			=	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 lowercase						(     SCREAMING_SNAKE_CASE=False   ) ->       str:


			'''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_			=	torch.xpu.device_count()
									return torch.xpu.is_available()
						except RuntimeError:
									return False
			return hasattr(SCREAMING_SNAKE_CASE					,						'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_					(    SCREAMING_SNAKE_CASE__    ):
	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
