
'''simple docstring'''


import gc
import os
import tempfile
import unittest

import torch
import torch.nn as nn
import torch.nn.functional as F
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import AutoencoderKL, DDIMScheduler, StableDiffusionPipeline, UNetaDConditionModel
from diffusers.loaders import AttnProcsLayers, LoraLoaderMixin
from diffusers.models.attention_processor import (
    Attention,
    AttnProcessor,
    AttnProcessor2_0,
    LoRAAttnProcessor,
    LoRAAttnProcessor2_0,
    LoRAXFormersAttnProcessor,
    XFormersAttnProcessor,
)
from diffusers.utils import TEXT_ENCODER_ATTN_MODULE, floats_tensor, torch_device
def 					__magic_name__(       UpperCAmelCase__ :       nn.Module	):
						UpperCamelCase_     :	Dict					     =     {}
						for name in unet.attn_processors.keys():
												UpperCamelCase_     :	int					     =     None if name.endswith("""attn1.processor"""	) else unet.config.cross_attention_dim
												if name.startswith("""mid_block"""	):
																		UpperCamelCase_     :	str					     =     unet.config.block_out_channels[-1]
												elif name.startswith("""up_blocks"""	):
																		UpperCamelCase_     :	str					     =     int(name[len("""up_blocks."""	)]	)
																		UpperCamelCase_     :	str					     =     list(reversed(unet.config.block_out_channels	)	)[block_id]
												elif name.startswith("""down_blocks"""	):
																		UpperCamelCase_     :	Tuple					     =     int(name[len("""down_blocks."""	)]	)
																		UpperCamelCase_     :	Optional[Any]					     =     unet.config.block_out_channels[block_id]
												UpperCamelCase_     :	List[Any]					     =     (
												    LoRAAttnProcessor2_0 if hasattr(UpperCAmelCase__							,				"""scaled_dot_product_attention"""	) else LoRAAttnProcessor
												)
												UpperCamelCase_     :	Union[str, Any]					     =     lora_attn_processor_class(
												    hidden_size=UpperCAmelCase__							,				cross_attention_dim=UpperCAmelCase__	)
						UpperCamelCase_     :	List[str]					     =     AttnProcsLayers(UpperCAmelCase__	)
						return lora_attn_procs, unet_lora_layers
def 					__magic_name__(       UpperCAmelCase__ :       nn.Module	):
						UpperCamelCase_     :	List[Any]					     =     {}
						UpperCamelCase_     :	int					     =     (
						    LoRAAttnProcessor2_0 if hasattr(UpperCAmelCase__							,				"""scaled_dot_product_attention"""	) else LoRAAttnProcessor
						)
						for name, module in text_encoder.named_modules():
												if name.endswith(UpperCAmelCase__	):
																		UpperCamelCase_     :	Optional[Any]					     =     lora_attn_processor_class(
																		    hidden_size=module.out_proj.out_features							,				cross_attention_dim=UpperCAmelCase__	)
						return text_lora_attn_procs
def 					__magic_name__(       UpperCAmelCase__ :       nn.Module	):
						UpperCamelCase_     :	Dict					     =     create_text_encoder_lora_attn_procs(UpperCAmelCase__	)
						UpperCamelCase_     :	int					     =     AttnProcsLayers(UpperCAmelCase__	)
						return text_encoder_lora_layers
def 					__magic_name__(       UpperCAmelCase__ :       Dict							,				UpperCAmelCase__ :       Optional[int]=False	):
						for _, attn_proc in text_lora_attn_procs.items():
												# set up.weights
												for layer_name, layer_module in attn_proc.named_modules():
																		if layer_name.endswith("""_lora"""	):
																								UpperCamelCase_     :	Dict					     =     (
																								    torch.randn_like(layer_module.up.weight	)
																								    if randn_weight
																								    else torch.zeros_like(layer_module.up.weight	)
																								)
																								UpperCamelCase_     :	Dict					     =     torch.nn.Parameter(UpperCAmelCase__	)







