



'''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     lowerCAmelCase_       (     _lowerCamelCase:       nn.Module ):
		__SCREAMING_SNAKE_CASE	:		Any   	=		{}
		for name in unet.attn_processors.keys():
				__SCREAMING_SNAKE_CASE	:		Optional[Any]   	=		None if name.endswith("""attn1.processor""" ) else unet.config.cross_attention_dim
				if name.startswith("""mid_block""" ):
						__SCREAMING_SNAKE_CASE	:		List[Any]   	=		unet.config.block_out_channels[-1]
				elif name.startswith("""up_blocks""" ):
						__SCREAMING_SNAKE_CASE	:		Union[str, Any]   	=		int(name[len("""up_blocks.""" )] )
						__SCREAMING_SNAKE_CASE	:		Optional[int]   	=		list(reversed(unet.config.block_out_channels ) )[block_id]
				elif name.startswith("""down_blocks""" ):
						__SCREAMING_SNAKE_CASE	:		str   	=		int(name[len("""down_blocks.""" )] )
						__SCREAMING_SNAKE_CASE	:		str   	=		unet.config.block_out_channels[block_id]
				__SCREAMING_SNAKE_CASE	:		Tuple   	=		(
				    LoRAAttnProcessor2_0 if hasattr(_lowerCAmelCase	,				"""scaled_dot_product_attention""" ) else LoRAAttnProcessor
				)
				__SCREAMING_SNAKE_CASE	:		Optional[Any]   	=		lora_attn_processor_class(
				    hidden_size=_lowerCAmelCase	,				cross_attention_dim=_lowerCAmelCase )
		__SCREAMING_SNAKE_CASE	:		Optional[Any]   	=		AttnProcsLayers(_lowerCAmelCase )
		return lora_attn_procs, unet_lora_layers


def     lowerCAmelCase_       (     _lowerCamelCase:       nn.Module ):
		__SCREAMING_SNAKE_CASE	:		Any   	=		{}
		__SCREAMING_SNAKE_CASE	:		List[str]   	=		(
		    LoRAAttnProcessor2_0 if hasattr(_lowerCAmelCase	,				"""scaled_dot_product_attention""" ) else LoRAAttnProcessor
		)
		for name, module in text_encoder.named_modules():
				if name.endswith(_lowerCAmelCase ):
						__SCREAMING_SNAKE_CASE	:		List[Any]   	=		lora_attn_processor_class(
						    hidden_size=module.out_proj.out_features	,				cross_attention_dim=_lowerCAmelCase )
		return text_lora_attn_procs


def     lowerCAmelCase_       (     _lowerCamelCase:       nn.Module ):
		__SCREAMING_SNAKE_CASE	:		Dict   	=		create_text_encoder_lora_attn_procs(_lowerCAmelCase )
		__SCREAMING_SNAKE_CASE	:		Union[str, Any]   	=		AttnProcsLayers(_lowerCAmelCase )
		return text_encoder_lora_layers


def     lowerCAmelCase_       (     _lowerCamelCase:       List[str]	,				_lowerCamelCase:       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""" ):
								__SCREAMING_SNAKE_CASE	:		List[Any]   	=		(
								    torch.randn_like(layer_module.up.weight )
								    if randn_weight
								    else torch.zeros_like(layer_module.up.weight )
								)
								__SCREAMING_SNAKE_CASE	:		Optional[Any]   	=		torch.nn.Parameter(_lowerCAmelCase )






class 						_UpperCamelCase  (							unittest.TestCase   ):


			'''simple docstring'''

			def UpperCamelCase__ (							self					:			str						):





					"""simple docstring"""






					torch.manual_seed(0						)
					__SCREAMING_SNAKE_CASE	:		Optional[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							,					)
					__SCREAMING_SNAKE_CASE	:		Dict   	=		DDIMScheduler(
					    beta_start=0.0_00_85							,					beta_end=0.0_12							,					beta_schedule="""scaled_linear"""							,					clip_sample=__snake_case							,					set_alpha_to_one=__snake_case							,					steps_offset=1							,					)
					torch.manual_seed(0						)
					__SCREAMING_SNAKE_CASE	:		str   	=		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							,					)
					__SCREAMING_SNAKE_CASE	:		Union[str, Any]   	=		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							,					)
					__SCREAMING_SNAKE_CASE	:		Union[str, Any]   	=		CLIPTextModel(__snake_case						)
					__SCREAMING_SNAKE_CASE	:		List[str]   	=		CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""						)

					__SCREAMING_SNAKE_CASE	:		Tuple   	=		create_unet_lora_layers(__snake_case						)
					__SCREAMING_SNAKE_CASE	:		Union[str, Any]   	=		create_text_encoder_lora_layers(__snake_case						)

					__SCREAMING_SNAKE_CASE	:		Union[str, Any]   	=		{
					    '''unet''': unet,
					    '''scheduler''': scheduler,
					    '''vae''': vae,
					    '''text_encoder''': text_encoder,
					    '''tokenizer''': tokenizer,
					    '''safety_checker''': None,
					    '''feature_extractor''': None,
					}
					__SCREAMING_SNAKE_CASE	:		Dict   	=		{
					    '''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 UpperCamelCase__ (							self					:			Union[str, Any]						):





					"""simple docstring"""






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

					__SCREAMING_SNAKE_CASE	:		Tuple   	=		torch.manual_seed(0						)
					__SCREAMING_SNAKE_CASE	:		Optional[Any]   	=		floats_tensor((batch_size, num_channels) + sizes						)
					__SCREAMING_SNAKE_CASE	:		Tuple   	=		torch.randint(1							,					__snake_case							,					size=(batch_size, sequence_length)							,					generator=__snake_case						)

					__SCREAMING_SNAKE_CASE	:		int   	=		{
					    '''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 UpperCamelCase__ (							self					:			str						):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE	:		Tuple   	=		7_7

					__SCREAMING_SNAKE_CASE	:		Any   	=		torch.randint(2							,					5_6							,					size=(1, max_seq_length)							,					generator=torch.manual_seed(0						)						)

					__SCREAMING_SNAKE_CASE	:		Union[str, Any]   	=		{}
					__SCREAMING_SNAKE_CASE	:		Union[str, Any]   	=		inputs
					return prepared_inputs

			def UpperCamelCase__ (							self					:			Any							,					lowerCAmelCase__					:			Dict						):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE	:		Union[str, Any]   	=		self.get_dummy_components()
					LoraLoaderMixin.save_lora_weights(
					    save_directory=__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(__snake_case							,					"""pytorch_lora_weights.bin"""						)						)						)

			def UpperCamelCase__ (							self					:			List[str]						):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE	:		List[str]   	=		self.get_dummy_components()
					__SCREAMING_SNAKE_CASE	:		Any   	=		StableDiffusionPipeline(**__snake_case						)
					__SCREAMING_SNAKE_CASE	:		Dict   	=		sd_pipe.to(__snake_case						)
					sd_pipe.set_progress_bar_config(disable=__snake_case						)

					__SCREAMING_SNAKE_CASE	:		int   	=		self.get_dummy_inputs()

					__SCREAMING_SNAKE_CASE	:		List[Any]   	=		sd_pipe(**__snake_case						).images
					__SCREAMING_SNAKE_CASE	:		Optional[int]   	=		original_images[0, -3:, -3:, -1]

					with tempfile.TemporaryDirectory() as tmpdirname:
							LoraLoaderMixin.save_lora_weights(
							    save_directory=__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(__snake_case							,					"""pytorch_lora_weights.bin"""						)						)						)
							sd_pipe.load_lora_weights(__snake_case						)

					__SCREAMING_SNAKE_CASE	:		Optional[int]   	=		sd_pipe(**__snake_case						).images
					__SCREAMING_SNAKE_CASE	:		str   	=		lora_images[0, -3:, -3:, -1]

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

			def UpperCamelCase__ (							self					:			Any						):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE	:		int   	=		self.get_dummy_components()
					__SCREAMING_SNAKE_CASE	:		Optional[Any]   	=		StableDiffusionPipeline(**__snake_case						)
					__SCREAMING_SNAKE_CASE	:		Any   	=		sd_pipe.to(__snake_case						)
					sd_pipe.set_progress_bar_config(disable=__snake_case						)

					__SCREAMING_SNAKE_CASE	:		Optional[int]   	=		self.get_dummy_inputs()

					__SCREAMING_SNAKE_CASE	:		str   	=		sd_pipe(**__snake_case						).images
					__SCREAMING_SNAKE_CASE	:		Any   	=		original_images[0, -3:, -3:, -1]

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

					__SCREAMING_SNAKE_CASE	:		Any   	=		sd_pipe(**__snake_case						).images
					__SCREAMING_SNAKE_CASE	:		Optional[int]   	=		lora_images[0, -3:, -3:, -1]

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

			def UpperCamelCase__ (							self					:			List[str]						):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE	:		Tuple   	=		self.get_dummy_components()
					__SCREAMING_SNAKE_CASE	:		Optional[int]   	=		lora_components['''unet_lora_attn_procs''']
					__SCREAMING_SNAKE_CASE	:		Any   	=		StableDiffusionPipeline(**__snake_case						)
					__SCREAMING_SNAKE_CASE	:		List[str]   	=		sd_pipe.to(__snake_case						)
					sd_pipe.set_progress_bar_config(disable=__snake_case						)

					__SCREAMING_SNAKE_CASE	:		int   	=		self.get_dummy_inputs()

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

					with tempfile.TemporaryDirectory() as tmpdirname:
							__SCREAMING_SNAKE_CASE	:		List[Any]   	=		sd_pipe.unet
							unet.set_attn_processor(__snake_case						)
							unet.save_attn_procs(__snake_case						)
							self.assertTrue(os.path.isfile(os.path.join(__snake_case							,					"""pytorch_lora_weights.bin"""						)						)						)
							sd_pipe.load_lora_weights(__snake_case						)

					__SCREAMING_SNAKE_CASE	:		Dict   	=		sd_pipe(**__snake_case						).images
					__SCREAMING_SNAKE_CASE	:		Tuple   	=		lora_images[0, -3:, -3:, -1]

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

			def UpperCamelCase__ (							self					:			Optional[int]						):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE	:		Tuple   	=		self.get_dummy_components()
					__SCREAMING_SNAKE_CASE	:		Any   	=		StableDiffusionPipeline(**__snake_case						)

					__SCREAMING_SNAKE_CASE	:		Optional[Any]   	=		self.get_dummy_tokens()

					# inference without lora
					__SCREAMING_SNAKE_CASE	:		Optional[Any]   	=		pipe.text_encoder(**__snake_case						)[0]
					assert outputs_without_lora.shape == (1, 7_7, 3_2)

					# create lora_attn_procs with zeroed out up.weights
					__SCREAMING_SNAKE_CASE	:		str   	=		create_text_encoder_lora_attn_procs(pipe.text_encoder						)
					set_lora_up_weights(__snake_case							,					randn_weight=__snake_case						)

					# monkey patch
					pipe._modify_text_encoder(__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
					__SCREAMING_SNAKE_CASE	:		Any   	=		pipe.text_encoder(**__snake_case						)[0]
					assert outputs_with_lora.shape == (1, 7_7, 3_2)

					assert torch.allclose(
					    __snake_case							,					__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
					__SCREAMING_SNAKE_CASE	:		List[Any]   	=		create_text_encoder_lora_attn_procs(pipe.text_encoder						)
					set_lora_up_weights(__snake_case							,					randn_weight=__snake_case						)

					# monkey patch
					pipe._modify_text_encoder(__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
					__SCREAMING_SNAKE_CASE	:		Optional[int]   	=		pipe.text_encoder(**__snake_case						)[0]
					assert outputs_with_lora.shape == (1, 7_7, 3_2)

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

			def UpperCamelCase__ (							self					:			Optional[int]						):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE	:		Tuple   	=		self.get_dummy_components()
					__SCREAMING_SNAKE_CASE	:		Optional[int]   	=		StableDiffusionPipeline(**__snake_case						)

					__SCREAMING_SNAKE_CASE	:		Tuple   	=		self.get_dummy_tokens()

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

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

					# monkey patch
					pipe._modify_text_encoder(__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
					__SCREAMING_SNAKE_CASE	:		int   	=		pipe.text_encoder(**__snake_case						)[0]
					assert outputs_with_lora.shape == (1, 7_7, 3_2)

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

					# remove monkey patch
					pipe._remove_text_encoder_monkey_patch()

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

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

			def UpperCamelCase__ (							self					:			str						):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE	:		int   	=		self.get_dummy_components()
					__SCREAMING_SNAKE_CASE	:		Tuple   	=		StableDiffusionPipeline(**__snake_case						)
					__SCREAMING_SNAKE_CASE	:		Union[str, Any]   	=		sd_pipe.to(__snake_case						)
					sd_pipe.set_progress_bar_config(disable=__snake_case						)

					__SCREAMING_SNAKE_CASE	:		Union[str, Any]   	=		self.get_dummy_inputs()

					with tempfile.TemporaryDirectory() as tmpdirname:
							LoraLoaderMixin.save_lora_weights(
							    save_directory=__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(__snake_case							,					"""pytorch_lora_weights.bin"""						)						)						)
							sd_pipe.load_lora_weights(__snake_case						)

					__SCREAMING_SNAKE_CASE	:		str   	=		sd_pipe(**__snake_case						).images
					__SCREAMING_SNAKE_CASE	:		Union[str, Any]   	=		lora_images[0, -3:, -3:, -1]

					__SCREAMING_SNAKE_CASE	:		Dict   	=		sd_pipe(**__snake_case							,					cross_attention_kwargs={"""scale""": 0.5}						).images
					__SCREAMING_SNAKE_CASE	:		Dict   	=		lora_images_with_scale[0, -3:, -3:, -1]

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

			def UpperCamelCase__ (							self					:			Tuple						):





					"""simple docstring"""






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

							__SCREAMING_SNAKE_CASE	:		List[str]   	=		self.get_dummy_components()
							__SCREAMING_SNAKE_CASE	:		Tuple   	=		StableDiffusionPipeline(**__snake_case						)
							__SCREAMING_SNAKE_CASE	:		List[str]   	=		sd_pipe.to(__snake_case						)
							sd_pipe.set_progress_bar_config(disable=__snake_case						)

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

            # load LoRA weight file
							sd_pipe.load_lora_weights(__snake_case						)

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

			@unittest.skipIf(torch_device != """cuda"""							,					"""This test is supposed to run on GPU"""						)
			def UpperCamelCase__ (							self					:			List[str]						):





					"""simple docstring"""






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

							__SCREAMING_SNAKE_CASE	:		Tuple   	=		self.get_dummy_components()
							__SCREAMING_SNAKE_CASE	:		List[str]   	=		StableDiffusionPipeline(**__snake_case						)
							__SCREAMING_SNAKE_CASE	:		Any   	=		sd_pipe.to(__snake_case						)
							sd_pipe.set_progress_bar_config(disable=__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(__snake_case							,					__snake_case						):
											self.assertIsInstance(module.processor							,					__snake_case						)

            # load LoRA weight file
							sd_pipe.load_lora_weights(__snake_case						)

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



			@unittest.skipIf(torch_device != """cuda"""							,					"""This test is supposed to run on GPU"""						)
			def UpperCamelCase__ (							self					:			List[Any]						):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE	:		List[str]   	=		self.get_dummy_components()
					__SCREAMING_SNAKE_CASE	:		str   	=		StableDiffusionPipeline(**__snake_case						)
					__SCREAMING_SNAKE_CASE	:		Any   	=		sd_pipe.to(__snake_case						)
					sd_pipe.set_progress_bar_config(disable=__snake_case						)

					__SCREAMING_SNAKE_CASE	:		int   	=		self.get_dummy_inputs()

					# enable XFormers
					sd_pipe.enable_xformers_memory_efficient_attention()

					__SCREAMING_SNAKE_CASE	:		Tuple   	=		sd_pipe(**__snake_case						).images
					__SCREAMING_SNAKE_CASE	:		Dict   	=		original_images[0, -3:, -3:, -1]

					with tempfile.TemporaryDirectory() as tmpdirname:
							LoraLoaderMixin.save_lora_weights(
							    save_directory=__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(__snake_case							,					"""pytorch_lora_weights.bin"""						)						)						)
							sd_pipe.load_lora_weights(__snake_case						)

					__SCREAMING_SNAKE_CASE	:		List[Any]   	=		sd_pipe(**__snake_case						).images
					__SCREAMING_SNAKE_CASE	:		Optional[int]   	=		lora_images[0, -3:, -3:, -1]

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




'''simple docstring'''




UpperCamelCase__	:     List[Any]    =			10_00


def     lowerCAmelCase_       (     _lowerCamelCase:       float ):
		return x * x


def     lowerCAmelCase_       (     _lowerCamelCase:       Any	,				_lowerCamelCase:       float	,				_lowerCamelCase:       float	,				_lowerCamelCase:       int = 4 ):
		assert callable(
		    _lowerCamelCase ), F"the function(object) passed should be callable your input : {function}"
		assert isinstance(_lowerCamelCase	,				(float, int) ), F"a should be float or integer your input : {a}"
		assert isinstance(function(_lowerCamelCase )	,				(float, int) ), (
		    "the function should return integer or float return type of your function, "
		    F"{type(_lowerCamelCase )}"
		)
		assert isinstance(_lowerCamelCase	,				(float, int) ), F"b should be float or integer your input : {b}"
		assert (
		    isinstance(_lowerCamelCase	,				_lowerCamelCase ) and precision > 0
		), F"precision should be positive integer your input : {precision}"

		# just applying the formula of simpson for approximate integration written in
		# mentioned article in first comment of this file and above this function

		__SCREAMING_SNAKE_CASE	:		List[Any]   	=		(b - a) / N_STEPS
		__SCREAMING_SNAKE_CASE	:		List[Any]   	=		function(_lowerCamelCase ) + function(_lowerCamelCase )

		for i in range(1	,				_lowerCamelCase ):
				__SCREAMING_SNAKE_CASE	:		Union[str, Any]   	=		a + h * i
				result += function(_lowerCamelCase ) * (4 if i % 2 else 2)

		result *= h / 3
		return round(_lowerCamelCase	,				_lowerCamelCase )


if __name__ == "__main__":
						import doctest

						doctest.testmod()