code: 
  """simple docstring"""
  import gc
  import unittest
  
  import numpy as np
  import torch
  from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer
  
  from diffusers import (
      AutoencoderKL,
      DDIMScheduler,
      EulerAncestralDiscreteScheduler,
      PNDMScheduler,
      StableDiffusionModelEditingPipeline,
      UNetaDConditionModel,
  )
  from diffusers.utils import slow, torch_device
  from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu, skip_mps
  
  from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS
  from ..test_pipelines_common import PipelineKarrasSchedulerTesterMixin, PipelineLatentTesterMixin, PipelineTesterMixin
  
  
  enable_full_determinism()
  
  
  @skip_mps
  class    _lowerCAmelCase						(						lowerCamelCase    ,       lowerCamelCase    ,       lowerCamelCase    ,       unittest.TestCase						):
  							lowercase_     :     int       =							StableDiffusionModelEditingPipeline
  							lowercase_     :     List[str]       =							TEXT_TO_IMAGE_PARAMS
  							lowercase_     :     List[Any]       =							TEXT_TO_IMAGE_BATCH_PARAMS
  							lowercase_     :     List[str]       =							TEXT_TO_IMAGE_IMAGE_PARAMS
  							lowercase_     :     Tuple       =							TEXT_TO_IMAGE_IMAGE_PARAMS
  
  
  
  							def       _a   (      self   )							->							Optional[int]:
  								torch.manual_seed(0   )
  								_UpperCAmelCase =						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 ,						)
  								_UpperCAmelCase =						DDIMScheduler()
  								torch.manual_seed(0   )
  								_UpperCAmelCase =						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   )
  								_UpperCAmelCase =						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=1000 ,						)
  								_UpperCAmelCase =						CLIPTextModel(a_   )
  								_UpperCAmelCase =						CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"   )
  
  								_UpperCAmelCase =						{
  								    "unet": unet,
  								    "scheduler": scheduler,
  								    "vae": vae,
  								    "text_encoder": text_encoder,
  								    "tokenizer": tokenizer,
  								    "safety_checker": None,
  								    "feature_extractor": None,
  								}
  								return components
  
  
  
  							def       _a   (      self ,						a_ ,						a_=0   )							->							Dict:
  								_UpperCAmelCase =						torch.manual_seed(a_   )
  								_UpperCAmelCase =						{
  								    "prompt": "A field of roses",
  								    "generator": generator,
  								    # Setting height and width to None to prevent OOMs on CPU.
  								    "height": None,
  								    "width": None,
  								    "num_inference_steps": 2,
  								    "guidance_scale": 6.0,
  								    "output_type": "numpy",
  								}
  								return inputs
  
  
  
  							def       _a   (      self   )							->							Union[str, Any]:
  								_UpperCAmelCase =						"cpu"  # ensure determinism for the device-dependent torch.Generator
  								_UpperCAmelCase =						self.get_dummy_components()
  								_UpperCAmelCase =						StableDiffusionModelEditingPipeline(**a_   )
  								_UpperCAmelCase =						sd_pipe.to(a_   )
  								sd_pipe.set_progress_bar_config(disable=a_   )
  
  								_UpperCAmelCase =						self.get_dummy_inputs(a_   )
  								_UpperCAmelCase =						sd_pipe(**a_   ).images
  								_UpperCAmelCase =						image[0, -3:, -3:, -1]
  								assert image.shape == (1, 64, 64, 3)
  
  								_UpperCAmelCase =						np.array([0.4755, 0.5132, 0.4976, 0.3904, 0.3554, 0.4765, 0.5139, 0.5158, 0.4889]   )
  
  								assert np.abs(image_slice.flatten() - expected_slice   ).max() < 1e-2
  
  
  
  							def       _a   (      self   )							->							Optional[Any]:
  								_UpperCAmelCase =						"cpu"  # ensure determinism for the device-dependent torch.Generator
  								_UpperCAmelCase =						self.get_dummy_components()
  								_UpperCAmelCase =						StableDiffusionModelEditingPipeline(**a_   )
  								_UpperCAmelCase =						sd_pipe.to(a_   )
  								sd_pipe.set_progress_bar_config(disable=a_   )
  
  								_UpperCAmelCase =						self.get_dummy_inputs(a_   )
  								_UpperCAmelCase =						"french fries"
  								_UpperCAmelCase =						sd_pipe(**a_ ,						negative_prompt=a_   )
  								_UpperCAmelCase =						output.images
  								_UpperCAmelCase =						image[0, -3:, -3:, -1]
  
  								assert image.shape == (1, 64, 64, 3)
  
  								_UpperCAmelCase =						np.array([0.4992, 0.5101, 0.5004, 0.3949, 0.3604, 0.4735, 0.5216, 0.5204, 0.4913]   )
  
  								assert np.abs(image_slice.flatten() - expected_slice   ).max() < 1e-2
  
  
  
  							def       _a   (      self   )							->							str:
  								_UpperCAmelCase =						"cpu"  # ensure determinism for the device-dependent torch.Generator
  								_UpperCAmelCase =						self.get_dummy_components()
  								_UpperCAmelCase =						EulerAncestralDiscreteScheduler(
  								    beta_start=0.00085 ,						beta_end=0.012 ,						beta_schedule="scaled_linear"   )
  								_UpperCAmelCase =						StableDiffusionModelEditingPipeline(**a_   )
  								_UpperCAmelCase =						sd_pipe.to(a_   )
  								sd_pipe.set_progress_bar_config(disable=a_   )
  
  								_UpperCAmelCase =						self.get_dummy_inputs(a_   )
  								_UpperCAmelCase =						sd_pipe(**a_   ).images
  								_UpperCAmelCase =						image[0, -3:, -3:, -1]
  
  								assert image.shape == (1, 64, 64, 3)
  
  								_UpperCAmelCase =						np.array([0.4747, 0.5372, 0.4779, 0.4982, 0.5543, 0.4816, 0.5238, 0.4904, 0.5027]   )
  
  								assert np.abs(image_slice.flatten() - expected_slice   ).max() < 1e-2
  
  
  
  							def       _a   (      self   )							->							Any:
  								_UpperCAmelCase =						"cpu"  # ensure determinism for the device-dependent torch.Generator
  								_UpperCAmelCase =						self.get_dummy_components()
  								_UpperCAmelCase =						PNDMScheduler()
  								_UpperCAmelCase =						StableDiffusionModelEditingPipeline(**a_   )
  								_UpperCAmelCase =						sd_pipe.to(a_   )
  								sd_pipe.set_progress_bar_config(disable=a_   )
  
  								_UpperCAmelCase =						self.get_dummy_inputs(a_   )
  								# the pipeline does not expect pndm so test if it raises error.
  								with self.assertRaises(a_   ):
  									_UpperCAmelCase =						sd_pipe(**a_   ).images
  
  
  
  							def       _a   (      self   )							->							Optional[int]:
  								super().test_inference_batch_single_identical(expected_max_diff=5e-3   )
  
  
  
  							def       _a   (      self   )							->							Optional[Any]:
  								super().test_attention_slicing_forward_pass(expected_max_diff=5e-3   )
  
  
  
  
  
  @slow
  @require_torch_gpu
  class    _lowerCAmelCase						(						unittest.TestCase						):
  
  
  
  							def       _a   (      self   )							->							Tuple:
  								super().tearDown()
  								gc.collect()
  								torch.cuda.empty_cache()
  
  
  
  							def       _a   (      self ,						a_=0   )							->							Optional[Any]:
  								_UpperCAmelCase =						torch.manual_seed(a_   )
  								_UpperCAmelCase =						{
  								    "prompt": "A field of roses",
  								    "generator": generator,
  								    "num_inference_steps": 3,
  								    "guidance_scale": 7.5,
  								    "output_type": "numpy",
  								}
  								return inputs
  
  
  
  							def       _a   (      self   )							->							str:
  								_UpperCAmelCase =						"CompVis/stable-diffusion-v1-4"
  								_UpperCAmelCase =						StableDiffusionModelEditingPipeline.from_pretrained(a_ ,						safety_checker=a_   )
  								pipe.to(a_   )
  								pipe.set_progress_bar_config(disable=a_   )
  								pipe.enable_attention_slicing()
  
  								_UpperCAmelCase =						self.get_inputs()
  								_UpperCAmelCase =						pipe(**a_   ).images
  								_UpperCAmelCase =						image[0, -3:, -3:, -1].flatten()
  
  								assert image.shape == (1, 512, 512, 3)
  
  								_UpperCAmelCase =						np.array(
  								    [0.6749496, 0.6386453, 0.51443267, 0.66094905, 0.61921215, 0.5491332, 0.5744417, 0.58075106, 0.5174658]   )
  
  								assert np.abs(expected_slice - image_slice   ).max() < 1e-2
  
  								# make sure image changes after editing
  								pipe.edit_model("A pack of roses" ,						"A pack of blue roses"   )
  
  								_UpperCAmelCase =						pipe(**a_   ).images
  								_UpperCAmelCase =						image[0, -3:, -3:, -1].flatten()
  
  								assert image.shape == (1, 512, 512, 3)
  
  								assert np.abs(expected_slice - image_slice   ).max() > 1e-1
  
  
  
  							def       _a   (      self   )							->							Optional[int]:
  								torch.cuda.empty_cache()
  								torch.cuda.reset_max_memory_allocated()
  								torch.cuda.reset_peak_memory_stats()
  
  								_UpperCAmelCase =						"CompVis/stable-diffusion-v1-4"
  								_UpperCAmelCase =						DDIMScheduler.from_pretrained(a_ ,						subfolder="scheduler"   )
  								_UpperCAmelCase =						StableDiffusionModelEditingPipeline.from_pretrained(
  								    a_ ,						scheduler=a_ ,						safety_checker=a_   )
  								_UpperCAmelCase =						pipe.to(a_   )
  								pipe.set_progress_bar_config(disable=a_   )
  								pipe.enable_attention_slicing(1   )
  								pipe.enable_sequential_cpu_offload()
  
  								_UpperCAmelCase =						self.get_inputs()
  								_UpperCAmelCase =						pipe(**a_   )
  
  								_UpperCAmelCase =						torch.cuda.max_memory_allocated()
  								# make sure that less than 4.4 GB is allocated
  								assert mem_bytes < 4.4 * 10**9
  
  
  
  
  