class     __snake_case			(    unittest.TestCase	):




		def 	_snake_case	(  self					:Tuple)					->			Dict:






								'''simple docstring'''






								torch.manual_seed(0)
								UpperCamelCase_     :	int					     =     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			,    )
								UpperCamelCase_     :	Tuple					     =     DDIMScheduler(
								    beta_start=0.00085			,    beta_end=0.012			,    beta_schedule="""scaled_linear"""			,    clip_sample=_SCREAMING_SNAKE_CASE			,    set_alpha_to_one=_SCREAMING_SNAKE_CASE			,    steps_offset=1			,    )
								torch.manual_seed(0)
								UpperCamelCase_     :	Tuple					     =     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			,    )
								UpperCamelCase_     :	Tuple					     =     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			,    )
								UpperCamelCase_     :	Tuple					     =     CLIPTextModel(_SCREAMING_SNAKE_CASE)
								UpperCamelCase_     :	List[str]					     =     CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip""")

								UpperCamelCase_     ,UpperCamelCase_     :	Dict					     =     create_unet_lora_layers(_SCREAMING_SNAKE_CASE)
								UpperCamelCase_     :	Optional[int]					     =     create_text_encoder_lora_layers(_SCREAMING_SNAKE_CASE)

								UpperCamelCase_     :	int					     =     {
								    """unet""": unet,
								    """scheduler""": scheduler,
								    """vae""": vae,
								    """text_encoder""": text_encoder,
								    """tokenizer""": tokenizer,
								    """safety_checker""": None,
								    """feature_extractor""": None,
								}
								UpperCamelCase_     :	str					     =     {
								    """unet_lora_layers""": unet_lora_layers,
								    """text_encoder_lora_layers""": text_encoder_lora_layers,
								    """unet_lora_attn_procs""": unet_lora_attn_procs,
								}
								return pipeline_components, lora_components




		def 	_snake_case	(  self					:Union[str, Any])					->			Dict:






								'''simple docstring'''






								UpperCamelCase_     :	str					     =     1
								UpperCamelCase_     :	Optional[int]					     =     1_0
								UpperCamelCase_     :	Optional[int]					     =     4
								UpperCamelCase_     :	Tuple					     =     (3_2, 3_2)

								UpperCamelCase_     :	Optional[Any]					     =     torch.manual_seed(0)
								UpperCamelCase_     :	str					     =     floats_tensor((batch_size, num_channels) + sizes)
								UpperCamelCase_     :	Optional[Any]					     =     torch.randint(1			,    _SCREAMING_SNAKE_CASE			,    size=(batch_size, sequence_length)			,    generator=_SCREAMING_SNAKE_CASE)

								UpperCamelCase_     :	Any					     =     {
								    """prompt""": """A painting of a squirrel eating a burger""",
								    """generator""": generator,
								    """num_inference_steps""": 2,
								    """guidance_scale""": 6.0,
								    """output_type""": """numpy""",
								}

								return noise, input_ids, pipeline_inputs

								# copied from: https://colab.research.google.com/gist/sayakpaul/df2ef6e1ae6d8c10a49d859883b10860/scratchpad.ipynb




		def 	_snake_case	(  self					:int)					->			Optional[Any]:






								'''simple docstring'''






								UpperCamelCase_     :	Dict					     =     7_7

								UpperCamelCase_     :	List[str]					     =     torch.randint(2			,    5_6			,    size=(1, max_seq_length)			,    generator=torch.manual_seed(0))

								UpperCamelCase_     :	Tuple					     =     {}
								UpperCamelCase_     :	Optional[int]					     =     inputs
								return prepared_inputs




		def 	_snake_case	(  self					:Union[str, Any]			,    _SCREAMING_SNAKE_CASE					:Optional[Any])					->			Any:






								'''simple docstring'''






								UpperCamelCase_     ,UpperCamelCase_     :	Tuple					     =     self.get_dummy_components()
								LoraLoaderMixin.save_lora_weights(
								    save_directory=_SCREAMING_SNAKE_CASE			,    unet_lora_layers=lora_components["""unet_lora_layers"""]			,    text_encoder_lora_layers=lora_components["""text_encoder_lora_layers"""]			,    )
								self.assertTrue(os.path.isfile(os.path.join(_SCREAMING_SNAKE_CASE			,    """pytorch_lora_weights.bin""")))




		def 	_snake_case	(  self					:Optional[int])					->			Dict:






								'''simple docstring'''






								UpperCamelCase_     ,UpperCamelCase_     :	Tuple					     =     self.get_dummy_components()
								UpperCamelCase_     :	List[str]					     =     StableDiffusionPipeline(**_SCREAMING_SNAKE_CASE)
								UpperCamelCase_     :	Union[str, Any]					     =     sd_pipe.to(_SCREAMING_SNAKE_CASE)
								sd_pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE)

								UpperCamelCase_     ,UpperCamelCase_     ,UpperCamelCase_     :	Any					     =     self.get_dummy_inputs()

								UpperCamelCase_     :	Optional[int]					     =     sd_pipe(**_SCREAMING_SNAKE_CASE).images
								UpperCamelCase_     :	Tuple					     =     original_images[0, -3:, -3:, -1]

								with tempfile.TemporaryDirectory() as tmpdirname:
														LoraLoaderMixin.save_lora_weights(
														    save_directory=_SCREAMING_SNAKE_CASE			,    unet_lora_layers=lora_components["""unet_lora_layers"""]			,    text_encoder_lora_layers=lora_components["""text_encoder_lora_layers"""]			,    )
														self.assertTrue(os.path.isfile(os.path.join(_SCREAMING_SNAKE_CASE			,    """pytorch_lora_weights.bin""")))
														sd_pipe.load_lora_weights(_SCREAMING_SNAKE_CASE)

								UpperCamelCase_     :	Dict					     =     sd_pipe(**_SCREAMING_SNAKE_CASE).images
								UpperCamelCase_     :	Union[str, Any]					     =     lora_images[0, -3:, -3:, -1]

								# Outputs shouldn't match.
								self.assertFalse(torch.allclose(torch.from_numpy(_SCREAMING_SNAKE_CASE)			,    torch.from_numpy(_SCREAMING_SNAKE_CASE)))




		def 	_snake_case	(  self					:Optional[Any])					->			Optional[int]:






								'''simple docstring'''






								UpperCamelCase_     ,UpperCamelCase_     :	Any					     =     self.get_dummy_components()
								UpperCamelCase_     :	List[Any]					     =     StableDiffusionPipeline(**_SCREAMING_SNAKE_CASE)
								UpperCamelCase_     :	Any					     =     sd_pipe.to(_SCREAMING_SNAKE_CASE)
								sd_pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE)

								UpperCamelCase_     ,UpperCamelCase_     ,UpperCamelCase_     :	Tuple					     =     self.get_dummy_inputs()

								UpperCamelCase_     :	Optional[int]					     =     sd_pipe(**_SCREAMING_SNAKE_CASE).images
								UpperCamelCase_     :	Union[str, Any]					     =     original_images[0, -3:, -3:, -1]

								with tempfile.TemporaryDirectory() as tmpdirname:
														LoraLoaderMixin.save_lora_weights(
														    save_directory=_SCREAMING_SNAKE_CASE			,    unet_lora_layers=lora_components["""unet_lora_layers"""]			,    text_encoder_lora_layers=lora_components["""text_encoder_lora_layers"""]			,    safe_serialization=_SCREAMING_SNAKE_CASE			,    )
														self.assertTrue(os.path.isfile(os.path.join(_SCREAMING_SNAKE_CASE			,    """pytorch_lora_weights.safetensors""")))
														sd_pipe.load_lora_weights(_SCREAMING_SNAKE_CASE)

								UpperCamelCase_     :	List[Any]					     =     sd_pipe(**_SCREAMING_SNAKE_CASE).images
								UpperCamelCase_     :	Optional[Any]					     =     lora_images[0, -3:, -3:, -1]

								# Outputs shouldn't match.
								self.assertFalse(torch.allclose(torch.from_numpy(_SCREAMING_SNAKE_CASE)			,    torch.from_numpy(_SCREAMING_SNAKE_CASE)))




		def 	_snake_case	(  self					:Optional[Any])					->			Optional[int]:






								'''simple docstring'''






								UpperCamelCase_     ,UpperCamelCase_     :	str					     =     self.get_dummy_components()
								UpperCamelCase_     :	int					     =     lora_components["""unet_lora_attn_procs"""]
								UpperCamelCase_     :	Optional[int]					     =     StableDiffusionPipeline(**_SCREAMING_SNAKE_CASE)
								UpperCamelCase_     :	List[str]					     =     sd_pipe.to(_SCREAMING_SNAKE_CASE)
								sd_pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE)

								UpperCamelCase_     ,UpperCamelCase_     ,UpperCamelCase_     :	Optional[Any]					     =     self.get_dummy_inputs()

								UpperCamelCase_     :	int					     =     sd_pipe(**_SCREAMING_SNAKE_CASE).images
								UpperCamelCase_     :	List[str]					     =     original_images[0, -3:, -3:, -1]

								with tempfile.TemporaryDirectory() as tmpdirname:
														UpperCamelCase_     :	Optional[int]					     =     sd_pipe.unet
														unet.set_attn_processor(_SCREAMING_SNAKE_CASE)
														unet.save_attn_procs(_SCREAMING_SNAKE_CASE)
														self.assertTrue(os.path.isfile(os.path.join(_SCREAMING_SNAKE_CASE			,    """pytorch_lora_weights.bin""")))
														sd_pipe.load_lora_weights(_SCREAMING_SNAKE_CASE)

								UpperCamelCase_     :	Tuple					     =     sd_pipe(**_SCREAMING_SNAKE_CASE).images
								UpperCamelCase_     :	List[str]					     =     lora_images[0, -3:, -3:, -1]

								# Outputs shouldn't match.
								self.assertFalse(torch.allclose(torch.from_numpy(_SCREAMING_SNAKE_CASE)			,    torch.from_numpy(_SCREAMING_SNAKE_CASE)))




		def 	_snake_case	(  self					:Dict)					->			Dict:






								'''simple docstring'''






								UpperCamelCase_     ,UpperCamelCase_     :	Optional[Any]					     =     self.get_dummy_components()
								UpperCamelCase_     :	Tuple					     =     StableDiffusionPipeline(**_SCREAMING_SNAKE_CASE)

								UpperCamelCase_     :	Optional[int]					     =     self.get_dummy_tokens()

								# inference without lora
								UpperCamelCase_     :	List[str]					     =     pipe.text_encoder(**_SCREAMING_SNAKE_CASE)[0]
								assert outputs_without_lora.shape == (1, 7_7, 3_2)

								# create lora_attn_procs with zeroed out up.weights
								UpperCamelCase_     :	int					     =     create_text_encoder_lora_attn_procs(pipe.text_encoder)
								set_lora_up_weights(_SCREAMING_SNAKE_CASE			,    randn_weight=_SCREAMING_SNAKE_CASE)

								# monkey patch
								pipe._modify_text_encoder(_SCREAMING_SNAKE_CASE)

								# verify that it's okay to release the text_attn_procs which holds the LoRAAttnProcessor.
								del text_attn_procs
								gc.collect()

								# inference with lora
								UpperCamelCase_     :	Optional[int]					     =     pipe.text_encoder(**_SCREAMING_SNAKE_CASE)[0]
								assert outputs_with_lora.shape == (1, 7_7, 3_2)

								assert torch.allclose(
								    _SCREAMING_SNAKE_CASE			,    _SCREAMING_SNAKE_CASE), "lora_up_weight are all zero, so the lora outputs should be the same to without lora outputs"

								# create lora_attn_procs with randn up.weights
								UpperCamelCase_     :	Dict					     =     create_text_encoder_lora_attn_procs(pipe.text_encoder)
								set_lora_up_weights(_SCREAMING_SNAKE_CASE			,    randn_weight=_SCREAMING_SNAKE_CASE)

								# monkey patch
								pipe._modify_text_encoder(_SCREAMING_SNAKE_CASE)

								# verify that it's okay to release the text_attn_procs which holds the LoRAAttnProcessor.
								del text_attn_procs
								gc.collect()

								# inference with lora
								UpperCamelCase_     :	Tuple					     =     pipe.text_encoder(**_SCREAMING_SNAKE_CASE)[0]
								assert outputs_with_lora.shape == (1, 7_7, 3_2)

								assert not torch.allclose(
								    _SCREAMING_SNAKE_CASE			,    _SCREAMING_SNAKE_CASE), "lora_up_weight are not zero, so the lora outputs should be different to without lora outputs"




		def 	_snake_case	(  self					:str)					->			List[Any]:






								'''simple docstring'''






								UpperCamelCase_     ,UpperCamelCase_     :	Tuple					     =     self.get_dummy_components()
								UpperCamelCase_     :	List[str]					     =     StableDiffusionPipeline(**_SCREAMING_SNAKE_CASE)

								UpperCamelCase_     :	Dict					     =     self.get_dummy_tokens()

								# inference without lora
								UpperCamelCase_     :	int					     =     pipe.text_encoder(**_SCREAMING_SNAKE_CASE)[0]
								assert outputs_without_lora.shape == (1, 7_7, 3_2)

								# create lora_attn_procs with randn up.weights
								UpperCamelCase_     :	str					     =     create_text_encoder_lora_attn_procs(pipe.text_encoder)
								set_lora_up_weights(_SCREAMING_SNAKE_CASE			,    randn_weight=_SCREAMING_SNAKE_CASE)

								# monkey patch
								pipe._modify_text_encoder(_SCREAMING_SNAKE_CASE)

								# verify that it's okay to release the text_attn_procs which holds the LoRAAttnProcessor.
								del text_attn_procs
								gc.collect()

								# inference with lora
								UpperCamelCase_     :	int					     =     pipe.text_encoder(**_SCREAMING_SNAKE_CASE)[0]
								assert outputs_with_lora.shape == (1, 7_7, 3_2)

								assert not torch.allclose(
								    _SCREAMING_SNAKE_CASE			,    _SCREAMING_SNAKE_CASE), "lora outputs should be different to without lora outputs"

								# remove monkey patch
								pipe._remove_text_encoder_monkey_patch()

								# inference with removed lora
								UpperCamelCase_     :	Optional[Any]					     =     pipe.text_encoder(**_SCREAMING_SNAKE_CASE)[0]
								assert outputs_without_lora_removed.shape == (1, 7_7, 3_2)

								assert torch.allclose(
								    _SCREAMING_SNAKE_CASE			,    _SCREAMING_SNAKE_CASE), "remove lora monkey patch should restore the original outputs"




		def 	_snake_case	(  self					:int)					->			Union[str, Any]:






								'''simple docstring'''






								UpperCamelCase_     ,UpperCamelCase_     :	Optional[int]					     =     self.get_dummy_components()
								UpperCamelCase_     :	List[str]					     =     StableDiffusionPipeline(**_SCREAMING_SNAKE_CASE)
								UpperCamelCase_     :	List[str]					     =     sd_pipe.to(_SCREAMING_SNAKE_CASE)
								sd_pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE)

								UpperCamelCase_     ,UpperCamelCase_     ,UpperCamelCase_     :	str					     =     self.get_dummy_inputs()

								with tempfile.TemporaryDirectory() as tmpdirname:
														LoraLoaderMixin.save_lora_weights(
														    save_directory=_SCREAMING_SNAKE_CASE			,    unet_lora_layers=lora_components["""unet_lora_layers"""]			,    text_encoder_lora_layers=lora_components["""text_encoder_lora_layers"""]			,    )
														self.assertTrue(os.path.isfile(os.path.join(_SCREAMING_SNAKE_CASE			,    """pytorch_lora_weights.bin""")))
														sd_pipe.load_lora_weights(_SCREAMING_SNAKE_CASE)

								UpperCamelCase_     :	List[str]					     =     sd_pipe(**_SCREAMING_SNAKE_CASE).images
								UpperCamelCase_     :	Tuple					     =     lora_images[0, -3:, -3:, -1]

								UpperCamelCase_     :	Optional[Any]					     =     sd_pipe(**_SCREAMING_SNAKE_CASE			,    cross_attention_kwargs={"""scale""": 0.5}).images
								UpperCamelCase_     :	Union[str, Any]					     =     lora_images_with_scale[0, -3:, -3:, -1]

								# Outputs shouldn't match.
								self.assertFalse(
								    torch.allclose(torch.from_numpy(_SCREAMING_SNAKE_CASE)			,    torch.from_numpy(_SCREAMING_SNAKE_CASE)))




		def 	_snake_case	(  self					:Optional[int])					->			str:






								'''simple docstring'''






								with tempfile.TemporaryDirectory() as tmpdirname:
														self.create_lora_weight_file(_SCREAMING_SNAKE_CASE)

														UpperCamelCase_     ,UpperCamelCase_     :	Any					     =     self.get_dummy_components()
														UpperCamelCase_     :	Union[str, Any]					     =     StableDiffusionPipeline(**_SCREAMING_SNAKE_CASE)
														UpperCamelCase_     :	Dict					     =     sd_pipe.to(_SCREAMING_SNAKE_CASE)
														sd_pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE)

														# check if vanilla attention processors are used
														for _, module in sd_pipe.unet.named_modules():
																				if isinstance(_SCREAMING_SNAKE_CASE			,    _SCREAMING_SNAKE_CASE):
																										self.assertIsInstance(module.processor			,    (AttnProcessor, AttnProcessor2_0))

            # load LoRA weight file
														sd_pipe.load_lora_weights(_SCREAMING_SNAKE_CASE)

														# check if lora attention processors are used
														for _, module in sd_pipe.unet.named_modules():
																				if isinstance(_SCREAMING_SNAKE_CASE			,    _SCREAMING_SNAKE_CASE):
																										UpperCamelCase_     :	Any					     =     (
																										    LoRAAttnProcessor2_0 if hasattr(_SCREAMING_SNAKE_CASE			,    """scaled_dot_product_attention""") else LoRAAttnProcessor
																										)
																										self.assertIsInstance(module.processor			,    _SCREAMING_SNAKE_CASE)




		@unittest.skipIf(torch_device != """cuda"""			,    """This test is supposed to run on GPU""")
		def 	_snake_case	(  self					:Dict)					->			Dict:






								'''simple docstring'''






								with tempfile.TemporaryDirectory() as tmpdirname:
														self.create_lora_weight_file(_SCREAMING_SNAKE_CASE)

														UpperCamelCase_     ,UpperCamelCase_     :	Union[str, Any]					     =     self.get_dummy_components()
														UpperCamelCase_     :	Optional[int]					     =     StableDiffusionPipeline(**_SCREAMING_SNAKE_CASE)
														UpperCamelCase_     :	List[Any]					     =     sd_pipe.to(_SCREAMING_SNAKE_CASE)
														sd_pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE)

														# enable XFormers
														sd_pipe.enable_xformers_memory_efficient_attention()

														# check if xFormers attention processors are used
														for _, module in sd_pipe.unet.named_modules():
																				if isinstance(_SCREAMING_SNAKE_CASE			,    _SCREAMING_SNAKE_CASE):
																										self.assertIsInstance(module.processor			,    _SCREAMING_SNAKE_CASE)

            # load LoRA weight file
														sd_pipe.load_lora_weights(_SCREAMING_SNAKE_CASE)

														# check if lora attention processors are used
														for _, module in sd_pipe.unet.named_modules():
																				if isinstance(_SCREAMING_SNAKE_CASE			,    _SCREAMING_SNAKE_CASE):
																										self.assertIsInstance(module.processor			,    _SCREAMING_SNAKE_CASE)





		@unittest.skipIf(torch_device != """cuda"""			,    """This test is supposed to run on GPU""")
		def 	_snake_case	(  self					:Union[str, Any])					->			str:






								'''simple docstring'''






								UpperCamelCase_     ,UpperCamelCase_     :	str					     =     self.get_dummy_components()
								UpperCamelCase_     :	List[str]					     =     StableDiffusionPipeline(**_SCREAMING_SNAKE_CASE)
								UpperCamelCase_     :	Dict					     =     sd_pipe.to(_SCREAMING_SNAKE_CASE)
								sd_pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE)

								UpperCamelCase_     ,UpperCamelCase_     ,UpperCamelCase_     :	List[str]					     =     self.get_dummy_inputs()

								# enable XFormers
								sd_pipe.enable_xformers_memory_efficient_attention()

								UpperCamelCase_     :	List[Any]					     =     sd_pipe(**_SCREAMING_SNAKE_CASE).images
								UpperCamelCase_     :	List[str]					     =     original_images[0, -3:, -3:, -1]

								with tempfile.TemporaryDirectory() as tmpdirname:
														LoraLoaderMixin.save_lora_weights(
														    save_directory=_SCREAMING_SNAKE_CASE			,    unet_lora_layers=lora_components["""unet_lora_layers"""]			,    text_encoder_lora_layers=lora_components["""text_encoder_lora_layers"""]			,    )
														self.assertTrue(os.path.isfile(os.path.join(_SCREAMING_SNAKE_CASE			,    """pytorch_lora_weights.bin""")))
														sd_pipe.load_lora_weights(_SCREAMING_SNAKE_CASE)

								UpperCamelCase_     :	str					     =     sd_pipe(**_SCREAMING_SNAKE_CASE).images
								UpperCamelCase_     :	Tuple					     =     lora_images[0, -3:, -3:, -1]

								# Outputs shouldn't match.
								self.assertFalse(torch.allclose(torch.from_numpy(_SCREAMING_SNAKE_CASE)			,    torch.from_numpy(_SCREAMING_SNAKE_CASE)))






'''simple docstring'''


__SCREAMING_SNAKE_CASE						=      {hex(i)[2:]: i for i in range(16)}  # Use [:2] to strip off the leading '0x'
def 					__magic_name__(       UpperCAmelCase__ :       str	):
						UpperCamelCase_     :	str					     =     hex_string.strip().lower()
						if not hex_string:
												raise ValueError("""Empty string was passed to the function"""	)
						UpperCamelCase_     :	Dict					     =     hex_string[0] == """-"""
						if is_negative:
												UpperCamelCase_     :	List[str]					     =     hex_string[1:]
						if not all(char in hex_table for char in hex_string	):
												raise ValueError("""Non-hexadecimal value was passed to the function"""	)
						UpperCamelCase_     :	int					     =     0
						for char in hex_string:
												UpperCamelCase_     :	Any					     =     16 * decimal_number + hex_table[char]
						return -decimal_number if is_negative else decimal_number


if __name__ == "__main__":
	from doctest import testmod

	testmod()




