code: 
  
  
  '''simple docstring'''
  
  
  
  
  
  import importlib
  import os
  import platform
  from pathlib import Path
  
  from packaging import version
  
  from .utils.logging import get_logger
  
  
  UpperCAmelCase__      =							get_logger(__name__)
  
  # Datasets
  UpperCAmelCase__      =							'''https://s3.amazonaws.com/datasets.huggingface.co/datasets/datasets'''
  UpperCAmelCase__      =							'''https://cdn-datasets.huggingface.co/datasets/datasets'''
  UpperCAmelCase__      =							'''https://raw.githubusercontent.com/huggingface/datasets/{revision}/datasets/{path}/{name}'''
  
  # Metrics
  UpperCAmelCase__      =							'''https://s3.amazonaws.com/datasets.huggingface.co/datasets/metrics'''
  UpperCAmelCase__      =							'''https://cdn-datasets.huggingface.co/datasets/metric'''
  UpperCAmelCase__      =							'''https://raw.githubusercontent.com/huggingface/datasets/{revision}/metrics/{path}/{name}'''
  
  # Hub
  UpperCAmelCase__      =							os.environ.get('''HF_ENDPOINT''', '''https://huggingface.co''')
  UpperCAmelCase__      =							HF_ENDPOINT + '''/datasets/{repo_id}/resolve/{revision}/{path}'''
  UpperCAmelCase__      =							'''main'''
  
  UpperCAmelCase__      =							version.parse(platform.python_version())
  
  if PY_VERSION < version.parse('''3.8'''):
  					import importlib_metadata
  else:
  					import importlib.metadata as importlib_metadata
  
  # General environment variables accepted values for booleans
  UpperCAmelCase__      =							{'''1''', '''ON''', '''YES''', '''TRUE'''}
  UpperCAmelCase__      =							ENV_VARS_TRUE_VALUES.union({'''AUTO'''})
  
  
  # Imports
  UpperCAmelCase__      =							version.parse(importlib_metadata.version('''dill'''))
  UpperCAmelCase__      =							version.parse(importlib_metadata.version('''pandas'''))
  UpperCAmelCase__      =							version.parse(importlib_metadata.version('''pyarrow'''))
  
  UpperCAmelCase__      =							os.environ.get('''USE_TF''', '''AUTO''').upper()
  UpperCAmelCase__      =							os.environ.get('''USE_TORCH''', '''AUTO''').upper()
  UpperCAmelCase__      =							os.environ.get('''USE_JAX''', '''AUTO''').upper()
  
  UpperCAmelCase__      =							'''N/A'''
  UpperCAmelCase__      =							False
  
  if USE_TORCH in ENV_VARS_TRUE_AND_AUTO_VALUES and USE_TF not in ENV_VARS_TRUE_VALUES:
  					UpperCAmelCase__      =							importlib.util.find_spec('''torch''') is not None
  					if TORCH_AVAILABLE:
  										try:
  															UpperCAmelCase__      =							version.parse(importlib_metadata.version('''torch'''))
  															logger.info(F"""PyTorch version {TORCH_VERSION} available.""")
  										except importlib_metadata.PackageNotFoundError:
  															pass
  else:
  					logger.info('''Disabling PyTorch because USE_TF is set''')
  
  UpperCAmelCase__      =							'''N/A'''
  UpperCAmelCase__      =							False
  
  if USE_TF in ENV_VARS_TRUE_AND_AUTO_VALUES and USE_TORCH not in ENV_VARS_TRUE_VALUES:
  					UpperCAmelCase__      =							importlib.util.find_spec('''tensorflow''') is not None
  					if TF_AVAILABLE:
  										# For the metadata, we have to look for both tensorflow and tensorflow-cpu
  										for package in [
  										    "tensorflow",
  										    "tensorflow-cpu",
  										    "tensorflow-gpu",
  										    "tf-nightly",
  										    "tf-nightly-cpu",
  										    "tf-nightly-gpu",
  										    "intel-tensorflow",
  										    "tensorflow-rocm",
  										    "tensorflow-macos",
  										]:
  															try:
  																				UpperCAmelCase__      =							version.parse(importlib_metadata.version(package))
  															except importlib_metadata.PackageNotFoundError:
  																				continue
  															else:
  																				break
  										else:
  															UpperCAmelCase__      =							False
  					if TF_AVAILABLE:
  										if TF_VERSION.major < 2:
  															logger.info(F"""TensorFlow found but with version {TF_VERSION}. `datasets` requires version 2 minimum.""")
  															UpperCAmelCase__      =							False
  										else:
  															logger.info(F"""TensorFlow version {TF_VERSION} available.""")
  else:
  					logger.info('''Disabling Tensorflow because USE_TORCH is set''')
  
  
  UpperCAmelCase__      =							'''N/A'''
  UpperCAmelCase__      =							False
  
  if USE_JAX in ENV_VARS_TRUE_AND_AUTO_VALUES:
  					UpperCAmelCase__      =							importlib.util.find_spec('''jax''') is not None and importlib.util.find_spec('''jaxlib''') is not None
  					if JAX_AVAILABLE:
  										try:
  															UpperCAmelCase__      =							version.parse(importlib_metadata.version('''jax'''))
  															logger.info(F"""JAX version {JAX_VERSION} available.""")
  										except importlib_metadata.PackageNotFoundError:
  															pass
  else:
  					logger.info('''Disabling JAX because USE_JAX is set to False''')
  
  
  UpperCAmelCase__      =							os.environ.get('''USE_BEAM''', '''AUTO''').upper()
  UpperCAmelCase__      =							'''N/A'''
  UpperCAmelCase__      =							False
  if USE_BEAM in ENV_VARS_TRUE_AND_AUTO_VALUES:
  					try:
  										UpperCAmelCase__      =							version.parse(importlib_metadata.version('''apache_beam'''))
  										UpperCAmelCase__      =							True
  										logger.info(F"""Apache Beam version {BEAM_VERSION} available.""")
  					except importlib_metadata.PackageNotFoundError:
  										pass
  else:
  					logger.info('''Disabling Apache Beam because USE_BEAM is set to False''')
  
  
  # Optional tools for data loading
  UpperCAmelCase__      =							importlib.util.find_spec('''sqlalchemy''') is not None
  
  # Optional tools for feature decoding
  UpperCAmelCase__      =							importlib.util.find_spec('''PIL''') is not None
  UpperCAmelCase__      =							importlib.util.find_spec('''soundfile''') is not None and version.parse(
      importlib.import_module('''soundfile''').__libsndfile_version__
  ) >= version.parse('''1.0.31''')
  UpperCAmelCase__      =							importlib.util.find_spec('''soundfile''') is not None and version.parse(
      importlib.import_module('''soundfile''').__libsndfile_version__
  ) >= version.parse('''1.1.0''')
  
  # Optional compression tools
  UpperCAmelCase__      =							importlib.util.find_spec('''rarfile''') is not None
  UpperCAmelCase__      =							importlib.util.find_spec('''zstandard''') is not None
  UpperCAmelCase__      =							importlib.util.find_spec('''lz4''') is not None
  UpperCAmelCase__      =							importlib.util.find_spec('''py7zr''') is not None
  
  
  # Cache location
  UpperCAmelCase__      =							'''~/.cache'''
  UpperCAmelCase__      =							os.getenv('''XDG_CACHE_HOME''', DEFAULT_XDG_CACHE_HOME)
  UpperCAmelCase__      =							os.path.join(XDG_CACHE_HOME, '''huggingface''')
  UpperCAmelCase__      =							os.path.expanduser(os.getenv('''HF_HOME''', DEFAULT_HF_CACHE_HOME))
  
  UpperCAmelCase__      =							os.path.join(HF_CACHE_HOME, '''datasets''')
  UpperCAmelCase__      =							Path(os.getenv('''HF_DATASETS_CACHE''', DEFAULT_HF_DATASETS_CACHE))
  
  UpperCAmelCase__      =							os.path.join(HF_CACHE_HOME, '''metrics''')
  UpperCAmelCase__      =							Path(os.getenv('''HF_METRICS_CACHE''', DEFAULT_HF_METRICS_CACHE))
  
  UpperCAmelCase__      =							os.path.join(HF_CACHE_HOME, '''modules''')
  UpperCAmelCase__      =							Path(os.getenv('''HF_MODULES_CACHE''', DEFAULT_HF_MODULES_CACHE))
  
  UpperCAmelCase__      =							'''downloads'''
  UpperCAmelCase__      =							os.path.join(HF_DATASETS_CACHE, DOWNLOADED_DATASETS_DIR)
  UpperCAmelCase__      =							Path(os.getenv('''HF_DATASETS_DOWNLOADED_DATASETS_PATH''', DEFAULT_DOWNLOADED_DATASETS_PATH))
  
  UpperCAmelCase__      =							'''extracted'''
  UpperCAmelCase__      =							os.path.join(DEFAULT_DOWNLOADED_DATASETS_PATH, EXTRACTED_DATASETS_DIR)
  UpperCAmelCase__      =							Path(os.getenv('''HF_DATASETS_EXTRACTED_DATASETS_PATH''', DEFAULT_EXTRACTED_DATASETS_PATH))
  
  # Download count for the website
  UpperCAmelCase__      =							(
      os.environ.get('''HF_UPDATE_DOWNLOAD_COUNTS''', '''AUTO''').upper() in ENV_VARS_TRUE_AND_AUTO_VALUES
  )
  
  # Batch size constants. For more info, see:
  # https://github.com/apache/arrow/blob/master/docs/source/cpp/arrays.rst#size-limitations-and-recommendations)
  UpperCAmelCase__      =							1_0_0_0
  
  # Size of the preloaded record batch in `Dataset.__iter__`
  UpperCAmelCase__      =							1_0
  
  # Pickling tables works only for small tables (<4GiB)
  # For big tables, we write them on disk instead
  UpperCAmelCase__      =							4 << 3_0
  
  # Max shard size in bytes (e.g. to shard parquet datasets in push_to_hub or download_and_prepare)
  UpperCAmelCase__      =							'''500MB'''
  
  # Parquet configuration
  UpperCAmelCase__      =							1_0_0
  UpperCAmelCase__      =							1_0_0
  UpperCAmelCase__      =							1_0_0
  
  # Offline mode
  UpperCAmelCase__      =							os.environ.get('''HF_DATASETS_OFFLINE''', '''AUTO''').upper() in ENV_VARS_TRUE_VALUES
  
  # In-memory
  UpperCAmelCase__      =							0  # Disabled
  UpperCAmelCase__      =							float(os.environ.get('''HF_DATASETS_IN_MEMORY_MAX_SIZE''', DEFAULT_IN_MEMORY_MAX_SIZE))
  
  # File names
  UpperCAmelCase__      =							'''dataset.arrow'''
  UpperCAmelCase__      =							'''indices.arrow'''
  UpperCAmelCase__      =							'''state.json'''
  UpperCAmelCase__      =							'''dataset_info.json'''
  UpperCAmelCase__      =							'''dataset_infos.json'''
  UpperCAmelCase__      =							'''LICENSE'''
  UpperCAmelCase__      =							'''metric_info.json'''
  UpperCAmelCase__      =							'''dataset_dict.json'''
  
  UpperCAmelCase__      =							'''datasets_modules'''
  
  UpperCAmelCase__      =							2_5_5
  
  # Streaming
  UpperCAmelCase__      =							2_0
  UpperCAmelCase__      =							5
  
  # Datasets without script
  UpperCAmelCase__      =							2_0_0
  UpperCAmelCase__      =							1_0
  UpperCAmelCase__      =							2_0_0
  
  # Progress bars
  UpperCAmelCase__      =							0.05  # 20 progress updates per sec
  
  
  
  
