code: 
  
  
  
  
  '''simple docstring'''
  
  
  
  
  
  
  
  # This model implementation is heavily based on:
  
  import gc
  import random
  import tempfile
  import unittest
  
  import numpy as np
  import torch
  from PIL import Image
  from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer
  
  from diffusers import (
      AutoencoderKL,
      ControlNetModel,
      DDIMScheduler,
      StableDiffusionControlNetInpaintPipeline,
      UNetaDConditionModel,
  )
  from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_controlnet import MultiControlNetModel
  from diffusers.utils import floats_tensor, load_image, load_numpy, randn_tensor, slow, torch_device
  from diffusers.utils.import_utils import is_xformers_available
  from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu
  
  from ..pipeline_params import (
      TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS,
      TEXT_GUIDED_IMAGE_INPAINTING_PARAMS,
      TEXT_TO_IMAGE_IMAGE_PARAMS,
  )
  from ..test_pipelines_common import (
      PipelineKarrasSchedulerTesterMixin,
      PipelineLatentTesterMixin,
      PipelineTesterMixin,
  )
  
  
  enable_full_determinism()
  
  
  
  
  
  class   lowerCamelCase_							( UpperCAmelCase_, UpperCAmelCase_, UpperCAmelCase_, unittest.TestCase							):
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  					lowercase__					=				StableDiffusionControlNetInpaintPipeline
  					lowercase__					=				TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
  					lowercase__					=				TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
  					lowercase__					=				frozenset({"""control_image"""}							)  # skip `image` and `mask` for now, only test for control_image
  					lowercase__					=				TEXT_TO_IMAGE_IMAGE_PARAMS
  
  
  
  
  
  
  					def        __SCREAMING_SNAKE_CASE			(					self				):
  							torch.manual_seed(0				)
  							_snake_case			 = UNetaDConditionModel(
  							    block_out_channels=(32, 64),						layers_per_block=2,						sample_size=32,						in_channels=9,						out_channels=4,						down_block_types=("DownBlock2D", "CrossAttnDownBlock2D"),						up_block_types=("CrossAttnUpBlock2D", "UpBlock2D"),						cross_attention_dim=32,						)
  							torch.manual_seed(0				)
  							_snake_case			 = ControlNetModel(
  							    block_out_channels=(32, 64),						layers_per_block=2,						in_channels=4,						down_block_types=("DownBlock2D", "CrossAttnDownBlock2D"),						cross_attention_dim=32,						conditioning_embedding_out_channels=(16, 32),						)
  							torch.manual_seed(0				)
  							_snake_case			 = DDIMScheduler(
  							    beta_start=0.0_00_85,						beta_end=0.0_12,						beta_schedule="scaled_linear",						clip_sample=__UpperCamelCase,						set_alpha_to_one=__UpperCamelCase,						)
  							torch.manual_seed(0				)
  							_snake_case			 = AutoencoderKL(
  							    block_out_channels=[32, 64],						in_channels=3,						out_channels=3,						down_block_types=["DownEncoderBlock2D", "DownEncoderBlock2D"],						up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D"],						latent_channels=4,						)
  							torch.manual_seed(0				)
  							_snake_case			 = CLIPTextConfig(
  							    bos_token_id=0,						eos_token_id=2,						hidden_size=32,						intermediate_size=37,						layer_norm_eps=1E-05,						num_attention_heads=4,						num_hidden_layers=5,						pad_token_id=1,						vocab_size=1_000,						)
  							_snake_case			 = CLIPTextModel(__UpperCamelCase				)
  							_snake_case			 = CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"				)
  
  							_snake_case			 = {
  							    "unet": unet,
  							    "controlnet": controlnet,
  							    "scheduler": scheduler,
  							    "vae": vae,
  							    "text_encoder": text_encoder,
  							    "tokenizer": tokenizer,
  							    "safety_checker": None,
  							    "feature_extractor": None,
  							}
  							return components
  
  
  
  
  
  
  					def        __SCREAMING_SNAKE_CASE			(					self,						__UpperCamelCase,						__UpperCamelCase=0				):
  							if str(__UpperCamelCase				).startswith("mps"				):
  									_snake_case			 = torch.manual_seed(__UpperCamelCase				)
  							else:
  									_snake_case			 = torch.Generator(device=__UpperCamelCase				).manual_seed(__UpperCamelCase				)
  
  							_snake_case			 = 2
  							_snake_case			 = randn_tensor(
  							    (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor),						generator=__UpperCamelCase,						device=torch.device(__UpperCamelCase				),						)
  							_snake_case			 = floats_tensor((1, 3, 32, 32),						rng=random.Random(__UpperCamelCase				)				).to(__UpperCamelCase				)
  							_snake_case			 = init_image.cpu().permute(0,						2,						3,						1				)[0]
  
  							_snake_case			 = Image.fromarray(np.uinta(__UpperCamelCase				)				).convert("RGB"				).resize((64, 64)				)
  							_snake_case			 = Image.fromarray(np.uinta(init_image + 4				)				).convert("RGB"				).resize((64, 64)				)
  
  							_snake_case			 = {
  							    "prompt": "A painting of a squirrel eating a burger",
  							    "generator": generator,
  							    "num_inference_steps": 2,
  							    "guidance_scale": 6.0,
  							    "output_type": "numpy",
  							    "image": image,
  							    "mask_image": mask_image,
  							    "control_image": control_image,
  							}
  
  							return inputs
  
  
  
  
  
  
  					def        __SCREAMING_SNAKE_CASE			(					self				):
  							return self._test_attention_slicing_forward_pass(expected_max_diff=2E-3				)
  
  
  
  
  
  
  					@unittest.skipIf(
  					    torch_device != "cuda" or not is_xformers_available(),						reason="XFormers attention is only available with CUDA and `xformers` installed",						)
  					def        __SCREAMING_SNAKE_CASE			(					self				):
  							self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2E-3				)
  
  
  
  
  
  
  					def        __SCREAMING_SNAKE_CASE			(					self				):
  							self._test_inference_batch_single_identical(expected_max_diff=2E-3				)
  
  
  
  
  
  class   lowerCamelCase_							( UpperCAmelCase_							):
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  					lowercase__					=				StableDiffusionControlNetInpaintPipeline
  					lowercase__					=				TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
  					lowercase__					=				TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
  					lowercase__					=				frozenset([]							)
  
  
  
  
  
  
  					def        __SCREAMING_SNAKE_CASE			(					self				):
  							torch.manual_seed(0				)
  							_snake_case			 = UNetaDConditionModel(
  							    block_out_channels=(32, 64),						layers_per_block=2,						sample_size=32,						in_channels=4,						out_channels=4,						down_block_types=("DownBlock2D", "CrossAttnDownBlock2D"),						up_block_types=("CrossAttnUpBlock2D", "UpBlock2D"),						cross_attention_dim=32,						)
  							torch.manual_seed(0				)
  							_snake_case			 = ControlNetModel(
  							    block_out_channels=(32, 64),						layers_per_block=2,						in_channels=4,						down_block_types=("DownBlock2D", "CrossAttnDownBlock2D"),						cross_attention_dim=32,						conditioning_embedding_out_channels=(16, 32),						)
  							torch.manual_seed(0				)
  							_snake_case			 = DDIMScheduler(
  							    beta_start=0.0_00_85,						beta_end=0.0_12,						beta_schedule="scaled_linear",						clip_sample=__UpperCamelCase,						set_alpha_to_one=__UpperCamelCase,						)
  							torch.manual_seed(0				)
  							_snake_case			 = AutoencoderKL(
  							    block_out_channels=[32, 64],						in_channels=3,						out_channels=3,						down_block_types=["DownEncoderBlock2D", "DownEncoderBlock2D"],						up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D"],						latent_channels=4,						)
  							torch.manual_seed(0				)
  							_snake_case			 = CLIPTextConfig(
  							    bos_token_id=0,						eos_token_id=2,						hidden_size=32,						intermediate_size=37,						layer_norm_eps=1E-05,						num_attention_heads=4,						num_hidden_layers=5,						pad_token_id=1,						vocab_size=1_000,						)
  							_snake_case			 = CLIPTextModel(__UpperCamelCase				)
  							_snake_case			 = CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"				)
  
  							_snake_case			 = {
  							    "unet": unet,
  							    "controlnet": controlnet,
  							    "scheduler": scheduler,
  							    "vae": vae,
  							    "text_encoder": text_encoder,
  							    "tokenizer": tokenizer,
  							    "safety_checker": None,
  							    "feature_extractor": None,
  							}
  							return components
  
  
  
  
  
  class   lowerCamelCase_							( UpperCAmelCase_, UpperCAmelCase_, unittest.TestCase							):
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  					lowercase__					=				StableDiffusionControlNetInpaintPipeline
  					lowercase__					=				TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
  					lowercase__					=				TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
  
  
  
  
  
  
  					def        __SCREAMING_SNAKE_CASE			(					self				):
  							torch.manual_seed(0				)
  							_snake_case			 = UNetaDConditionModel(
  							    block_out_channels=(32, 64),						layers_per_block=2,						sample_size=32,						in_channels=9,						out_channels=4,						down_block_types=("DownBlock2D", "CrossAttnDownBlock2D"),						up_block_types=("CrossAttnUpBlock2D", "UpBlock2D"),						cross_attention_dim=32,						)
  							torch.manual_seed(0				)
  
  							def init_weights(__UpperCamelCase				):
  									if isinstance(__UpperCamelCase,						torch.nn.Convad				):
  											torch.nn.init.normal(m.weight				)
  											m.bias.data.fill_(1.0				)
  
  							_snake_case			 = ControlNetModel(
  							    block_out_channels=(32, 64),						layers_per_block=2,						in_channels=4,						down_block_types=("DownBlock2D", "CrossAttnDownBlock2D"),						cross_attention_dim=32,						conditioning_embedding_out_channels=(16, 32),						)
  							controlneta.controlnet_down_blocks.apply(__UpperCamelCase				)
  
  							torch.manual_seed(0				)
  							_snake_case			 = ControlNetModel(
  							    block_out_channels=(32, 64),						layers_per_block=2,						in_channels=4,						down_block_types=("DownBlock2D", "CrossAttnDownBlock2D"),						cross_attention_dim=32,						conditioning_embedding_out_channels=(16, 32),						)
  							controlneta.controlnet_down_blocks.apply(__UpperCamelCase				)
  
  							torch.manual_seed(0				)
  							_snake_case			 = DDIMScheduler(
  							    beta_start=0.0_00_85,						beta_end=0.0_12,						beta_schedule="scaled_linear",						clip_sample=__UpperCamelCase,						set_alpha_to_one=__UpperCamelCase,						)
  							torch.manual_seed(0				)
  							_snake_case			 = AutoencoderKL(
  							    block_out_channels=[32, 64],						in_channels=3,						out_channels=3,						down_block_types=["DownEncoderBlock2D", "DownEncoderBlock2D"],						up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D"],						latent_channels=4,						)
  							torch.manual_seed(0				)
  							_snake_case			 = CLIPTextConfig(
  							    bos_token_id=0,						eos_token_id=2,						hidden_size=32,						intermediate_size=37,						layer_norm_eps=1E-05,						num_attention_heads=4,						num_hidden_layers=5,						pad_token_id=1,						vocab_size=1_000,						)
  							_snake_case			 = CLIPTextModel(__UpperCamelCase				)
  							_snake_case			 = CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"				)
  
  							_snake_case			 = MultiControlNetModel([controlneta, controlneta]				)
  
  							_snake_case			 = {
  							    "unet": unet,
  							    "controlnet": controlnet,
  							    "scheduler": scheduler,
  							    "vae": vae,
  							    "text_encoder": text_encoder,
  							    "tokenizer": tokenizer,
  							    "safety_checker": None,
  							    "feature_extractor": None,
  							}
  							return components
  
  
  
  
  
  
  					def        __SCREAMING_SNAKE_CASE			(					self,						__UpperCamelCase,						__UpperCamelCase=0				):
  							if str(__UpperCamelCase				).startswith("mps"				):
  									_snake_case			 = torch.manual_seed(__UpperCamelCase				)
  							else:
  									_snake_case			 = torch.Generator(device=__UpperCamelCase				).manual_seed(__UpperCamelCase				)
  
  							_snake_case			 = 2
  
  							_snake_case			 = [
  							    randn_tensor(
  							        (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor),						generator=__UpperCamelCase,						device=torch.device(__UpperCamelCase				),						),
  							    randn_tensor(
  							        (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor),						generator=__UpperCamelCase,						device=torch.device(__UpperCamelCase				),						),
  							]
  							_snake_case			 = floats_tensor((1, 3, 32, 32),						rng=random.Random(__UpperCamelCase				)				).to(__UpperCamelCase				)
  							_snake_case			 = init_image.cpu().permute(0,						2,						3,						1				)[0]
  
  							_snake_case			 = Image.fromarray(np.uinta(__UpperCamelCase				)				).convert("RGB"				).resize((64, 64)				)
  							_snake_case			 = Image.fromarray(np.uinta(init_image + 4				)				).convert("RGB"				).resize((64, 64)				)
  
  							_snake_case			 = {
  							    "prompt": "A painting of a squirrel eating a burger",
  							    "generator": generator,
  							    "num_inference_steps": 2,
  							    "guidance_scale": 6.0,
  							    "output_type": "numpy",
  							    "image": image,
  							    "mask_image": mask_image,
  							    "control_image": control_image,
  							}
  
  							return inputs
  
  
  
  
  
  
  					def        __SCREAMING_SNAKE_CASE			(					self				):
  							_snake_case			 = self.get_dummy_components()
  							_snake_case			 = self.pipeline_class(**__UpperCamelCase				)
  							pipe.to(__UpperCamelCase				)
  
  							_snake_case			 = 10.0
  							_snake_case			 = 4
  
  							_snake_case			 = self.get_dummy_inputs(__UpperCamelCase				)
  							_snake_case			 = steps
  							_snake_case			 = scale
  							_snake_case			 = pipe(**__UpperCamelCase				)[0]
  
  							_snake_case			 = self.get_dummy_inputs(__UpperCamelCase				)
  							_snake_case			 = steps
  							_snake_case			 = scale
  							_snake_case			 = pipe(**__UpperCamelCase,						control_guidance_start=0.1,						control_guidance_end=0.2				)[0]
  
  							_snake_case			 = self.get_dummy_inputs(__UpperCamelCase				)
  							_snake_case			 = steps
  							_snake_case			 = scale
  							_snake_case			 = pipe(**__UpperCamelCase,						control_guidance_start=[0.1, 0.3],						control_guidance_end=[0.2, 0.7]				)[0]
  
  							_snake_case			 = self.get_dummy_inputs(__UpperCamelCase				)
  							_snake_case			 = steps
  							_snake_case			 = scale
  							_snake_case			 = pipe(**__UpperCamelCase,						control_guidance_start=0.4,						control_guidance_end=[0.5, 0.8]				)[0]
  
  							# make sure that all outputs are different
  							assert np.sum(np.abs(output_a - output_a				)				) > 1E-3
  							assert np.sum(np.abs(output_a - output_a				)				) > 1E-3
  							assert np.sum(np.abs(output_a - output_a				)				) > 1E-3
  
  
  
  
  
  
  					def        __SCREAMING_SNAKE_CASE			(					self				):
  							return self._test_attention_slicing_forward_pass(expected_max_diff=2E-3				)
  
  
  
  
  
  
  					@unittest.skipIf(
  					    torch_device != "cuda" or not is_xformers_available(),						reason="XFormers attention is only available with CUDA and `xformers` installed",						)
  					def        __SCREAMING_SNAKE_CASE			(					self				):
  							self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2E-3				)
  
  
  
  
  
  
  					def        __SCREAMING_SNAKE_CASE			(					self				):
  							self._test_inference_batch_single_identical(expected_max_diff=2E-3				)
  
  
  
  
  
  
  					def        __SCREAMING_SNAKE_CASE			(					self				):
  							_snake_case			 = self.get_dummy_components()
  							_snake_case			 = self.pipeline_class(**__UpperCamelCase				)
  							pipe.to(__UpperCamelCase				)
  							pipe.set_progress_bar_config(disable=__UpperCamelCase				)
  							with tempfile.TemporaryDirectory() as tmpdir:
  									try:
  											# save_pretrained is not implemented for Multi-ControlNet
  											pipe.save_pretrained(__UpperCamelCase				)
  									except NotImplementedError:
  											pass
  
  
  
  
  
  @slow
  @require_torch_gpu
  class   lowerCamelCase_							( unittest.TestCase							):
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  					def        __SCREAMING_SNAKE_CASE			(					self				):
  							super().tearDown()
  							gc.collect()
  							torch.cuda.empty_cache()
  
  
  
  
  
  
  					def        __SCREAMING_SNAKE_CASE			(					self				):
  							_snake_case			 = ControlNetModel.from_pretrained("lllyasviel/sd-controlnet-canny"				)
  
  							_snake_case			 = StableDiffusionControlNetInpaintPipeline.from_pretrained(
  							    "runwayml/stable-diffusion-inpainting",						safety_checker=__UpperCamelCase,						controlnet=__UpperCamelCase				)
  							pipe.enable_model_cpu_offload()
  							pipe.set_progress_bar_config(disable=__UpperCamelCase				)
  
  							_snake_case			 = torch.Generator(device="cpu"				).manual_seed(0				)
  							_snake_case			 = load_image(
  							    "https://huggingface.co/lllyasviel/sd-controlnet-canny/resolve/main/images/bird.png"				).resize((512, 512)				)
  
  							_snake_case			 = load_image(
  							    "https://huggingface.co/datasets/diffusers/test-arrays/resolve/main"
  							    "/stable_diffusion_inpaint/input_bench_mask.png"				).resize((512, 512)				)
  
  							_snake_case			 = "pitch black hole"
  
  							_snake_case			 = load_image(
  							    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/bird_canny.png"				).resize((512, 512)				)
  
  							_snake_case			 = pipe(
  							    __UpperCamelCase,						image=__UpperCamelCase,						mask_image=__UpperCamelCase,						control_image=__UpperCamelCase,						generator=__UpperCamelCase,						output_type="np",						num_inference_steps=3,						)
  
  							_snake_case			 = output.images[0]
  
  							assert image.shape == (512, 512, 3)
  
  							_snake_case			 = load_numpy(
  							    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/inpaint.npy"				)
  
  							assert np.abs(expected_image - image				).max() < 9E-2
  
  
  
  
  
  
  					def        __SCREAMING_SNAKE_CASE			(					self				):
  							_snake_case			 = ControlNetModel.from_pretrained("lllyasviel/control_v11p_sd15_inpaint"				)
  
  							_snake_case			 = StableDiffusionControlNetInpaintPipeline.from_pretrained(
  							    "runwayml/stable-diffusion-v1-5",						safety_checker=__UpperCamelCase,						controlnet=__UpperCamelCase				)
  							_snake_case			 = DDIMScheduler.from_config(pipe.scheduler.config				)
  							pipe.enable_model_cpu_offload()
  							pipe.set_progress_bar_config(disable=__UpperCamelCase				)
  
  							_snake_case			 = torch.Generator(device="cpu"				).manual_seed(33				)
  
  							_snake_case			 = load_image(
  							    "https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/stable_diffusion_inpaint/boy.png"				)
  							_snake_case			 = init_image.resize((512, 512)				)
  
  							_snake_case			 = load_image(
  							    "https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/stable_diffusion_inpaint/boy_mask.png"				)
  							_snake_case			 = mask_image.resize((512, 512)				)
  
  							_snake_case			 = "a handsome man with ray-ban sunglasses"
  
  							def make_inpaint_condition(__UpperCamelCase,						__UpperCamelCase				):
  									_snake_case			 = np.array(image.convert("RGB"				)				).astype(np.floataa				) / 2_55.0
  									_snake_case			 = np.array(image_mask.convert("L"				)				).astype(np.floataa				) / 2_55.0
  
  									assert image.shape[0:1] == image_mask.shape[0:1], "image and image_mask must have the same image size"
  									_snake_case			 = -1.0  # set as masked pixel
  									_snake_case			 = np.expand_dims(__UpperCamelCase,						0				).transpose(0,						3,						1,						2				)
  									_snake_case			 = torch.from_numpy(__UpperCamelCase				)
  									return image
  
  							_snake_case			 = make_inpaint_condition(__UpperCamelCase,						__UpperCamelCase				)
  
  							_snake_case			 = pipe(
  							    __UpperCamelCase,						image=__UpperCamelCase,						mask_image=__UpperCamelCase,						control_image=__UpperCamelCase,						guidance_scale=9.0,						eta=1.0,						generator=__UpperCamelCase,						num_inference_steps=20,						output_type="np",						)
  							_snake_case			 = output.images[0]
  
  							assert image.shape == (512, 512, 3)
  
  							_snake_case			 = load_numpy(
  							    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/boy_ray_ban.npy"				)
  
  							assert np.abs(expected_image - image				).max() < 9E-2
  
  
  
  
  
  
style_context: 
  
  
  
  
  '''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
  
  						_lowerCamelCase							:		int										=						True
  except ImportError:
  						_lowerCamelCase							:		List[str]										=						False
  
  
  # Cache this result has it's a C FFI call which can be pretty time-consuming
  _lowerCamelCase							:		List[Any]										=						torch.distributed.is_available()
  
  
  
  
  
  
  def 	_lowercase	(			lowercase_						):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		_snake_case			 = importlib.util.find_spec(lowercase_						) is not None
  		if package_exists:
  				try:
  						_snake_case			 = importlib.metadata.metadata(lowercase_						)
  						return True
  				except importlib.metadata.PackageNotFoundError:
  						return False
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return _torch_distributed_available
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''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	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return importlib.metadata.version("oneccl_bind_pt"						)
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return _is_package_available("transformer_engine"						)
  
  
  
  
  
  
  @lru_cache
  def 	_lowercase	(			lowercase_=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
  						_snake_case			 = xm.xla_device()
  						return True
  				except RuntimeError:
  						return False
  		return _tpu_available
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return _is_package_available("deepspeed"						)
  
  
  
  
  
  
  def 	_lowercase	(			lowercase_=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 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		_snake_case			 = _is_package_available("bitsandbytes"						)
  		if package_exists:
  				_snake_case			 = version.parse(importlib.metadata.version("bitsandbytes"						)						)
  				return compare_versions(lowercase_		,							">="		,							"0.39.0"						)
  		return False
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		_snake_case			 = _is_package_available("bitsandbytes"						)
  		if package_exists:
  				_snake_case			 = version.parse(importlib.metadata.version("bitsandbytes"						)						)
  				return compare_versions(lowercase_		,							">="		,							"0.37.2"						)
  		return False
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return _is_package_available("bitsandbytes"						)
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		if strtobool(os.environ.get("ACCELERATE_USE_MEGATRON_LM"		,							"False"						)						) == 1:
  				_snake_case			 = importlib.util.find_spec("megatron"						) is not None
  				if package_exists:
  						try:
  								_snake_case			 = 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 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return _is_package_available("safetensors"						)
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return _is_package_available("transformers"						)
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return _is_package_available("datasets"						)
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return _is_package_available("aim"						)
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return _is_package_available("tensorboard"						) or _is_package_available("tensorboardX"						)
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return _is_package_available("wandb"						)
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return _is_package_available("comet_ml"						)
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return _is_package_available("boto3"						)
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''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"		,							lowercase_						)
  				return parse_flag_from_env("ACCELERATE_ENABLE_RICH"		,							lowercase_						)
  		return False
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return _is_package_available("sagemaker"						)
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return _is_package_available("tqdm"						)
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return _is_package_available("mlflow"						)
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return is_torch_version(">="		,							"1.12"						) and torch.backends.mps.is_available() and torch.backends.mps.is_built()
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		def get_major_and_minor_from_version(lowercase_						):
  				return str(version.parse(lowercase_						).major						) + "." + str(version.parse(lowercase_						).minor						)
  
  		_snake_case			 = importlib.metadata.version("torch"						)
  		if importlib.util.find_spec("intel_extension_for_pytorch"						) is None:
  				return False
  		_snake_case			 = "N/A"
  		try:
  				_snake_case			 = importlib.metadata.version("intel_extension_for_pytorch"						)
  		except importlib.metadata.PackageNotFoundError:
  				return False
  		_snake_case			 = get_major_and_minor_from_version(_torch_version						)
  		_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	(			lowercase_=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
  						_snake_case			 = 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 	_lowercase	(			lowercase_=False						):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		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
  						_snake_case			 = torch.xpu.device_count()
  						return torch.xpu.is_available()
  				except RuntimeError:
  						return False
  		return hasattr(lowercase_		,							"xpu"						) and torch.xpu.is_available()
  
  
  
  
  
  