code: 
  
  
  
  
  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()
  
style_context: 
  
  
  
  
  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
  