style_context: 
  
  
  '''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 	a__				(				a_			,     a_			,     a_			,     unittest.TestCase      ):
  
  
  
  
  
  			'''simple docstring'''
  
  			A	:							Optional[int]							= StableDiffusionControlNetInpaintPipeline
  			A	:							List[str]							= TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
  			A	:							List[Any]							= TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
  			A	:							Any							= frozenset({'''control_image'''}      )  # skip `image` and `mask` for now, only test for control_image
  			A	:							List[Any]							= TEXT_TO_IMAGE_IMAGE_PARAMS
  			def 				lowerCAmelCase    (     self       : Tuple  )			->		List[str]:
  						torch.manual_seed(0  )
  						__A=  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  )
  						__A=  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  )
  						__A=  DDIMScheduler(
  						    beta_start=0.0_00_85 ,						beta_end=0.0_12 ,						beta_schedule='scaled_linear' ,						clip_sample=lowerCAmelCase_ ,						set_alpha_to_one=lowerCAmelCase_ ,						)
  						torch.manual_seed(0  )
  						__A=  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  )
  						__A=  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 ,						)
  						__A=  CLIPTextModel(lowerCAmelCase_  )
  						__A=  CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'  )
  
  						__A=  {
  						    'unet': unet,
  						    'controlnet': controlnet,
  						    'scheduler': scheduler,
  						    'vae': vae,
  						    'text_encoder': text_encoder,
  						    'tokenizer': tokenizer,
  						    'safety_checker': None,
  						    'feature_extractor': None,
  						}
  						return components
  			def 				lowerCAmelCase    (     self       : List[str] ,						lowerCAmelCase_       : List[Any] ,						lowerCAmelCase_       : int=0  )			->		str:
  						if str(lowerCAmelCase_  ).startswith('mps'  ):
  									__A=  torch.manual_seed(lowerCAmelCase_  )
  						else:
  									__A=  torch.Generator(device=lowerCAmelCase_  ).manual_seed(lowerCAmelCase_  )
  
  						__A=  2
  						__A=  randn_tensor(
  						    (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor) ,						generator=lowerCAmelCase_ ,						device=torch.device(lowerCAmelCase_  ) ,						)
  						__A=  floats_tensor((1, 3, 32, 32) ,						rng=random.Random(lowerCAmelCase_  )  ).to(lowerCAmelCase_  )
  						__A=  init_image.cpu().permute(0 ,						2 ,						3 ,						1  )[0]
  
  						__A=  Image.fromarray(np.uinta(lowerCAmelCase_  )  ).convert('RGB'  ).resize((64, 64)  )
  						__A=  Image.fromarray(np.uinta(init_image + 4  )  ).convert('RGB'  ).resize((64, 64)  )
  
  						__A=  {
  						    '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 				lowerCAmelCase    (     self       : Tuple  )			->		Optional[int]:
  						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 				lowerCAmelCase    (     self       : Optional[int]  )			->		str:
  						self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2E-3  )
  
  			def 				lowerCAmelCase    (     self       : List[Any]  )			->		str:
  						self._test_inference_batch_single_identical(expected_max_diff=2E-3  )
  
  
  class 	a__				(				a_      ):
  
  
  
  
  
  			'''simple docstring'''
  
  			A	:							int							= StableDiffusionControlNetInpaintPipeline
  			A	:							List[str]							= TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
  			A	:							Tuple							= TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
  			A	:							int							= frozenset([]      )
  			def 				lowerCAmelCase    (     self       : int  )			->		List[Any]:
  						torch.manual_seed(0  )
  						__A=  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  )
  						__A=  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  )
  						__A=  DDIMScheduler(
  						    beta_start=0.0_00_85 ,						beta_end=0.0_12 ,						beta_schedule='scaled_linear' ,						clip_sample=lowerCAmelCase_ ,						set_alpha_to_one=lowerCAmelCase_ ,						)
  						torch.manual_seed(0  )
  						__A=  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  )
  						__A=  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 ,						)
  						__A=  CLIPTextModel(lowerCAmelCase_  )
  						__A=  CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'  )
  
  						__A=  {
  						    'unet': unet,
  						    'controlnet': controlnet,
  						    'scheduler': scheduler,
  						    'vae': vae,
  						    'text_encoder': text_encoder,
  						    'tokenizer': tokenizer,
  						    'safety_checker': None,
  						    'feature_extractor': None,
  						}
  						return components
  
  
  class 	a__				(				a_			,     a_			,     unittest.TestCase      ):
  
  
  
  
  
  			'''simple docstring'''
  
  			A	:							Tuple							= StableDiffusionControlNetInpaintPipeline
  			A	:							int							= TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
  			A	:							Optional[int]							= TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
  			def 				lowerCAmelCase    (     self       : List[Any]  )			->		int:
  						torch.manual_seed(0  )
  						__A=  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(lowerCAmelCase_       : Optional[int]  ):
  									if isinstance(lowerCAmelCase_ ,						torch.nn.Convad  ):
  												torch.nn.init.normal(m.weight  )
  												m.bias.data.fill_(1.0  )
  
  						__A=  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(lowerCAmelCase_  )
  
  						torch.manual_seed(0  )
  						__A=  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(lowerCAmelCase_  )
  
  						torch.manual_seed(0  )
  						__A=  DDIMScheduler(
  						    beta_start=0.0_00_85 ,						beta_end=0.0_12 ,						beta_schedule='scaled_linear' ,						clip_sample=lowerCAmelCase_ ,						set_alpha_to_one=lowerCAmelCase_ ,						)
  						torch.manual_seed(0  )
  						__A=  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  )
  						__A=  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 ,						)
  						__A=  CLIPTextModel(lowerCAmelCase_  )
  						__A=  CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'  )
  
  						__A=  MultiControlNetModel([controlneta, controlneta]  )
  
  						__A=  {
  						    'unet': unet,
  						    'controlnet': controlnet,
  						    'scheduler': scheduler,
  						    'vae': vae,
  						    'text_encoder': text_encoder,
  						    'tokenizer': tokenizer,
  						    'safety_checker': None,
  						    'feature_extractor': None,
  						}
  						return components
  			def 				lowerCAmelCase    (     self       : Union[str, Any] ,						lowerCAmelCase_       : str ,						lowerCAmelCase_       : List[Any]=0  )			->		List[Any]:
  						if str(lowerCAmelCase_  ).startswith('mps'  ):
  									__A=  torch.manual_seed(lowerCAmelCase_  )
  						else:
  									__A=  torch.Generator(device=lowerCAmelCase_  ).manual_seed(lowerCAmelCase_  )
  
  						__A=  2
  
  						__A=  [
  						    randn_tensor(
  						        (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor) ,						generator=lowerCAmelCase_ ,						device=torch.device(lowerCAmelCase_  ) ,						),
  						    randn_tensor(
  						        (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor) ,						generator=lowerCAmelCase_ ,						device=torch.device(lowerCAmelCase_  ) ,						),
  						]
  						__A=  floats_tensor((1, 3, 32, 32) ,						rng=random.Random(lowerCAmelCase_  )  ).to(lowerCAmelCase_  )
  						__A=  init_image.cpu().permute(0 ,						2 ,						3 ,						1  )[0]
  
  						__A=  Image.fromarray(np.uinta(lowerCAmelCase_  )  ).convert('RGB'  ).resize((64, 64)  )
  						__A=  Image.fromarray(np.uinta(init_image + 4  )  ).convert('RGB'  ).resize((64, 64)  )
  
  						__A=  {
  						    '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 				lowerCAmelCase    (     self       : Union[str, Any]  )			->		Any:
  						__A=  self.get_dummy_components()
  						__A=  self.pipeline_class(**lowerCAmelCase_  )
  						pipe.to(lowerCAmelCase_  )
  
  						__A=  10.0
  						__A=  4
  
  						__A=  self.get_dummy_inputs(lowerCAmelCase_  )
  						__A=  steps
  						__A=  scale
  						__A=  pipe(**lowerCAmelCase_  )[0]
  
  						__A=  self.get_dummy_inputs(lowerCAmelCase_  )
  						__A=  steps
  						__A=  scale
  						__A=  pipe(**lowerCAmelCase_ ,						control_guidance_start=0.1 ,						control_guidance_end=0.2  )[0]
  
  						__A=  self.get_dummy_inputs(lowerCAmelCase_  )
  						__A=  steps
  						__A=  scale
  						__A=  pipe(**lowerCAmelCase_ ,						control_guidance_start=[0.1, 0.3] ,						control_guidance_end=[0.2, 0.7]  )[0]
  
  						__A=  self.get_dummy_inputs(lowerCAmelCase_  )
  						__A=  steps
  						__A=  scale
  						__A=  pipe(**lowerCAmelCase_ ,						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 				lowerCAmelCase    (     self       : str  )			->		Any:
  						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 				lowerCAmelCase    (     self       : Any  )			->		int:
  						self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2E-3  )
  			def 				lowerCAmelCase    (     self       : Dict  )			->		Dict:
  						self._test_inference_batch_single_identical(expected_max_diff=2E-3  )
  
  			def 				lowerCAmelCase    (     self       : Union[str, Any]  )			->		Optional[int]:
  						__A=  self.get_dummy_components()
  						__A=  self.pipeline_class(**lowerCAmelCase_  )
  						pipe.to(lowerCAmelCase_  )
  						pipe.set_progress_bar_config(disable=lowerCAmelCase_  )
  						with tempfile.TemporaryDirectory() as tmpdir:
  									try:
  												# save_pretrained is not implemented for Multi-ControlNet
  												pipe.save_pretrained(lowerCAmelCase_  )
  									except NotImplementedError:
  												pass
  
  
  @slow
  @require_torch_gpu
  class 	a__				(				unittest.TestCase      ):
  
  
  
  
  
  			'''simple docstring'''
  
  			def 				lowerCAmelCase    (     self       : Optional[int]  )			->		Tuple:
  						super().tearDown()
  						gc.collect()
  						torch.cuda.empty_cache()
  			def 				lowerCAmelCase    (     self       : Union[str, Any]  )			->		Tuple:
  						__A=  ControlNetModel.from_pretrained('lllyasviel/sd-controlnet-canny'  )
  
  						__A=  StableDiffusionControlNetInpaintPipeline.from_pretrained(
  						    'runwayml/stable-diffusion-inpainting' ,						safety_checker=lowerCAmelCase_ ,						controlnet=lowerCAmelCase_  )
  						pipe.enable_model_cpu_offload()
  						pipe.set_progress_bar_config(disable=lowerCAmelCase_  )
  
  						__A=  torch.Generator(device='cpu'  ).manual_seed(0  )
  						__A=  load_image(
  						    'https://huggingface.co/lllyasviel/sd-controlnet-canny/resolve/main/images/bird.png'  ).resize((512, 512)  )
  
  						__A=  load_image(
  						    'https://huggingface.co/datasets/diffusers/test-arrays/resolve/main'
  						    '/stable_diffusion_inpaint/input_bench_mask.png'  ).resize((512, 512)  )
  
  						__A=  'pitch black hole'
  
  						__A=  load_image(
  						    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/bird_canny.png'  ).resize((512, 512)  )
  
  						__A=  pipe(
  						    lowerCAmelCase_ ,						image=lowerCAmelCase_ ,						mask_image=lowerCAmelCase_ ,						control_image=lowerCAmelCase_ ,						generator=lowerCAmelCase_ ,						output_type='np' ,						num_inference_steps=3 ,						)
  
  						__A=  output.images[0]
  
  						assert image.shape == (512, 512, 3)
  
  						__A=  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 				lowerCAmelCase    (     self       : str  )			->		Tuple:
  						__A=  ControlNetModel.from_pretrained('lllyasviel/control_v11p_sd15_inpaint'  )
  
  						__A=  StableDiffusionControlNetInpaintPipeline.from_pretrained(
  						    'runwayml/stable-diffusion-v1-5' ,						safety_checker=lowerCAmelCase_ ,						controlnet=lowerCAmelCase_  )
  						__A=  DDIMScheduler.from_config(pipe.scheduler.config  )
  						pipe.enable_model_cpu_offload()
  						pipe.set_progress_bar_config(disable=lowerCAmelCase_  )
  
  						__A=  torch.Generator(device='cpu'  ).manual_seed(33  )
  
  						__A=  load_image(
  						    'https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/stable_diffusion_inpaint/boy.png'  )
  						__A=  init_image.resize((512, 512)  )
  
  						__A=  load_image(
  						    'https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/stable_diffusion_inpaint/boy_mask.png'  )
  						__A=  mask_image.resize((512, 512)  )
  
  						__A=  'a handsome man with ray-ban sunglasses'
  
  						def make_inpaint_condition(lowerCAmelCase_       : int ,						lowerCAmelCase_       : str  ):
  									__A=  np.array(image.convert('RGB'  )  ).astype(np.floataa  ) / 2_55.0
  									__A=  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"
  									__A=  -1.0  # set as masked pixel
  									__A=  np.expand_dims(lowerCAmelCase_ ,						0  ).transpose(0 ,						3 ,						1 ,						2  )
  									__A=  torch.from_numpy(lowerCAmelCase_  )
  									return image
  
  						__A=  make_inpaint_condition(lowerCAmelCase_ ,						lowerCAmelCase_  )
  
  						__A=  pipe(
  						    lowerCAmelCase_ ,						image=lowerCAmelCase_ ,						mask_image=lowerCAmelCase_ ,						control_image=lowerCAmelCase_ ,						guidance_scale=9.0 ,						eta=1.0 ,						generator=lowerCAmelCase_ ,						num_inference_steps=20 ,						output_type='np' ,						)
  						__A=  output.images[0]
  
  						assert image.shape == (512, 512, 3)
  
  						__A=  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
  
  
  
  