style_context: 
  """simple docstring"""
  from collections import namedtuple
  
  __magic_name__		       =				namedtuple('''from_to''', '''from_ to''')
  
  __magic_name__		       =				{
      '''atm''': from_to(1, 1),
      '''pascal''': from_to(0.0000098, 10_13_25),
      '''bar''': from_to(0.986923, 1.01325),
      '''kilopascal''': from_to(0.00986923, 101.325),
      '''megapascal''': from_to(9.86923, 0.101325),
      '''psi''': from_to(0.068046, 14.6959),
      '''inHg''': from_to(0.0334211, 29.9213),
      '''torr''': from_to(0.00131579, 7_60),
  }
  
  
  
  
  def     __lowerCamelCase  (		UpperCamelCase__				,     UpperCamelCase__				,     UpperCamelCase__      ):
  
  
  	"""simple docstring"""
  
  
  
  
  
  
  	if from_type not in PRESSURE_CONVERSION:
  		raise ValueError(
  		    f"Invalid 'from_type' value: {from_type!r}  Supported values are:\n"
  		    + ", ".join(UpperCamelCase__      )      )
  	if to_type not in PRESSURE_CONVERSION:
  		raise ValueError(
  		    f"Invalid 'to_type' value: {to_type!r}.  Supported values are:\n"
  		    + ", ".join(UpperCamelCase__      )      )
  	return (
  	    value * PRESSURE_CONVERSION[from_type].from_ * PRESSURE_CONVERSION[to_type].to
  	)
  
  
  if __name__ == "__main__":
  			import doctest
  
  			doctest.testmod()
  
  
  
  
  