code: 
  
  
  
  '''simple docstring'''
  
  
  
  import gc
  import random
  import tempfile
  import unittest
  
  import numpy as np
  import torch
  from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer
  
  from diffusers import AutoencoderKL, DDIMScheduler, LMSDiscreteScheduler, PNDMScheduler, UNetaDConditionModel
  from diffusers.pipelines.semantic_stable_diffusion import SemanticStableDiffusionPipeline as StableDiffusionPipeline
  from diffusers.utils import floats_tensor, nightly, torch_device
  from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu
  
  
  enable_full_determinism()
  class        UpperCAmelCase__  (    unittest.TestCase):
  
  
  
   def    __lowerCamelCase				(  self			)  ->							str:
    # clean up the VRAM after each test
    super().tearDown()
    gc.collect()
    torch.cuda.empty_cache()
  
  
  
   @property
   def    __lowerCamelCase				(  self			)  ->							Any:
    __UpperCamelCase				      =  1
    __UpperCamelCase				      =  3
    __UpperCamelCase				      =  (3_2, 3_2)
  
    __UpperCamelCase				      =  floats_tensor((batch_size, num_channels) + sizes		,	rng=random.Random(0			)			).to(lowercase			)
    return image
  
  
  
   @property
   def    __lowerCamelCase				(  self			)  ->							Any:
    torch.manual_seed(0			)
    __UpperCamelCase				      =  UNetaDConditionModel(
        block_out_channels=(3_2, 6_4)		,	layers_per_block=2		,	sample_size=3_2		,	in_channels=4		,	out_channels=4		,	down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""")		,	up_block_types=("""CrossAttnUpBlock2D""", """UpBlock2D""")		,	cross_attention_dim=3_2		,	)
    return model
  
  
  
   @property
   def    __lowerCamelCase				(  self			)  ->							Dict:
    torch.manual_seed(0			)
    __UpperCamelCase				      =  AutoencoderKL(
        block_out_channels=[3_2, 6_4]		,	in_channels=3		,	out_channels=3		,	down_block_types=["""DownEncoderBlock2D""", """DownEncoderBlock2D"""]		,	up_block_types=["""UpDecoderBlock2D""", """UpDecoderBlock2D"""]		,	latent_channels=4		,	)
    return model
  
  
  
   @property
   def    __lowerCamelCase				(  self			)  ->							Optional[Any]:
    torch.manual_seed(0			)
    __UpperCamelCase				      =  CLIPTextConfig(
        bos_token_id=0		,	eos_token_id=2		,	hidden_size=3_2		,	intermediate_size=3_7		,	layer_norm_eps=1E-05		,	num_attention_heads=4		,	num_hidden_layers=5		,	pad_token_id=1		,	vocab_size=1_0_0_0		,	)
    return CLIPTextModel(lowercase			)
  
  
  
   @property
   def    __lowerCamelCase				(  self			)  ->							Tuple:
    def extract(*lowercase		,	**lowercase			):
     class        UpperCAmelCase__  :
  
  
  
      def __init__(  self			)  ->							List[Any]:
       __UpperCamelCase				      =  torch.ones([0]			)
  
  
  
  
      def    __lowerCamelCase				(  self		,	lowercase			)  ->							Optional[int]:
       self.pixel_values.to(lowercase			)
       return self
  
  
     return Out()
  
    return extract
  
  
  
   def    __lowerCamelCase				(  self			)  ->							Optional[Any]:
    __UpperCamelCase				      =  """cpu"""  # ensure determinism for the device-dependent torch.Generator
    __UpperCamelCase				      =  self.dummy_cond_unet
    __UpperCamelCase				      =  DDIMScheduler(
        beta_start=0.00_085		,	beta_end=0.012		,	beta_schedule="""scaled_linear"""		,	clip_sample=lowercase		,	set_alpha_to_one=lowercase		,	)
  
    __UpperCamelCase				      =  self.dummy_vae
    __UpperCamelCase				      =  self.dummy_text_encoder
    __UpperCamelCase				      =  CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""			)
  
    # make sure here that pndm scheduler skips prk
    __UpperCamelCase				      =  StableDiffusionPipeline(
        unet=lowercase		,	scheduler=lowercase		,	vae=lowercase		,	text_encoder=lowercase		,	tokenizer=lowercase		,	safety_checker=lowercase		,	feature_extractor=self.dummy_extractor		,	)
    __UpperCamelCase				      =  sd_pipe.to(lowercase			)
    sd_pipe.set_progress_bar_config(disable=lowercase			)
  
    __UpperCamelCase				      =  """A painting of a squirrel eating a burger"""
  
    __UpperCamelCase				      =  torch.Generator(device=lowercase			).manual_seed(0			)
    __UpperCamelCase				      =  sd_pipe([prompt]		,	generator=lowercase		,	guidance_scale=6.0		,	num_inference_steps=2		,	output_type="""np"""			)
    __UpperCamelCase				      =  output.images
  
    __UpperCamelCase				      =  torch.Generator(device=lowercase			).manual_seed(0			)
    __UpperCamelCase				      =  sd_pipe(
        [prompt]		,	generator=lowercase		,	guidance_scale=6.0		,	num_inference_steps=2		,	output_type="""np"""		,	return_dict=lowercase		,	)[0]
  
    __UpperCamelCase				      =  image[0, -3:, -3:, -1]
    __UpperCamelCase				      =  image_from_tuple[0, -3:, -3:, -1]
  
    assert image.shape == (1, 6_4, 6_4, 3)
    __UpperCamelCase				      =  np.array([0.5_753, 0.6_114, 0.5_001, 0.5_034, 0.5_470, 0.4_729, 0.4_971, 0.4_867, 0.4_867]			)
  
    assert np.abs(image_slice.flatten() - expected_slice			).max() < 1E-2
    assert np.abs(image_from_tuple_slice.flatten() - expected_slice			).max() < 1E-2
  
  
  
   def    __lowerCamelCase				(  self			)  ->							List[str]:
    __UpperCamelCase				      =  """cpu"""  # ensure determinism for the device-dependent torch.Generator
    __UpperCamelCase				      =  self.dummy_cond_unet
    __UpperCamelCase				      =  PNDMScheduler(skip_prk_steps=lowercase			)
    __UpperCamelCase				      =  self.dummy_vae
    __UpperCamelCase				      =  self.dummy_text_encoder
    __UpperCamelCase				      =  CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""			)
  
    # make sure here that pndm scheduler skips prk
    __UpperCamelCase				      =  StableDiffusionPipeline(
        unet=lowercase		,	scheduler=lowercase		,	vae=lowercase		,	text_encoder=lowercase		,	tokenizer=lowercase		,	safety_checker=lowercase		,	feature_extractor=self.dummy_extractor		,	)
    __UpperCamelCase				      =  sd_pipe.to(lowercase			)
    sd_pipe.set_progress_bar_config(disable=lowercase			)
  
    __UpperCamelCase				      =  """A painting of a squirrel eating a burger"""
    __UpperCamelCase				      =  torch.Generator(device=lowercase			).manual_seed(0			)
    __UpperCamelCase				      =  sd_pipe([prompt]		,	generator=lowercase		,	guidance_scale=6.0		,	num_inference_steps=2		,	output_type="""np"""			)
  
    __UpperCamelCase				      =  output.images
  
    __UpperCamelCase				      =  torch.Generator(device=lowercase			).manual_seed(0			)
    __UpperCamelCase				      =  sd_pipe(
        [prompt]		,	generator=lowercase		,	guidance_scale=6.0		,	num_inference_steps=2		,	output_type="""np"""		,	return_dict=lowercase		,	)[0]
  
    __UpperCamelCase				      =  image[0, -3:, -3:, -1]
    __UpperCamelCase				      =  image_from_tuple[0, -3:, -3:, -1]
  
    assert image.shape == (1, 6_4, 6_4, 3)
    __UpperCamelCase				      =  np.array([0.5_122, 0.5_712, 0.4_825, 0.5_053, 0.5_646, 0.4_769, 0.5_179, 0.4_894, 0.4_994]			)
  
    assert np.abs(image_slice.flatten() - expected_slice			).max() < 1E-2
    assert np.abs(image_from_tuple_slice.flatten() - expected_slice			).max() < 1E-2
  
  
  
   def    __lowerCamelCase				(  self			)  ->							Union[str, Any]:
    __UpperCamelCase				      =  StableDiffusionPipeline.from_pretrained(
        """hf-internal-testing/tiny-stable-diffusion-lms-pipe"""		,	safety_checker=lowercase			)
    assert isinstance(lowercase		,	lowercase			)
    assert isinstance(pipe.scheduler		,	lowercase			)
    assert pipe.safety_checker is None
  
    __UpperCamelCase				      =  pipe("""example prompt"""		,	num_inference_steps=2			).images[0]
    assert image is not None
  
    # check that there's no error when saving a pipeline with one of the models being None
    with tempfile.TemporaryDirectory() as tmpdirname:
     pipe.save_pretrained(lowercase			)
     __UpperCamelCase				      =  StableDiffusionPipeline.from_pretrained(lowercase			)
  
    # sanity check that the pipeline still works
    assert pipe.safety_checker is None
    __UpperCamelCase				      =  pipe("""example prompt"""		,	num_inference_steps=2			).images[0]
    assert image is not None
  
  
  
  
   @unittest.skipIf(torch_device != """cuda"""		,	"""This test requires a GPU"""			)
   def    __lowerCamelCase				(  self			)  ->							Union[str, Any]:
    __UpperCamelCase				      =  self.dummy_cond_unet
    __UpperCamelCase				      =  PNDMScheduler(skip_prk_steps=lowercase			)
    __UpperCamelCase				      =  self.dummy_vae
    __UpperCamelCase				      =  self.dummy_text_encoder
    __UpperCamelCase				      =  CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""			)
  
    # put models in fp16
    __UpperCamelCase				      =  unet.half()
    __UpperCamelCase				      =  vae.half()
    __UpperCamelCase				      =  bert.half()
  
    # make sure here that pndm scheduler skips prk
    __UpperCamelCase				      =  StableDiffusionPipeline(
        unet=lowercase		,	scheduler=lowercase		,	vae=lowercase		,	text_encoder=lowercase		,	tokenizer=lowercase		,	safety_checker=lowercase		,	feature_extractor=self.dummy_extractor		,	)
    __UpperCamelCase				      =  sd_pipe.to(lowercase			)
    sd_pipe.set_progress_bar_config(disable=lowercase			)
  
    __UpperCamelCase				      =  """A painting of a squirrel eating a burger"""
    __UpperCamelCase				      =  sd_pipe([prompt]		,	num_inference_steps=2		,	output_type="""np"""			).images
  
    assert image.shape == (1, 6_4, 6_4, 3)
  
  
  @nightly
  @require_torch_gpu
  class        UpperCAmelCase__  (    unittest.TestCase):
  
  
  
   def    __lowerCamelCase				(  self			)  ->							int:
    # clean up the VRAM after each test
    super().tearDown()
    gc.collect()
    torch.cuda.empty_cache()
  
  
  
   def    __lowerCamelCase				(  self			)  ->							Tuple:
    __UpperCamelCase				      =  """cuda"""
    __UpperCamelCase				      =  StableDiffusionPipeline.from_pretrained("""runwayml/stable-diffusion-v1-5"""			)
    __UpperCamelCase				      =  pipe.to(lowercase			)
    pipe.set_progress_bar_config(disable=lowercase			)
  
    __UpperCamelCase				      =  """a photo of a cat"""
    __UpperCamelCase				      =  {
        """editing_prompt""": ["""sunglasses"""],
        """reverse_editing_direction""": [False],
        """edit_warmup_steps""": 1_0,
        """edit_guidance_scale""": 6,
        """edit_threshold""": 0.95,
        """edit_momentum_scale""": 0.5,
        """edit_mom_beta""": 0.6,
    }
  
    __UpperCamelCase				      =  3
    __UpperCamelCase				      =  7
  
    # no sega enabled
    __UpperCamelCase				      =  torch.Generator(lowercase			)
    generator.manual_seed(lowercase			)
    __UpperCamelCase				      =  pipe(
        [prompt]		,	generator=lowercase		,	guidance_scale=lowercase		,	num_inference_steps=5_0		,	output_type="""np"""		,	width=5_1_2		,	height=5_1_2		,	)
  
    __UpperCamelCase				      =  output.images
    __UpperCamelCase				      =  image[0, -3:, -3:, -1]
    __UpperCamelCase				      =  [
        0.34_673_113,
        0.38_492_733,
        0.37_597_352,
        0.34_086_335,
        0.35_650_748,
        0.35_579_205,
        0.3_384_763,
        0.34_340_236,
        0.3_573_271,
    ]
  
    assert image.shape == (1, 5_1_2, 5_1_2, 3)
  
    assert np.abs(image_slice.flatten() - expected_slice			).max() < 1E-2
  
    # with sega enabled
    # generator = torch.manual_seed(seed)
    generator.manual_seed(lowercase			)
    __UpperCamelCase				      =  pipe(
        [prompt]		,	generator=lowercase		,	guidance_scale=lowercase		,	num_inference_steps=5_0		,	output_type="""np"""		,	width=5_1_2		,	height=5_1_2		,	**lowercase		,	)
  
    __UpperCamelCase				      =  output.images
    __UpperCamelCase				      =  image[0, -3:, -3:, -1]
    __UpperCamelCase				      =  [
        0.41_887_826,
        0.37_728_766,
        0.30_138_272,
        0.41_416_335,
        0.41_664_985,
        0.36_283_392,
        0.36_191_246,
        0.43_364_465,
        0.43_001_732,
    ]
  
    assert image.shape == (1, 5_1_2, 5_1_2, 3)
  
    assert np.abs(image_slice.flatten() - expected_slice			).max() < 1E-2
  
  
  
   def    __lowerCamelCase				(  self			)  ->							Tuple:
    __UpperCamelCase				      =  """cuda"""
    __UpperCamelCase				      =  StableDiffusionPipeline.from_pretrained("""runwayml/stable-diffusion-v1-5"""			)
    __UpperCamelCase				      =  pipe.to(lowercase			)
    pipe.set_progress_bar_config(disable=lowercase			)
  
    __UpperCamelCase				      =  """an image of a crowded boulevard, realistic, 4k"""
    __UpperCamelCase				      =  {
        """editing_prompt""": """crowd, crowded, people""",
        """reverse_editing_direction""": True,
        """edit_warmup_steps""": 1_0,
        """edit_guidance_scale""": 8.3,
        """edit_threshold""": 0.9,
        """edit_momentum_scale""": 0.5,
        """edit_mom_beta""": 0.6,
    }
  
    __UpperCamelCase				      =  9
    __UpperCamelCase				      =  7
  
    # no sega enabled
    __UpperCamelCase				      =  torch.Generator(lowercase			)
    generator.manual_seed(lowercase			)
    __UpperCamelCase				      =  pipe(
        [prompt]		,	generator=lowercase		,	guidance_scale=lowercase		,	num_inference_steps=5_0		,	output_type="""np"""		,	width=5_1_2		,	height=5_1_2		,	)
  
    __UpperCamelCase				      =  output.images
    __UpperCamelCase				      =  image[0, -3:, -3:, -1]
    __UpperCamelCase				      =  [
        0.43_497_998,
        0.91_814_065,
        0.7_540_739,
        0.55_580_205,
        0.8_467_265,
        0.5_389_691,
        0.62_574_506,
        0.58_897_763,
        0.50_926_757,
    ]
  
    assert image.shape == (1, 5_1_2, 5_1_2, 3)
  
    assert np.abs(image_slice.flatten() - expected_slice			).max() < 1E-2
  
    # with sega enabled
    # generator = torch.manual_seed(seed)
    generator.manual_seed(lowercase			)
    __UpperCamelCase				      =  pipe(
        [prompt]		,	generator=lowercase		,	guidance_scale=lowercase		,	num_inference_steps=5_0		,	output_type="""np"""		,	width=5_1_2		,	height=5_1_2		,	**lowercase		,	)
  
    __UpperCamelCase				      =  output.images
    __UpperCamelCase				      =  image[0, -3:, -3:, -1]
    __UpperCamelCase				      =  [
        0.3_089_719,
        0.30_500_144,
        0.29_016_042,
        0.30_630_964,
        0.325_687,
        0.29_419_225,
        0.2_908_091,
        0.28_723_598,
        0.27_696_294,
    ]
  
    assert image.shape == (1, 5_1_2, 5_1_2, 3)
  
    assert np.abs(image_slice.flatten() - expected_slice			).max() < 1E-2
  
  
  
   def    __lowerCamelCase				(  self			)  ->							Union[str, Any]:
    __UpperCamelCase				      =  """cuda"""
    __UpperCamelCase				      =  StableDiffusionPipeline.from_pretrained("""runwayml/stable-diffusion-v1-5"""			)
    __UpperCamelCase				      =  pipe.to(lowercase			)
    pipe.set_progress_bar_config(disable=lowercase			)
  
    __UpperCamelCase				      =  """a castle next to a river"""
    __UpperCamelCase				      =  {
        """editing_prompt""": ["""boat on a river, boat""", """monet, impression, sunrise"""],
        """reverse_editing_direction""": False,
        """edit_warmup_steps""": [1_5, 1_8],
        """edit_guidance_scale""": 6,
        """edit_threshold""": [0.9, 0.8],
        """edit_momentum_scale""": 0.5,
        """edit_mom_beta""": 0.6,
    }
  
    __UpperCamelCase				      =  4_8
    __UpperCamelCase				      =  7
  
    # no sega enabled
    __UpperCamelCase				      =  torch.Generator(lowercase			)
    generator.manual_seed(lowercase			)
    __UpperCamelCase				      =  pipe(
        [prompt]		,	generator=lowercase		,	guidance_scale=lowercase		,	num_inference_steps=5_0		,	output_type="""np"""		,	width=5_1_2		,	height=5_1_2		,	)
  
    __UpperCamelCase				      =  output.images
    __UpperCamelCase				      =  image[0, -3:, -3:, -1]
    __UpperCamelCase				      =  [
        0.75_163_555,
        0.76_037_145,
        0.61_785,
        0.9_189_673,
        0.8_627_701,
        0.85_189_694,
        0.8_512_813,
        0.87_012_076,
        0.8_312_857,
    ]
  
    assert image.shape == (1, 5_1_2, 5_1_2, 3)
  
    assert np.abs(image_slice.flatten() - expected_slice			).max() < 1E-2
  
    # with sega enabled
    # generator = torch.manual_seed(seed)
    generator.manual_seed(lowercase			)
    __UpperCamelCase				      =  pipe(
        [prompt]		,	generator=lowercase		,	guidance_scale=lowercase		,	num_inference_steps=5_0		,	output_type="""np"""		,	width=5_1_2		,	height=5_1_2		,	**lowercase		,	)
  
    __UpperCamelCase				      =  output.images
    __UpperCamelCase				      =  image[0, -3:, -3:, -1]
    __UpperCamelCase				      =  [
        0.73_553_365,
        0.7_537_271,
        0.74_341_905,
        0.66_480_356,
        0.6_472_925,
        0.63_039_416,
        0.64_812_905,
        0.6_749_717,
        0.6_517_102,
    ]
  
    assert image.shape == (1, 5_1_2, 5_1_2, 3)
  
    assert np.abs(image_slice.flatten() - expected_slice			).max() < 1E-2
  
  
  
  
   def    __lowerCamelCase				(  self			)  ->							Tuple:
    __UpperCamelCase				      =  """cuda"""
    __UpperCamelCase				      =  StableDiffusionPipeline.from_pretrained("""runwayml/stable-diffusion-v1-5"""		,	torch_dtype=torch.floataa			)
    __UpperCamelCase				      =  pipe.to(lowercase			)
    pipe.set_progress_bar_config(disable=lowercase			)
  
    __UpperCamelCase				      =  """a photo of a cat"""
    __UpperCamelCase				      =  {
        """editing_prompt""": ["""sunglasses"""],
        """reverse_editing_direction""": [False],
        """edit_warmup_steps""": 1_0,
        """edit_guidance_scale""": 6,
        """edit_threshold""": 0.95,
        """edit_momentum_scale""": 0.5,
        """edit_mom_beta""": 0.6,
    }
  
    __UpperCamelCase				      =  3
    __UpperCamelCase				      =  7
  
    # no sega enabled
    __UpperCamelCase				      =  torch.Generator(lowercase			)
    generator.manual_seed(lowercase			)
    __UpperCamelCase				      =  pipe(
        [prompt]		,	generator=lowercase		,	guidance_scale=lowercase		,	num_inference_steps=5_0		,	output_type="""np"""		,	width=5_1_2		,	height=5_1_2		,	)
  
    __UpperCamelCase				      =  output.images
    __UpperCamelCase				      =  image[0, -3:, -3:, -1]
    __UpperCamelCase				      =  [
        0.34_887_695,
        0.3_876_953,
        0.375,
        0.34_423_828,
        0.3_581_543,
        0.35_717_773,
        0.3_383_789,
        0.34_570_312,
        0.359_375,
    ]
  
    assert image.shape == (1, 5_1_2, 5_1_2, 3)
  
    assert np.abs(image_slice.flatten() - expected_slice			).max() < 1E-2
  
    # with sega enabled
    # generator = torch.manual_seed(seed)
    generator.manual_seed(lowercase			)
    __UpperCamelCase				      =  pipe(
        [prompt]		,	generator=lowercase		,	guidance_scale=lowercase		,	num_inference_steps=5_0		,	output_type="""np"""		,	width=5_1_2		,	height=5_1_2		,	**lowercase		,	)
  
    __UpperCamelCase				      =  output.images
    __UpperCamelCase				      =  image[0, -3:, -3:, -1]
    __UpperCamelCase				      =  [
        0.42_285_156,
        0.36_914_062,
        0.29_077_148,
        0.42_041_016,
        0.41_918_945,
        0.35_498_047,
        0.3_618_164,
        0.4_423_828,
        0.43_115_234,
    ]
  
    assert image.shape == (1, 5_1_2, 5_1_2, 3)
  
    assert np.abs(image_slice.flatten() - expected_slice			).max() < 1E-2
  
  
  
  
  
  
style_context: 
  
  
  
  '''simple docstring'''
  
  
  
  a__						:			Any										=			{
      '0000': '0',
      '0001': '1',
      '0010': '2',
      '0011': '3',
      '0100': '4',
      '0101': '5',
      '0110': '6',
      '0111': '7',
      '1000': '8',
      '1001': '9',
      '1010': 'a',
      '1011': 'b',
      '1100': 'c',
      '1101': 'd',
      '1110': 'e',
      '1111': 'f',
  }
  
  
  
  
  
  
  
  def _lowercase   (  __A       ):
  
  
  
   '''simple docstring'''
  
  
  
   __UpperCamelCase				      =  str(__A       ).strip()
  
   # Exceptions
   if not binary_str:
    raise ValueError("""Empty string was passed to the function"""       )
   __UpperCamelCase				      =  binary_str[0] == """-"""
   __UpperCamelCase				      =  binary_str[1:] if is_negative else binary_str
   if not all(char in """01""" for char in binary_str       ):
    raise ValueError("""Non-binary value was passed to the function"""       )
  
   __UpperCamelCase				      =  (
       """0""" * (4 * (divmod(len(__A       )							,4       )[0] + 1) - len(__A       )) + binary_str
   )
  
   __UpperCamelCase				      =  []
   for x in range(0							,len(__A       )							,4       ):
    hexadecimal.append(BITS_TO_HEX[binary_str[x : x + 4]]       )
   __UpperCamelCase				      =  """0x""" + """""".join(__A       )
  
   return "-" + hexadecimal_str if is_negative else hexadecimal_str
  
  
  if __name__ == "__main__":
   from doctest import testmod
  
   testmod()
  
  
  
  
  
  