






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 						A_					(						lowercase_			)				->List[str]:







 """simple docstring"""

 SCREAMING_SNAKE_CASE				    =		{}
 for name in unet.attn_processors.keys():
  SCREAMING_SNAKE_CASE				    =		None if name.endswith('attn1.processor'			) else unet.config.cross_attention_dim
  if name.startswith('mid_block'			):
   SCREAMING_SNAKE_CASE				    =		unet.config.block_out_channels[-1]
  elif name.startswith('up_blocks'			):
   SCREAMING_SNAKE_CASE				    =		int(name[len('up_blocks.'			)]			)
   SCREAMING_SNAKE_CASE				    =		list(reversed(unet.config.block_out_channels			)			)[block_id]
  elif name.startswith('down_blocks'			):
   SCREAMING_SNAKE_CASE				    =		int(name[len('down_blocks.'			)]			)
   SCREAMING_SNAKE_CASE				    =		unet.config.block_out_channels[block_id]
  SCREAMING_SNAKE_CASE				    =		(
      LoRAAttnProcessor2_0 if hasattr(lowercase_	,  'scaled_dot_product_attention'			) else LoRAAttnProcessor
  )
  SCREAMING_SNAKE_CASE				    =		lora_attn_processor_class(
      hidden_size=lowercase_	,  cross_attention_dim=lowercase_			)
 SCREAMING_SNAKE_CASE				    =		AttnProcsLayers(lowercase_			)
 return lora_attn_procs, unet_lora_layers





def 						A_					(						lowercase_			)				->Union[str, Any]:







 """simple docstring"""

 SCREAMING_SNAKE_CASE				    =		{}
 SCREAMING_SNAKE_CASE				    =		(
     LoRAAttnProcessor2_0 if hasattr(lowercase_	,  'scaled_dot_product_attention'			) else LoRAAttnProcessor
 )
 for name, module in text_encoder.named_modules():
  if name.endswith(lowercase_			):
   SCREAMING_SNAKE_CASE				    =		lora_attn_processor_class(
       hidden_size=module.out_proj.out_features	,  cross_attention_dim=lowercase_			)
 return text_lora_attn_procs





def 						A_					(						lowercase_			)				->int:







 """simple docstring"""

 SCREAMING_SNAKE_CASE				    =		create_text_encoder_lora_attn_procs(lowercase_			)
 SCREAMING_SNAKE_CASE				    =		AttnProcsLayers(lowercase_			)
 return text_encoder_lora_layers





def 						A_					(						lowercase_	,  lowercase_=False			)				->Optional[Any]:







 """simple docstring"""

 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				    =		(
        torch.randn_like(layer_module.up.weight			)
        if randn_weight
        else torch.zeros_like(layer_module.up.weight			)
    )
    SCREAMING_SNAKE_CASE				    =		torch.nn.Parameter(lowercase_			)
class 	a_(		unittest.TestCase	):



     """simple docstring"""



     def     __UpperCamelCase						(		self					:	Dict)							->	str:

      """simple docstring"""
      torch.manual_seed(0)
      SCREAMING_SNAKE_CASE				    =		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				    =		DDIMScheduler(
          beta_start=0.0_00_85  ,  beta_end=0.0_12  ,  beta_schedule='scaled_linear'  ,  clip_sample=lowerCAmelCase__  ,  set_alpha_to_one=lowerCAmelCase__  ,  steps_offset=1  ,  )
      torch.manual_seed(0)
      SCREAMING_SNAKE_CASE				    =		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				    =		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				    =		CLIPTextModel(lowerCAmelCase__)
      SCREAMING_SNAKE_CASE				    =		CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip')

      SCREAMING_SNAKE_CASE    ,   SCREAMING_SNAKE_CASE				    =		create_unet_lora_layers(lowerCAmelCase__)
      SCREAMING_SNAKE_CASE				    =		create_text_encoder_lora_layers(lowerCAmelCase__)

      SCREAMING_SNAKE_CASE				    =		{
          'unet': unet,
          'scheduler': scheduler,
          'vae': vae,
          'text_encoder': text_encoder,
          'tokenizer': tokenizer,
          'safety_checker': None,
          'feature_extractor': None,
      }
      SCREAMING_SNAKE_CASE				    =		{
          '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					:	List[str])							->	Tuple:

      """simple docstring"""
      SCREAMING_SNAKE_CASE				    =		1
      SCREAMING_SNAKE_CASE				    =		1_0
      SCREAMING_SNAKE_CASE				    =		4
      SCREAMING_SNAKE_CASE				    =		(3_2, 3_2)

      SCREAMING_SNAKE_CASE				    =		torch.manual_seed(0)
      SCREAMING_SNAKE_CASE				    =		floats_tensor((batch_size, num_channels) + sizes)
      SCREAMING_SNAKE_CASE				    =		torch.randint(1  ,  lowerCAmelCase__  ,  size=(batch_size, sequence_length)  ,  generator=lowerCAmelCase__)

      SCREAMING_SNAKE_CASE				    =		{
          '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					:	List[str])							->	List[Any]:

      """simple docstring"""
      SCREAMING_SNAKE_CASE				    =		7_7

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

      SCREAMING_SNAKE_CASE				    =		{}
      SCREAMING_SNAKE_CASE				    =		inputs
      return prepared_inputs





     def     __UpperCamelCase						(		self					:	int  ,  lowerCAmelCase__					:	List[Any])							->	Union[str, Any]:

      """simple docstring"""
      SCREAMING_SNAKE_CASE    ,   SCREAMING_SNAKE_CASE				    =		self.get_dummy_components()
      LoraLoaderMixin.save_lora_weights(
          save_directory=lowerCAmelCase__  ,  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(lowerCAmelCase__  ,  'pytorch_lora_weights.bin')))





     def     __UpperCamelCase						(		self					:	Any)							->	Tuple:

      """simple docstring"""
      SCREAMING_SNAKE_CASE    ,   SCREAMING_SNAKE_CASE				    =		self.get_dummy_components()
      SCREAMING_SNAKE_CASE				    =		StableDiffusionPipeline(**lowerCAmelCase__)
      SCREAMING_SNAKE_CASE				    =		sd_pipe.to(lowerCAmelCase__)
      sd_pipe.set_progress_bar_config(disable=lowerCAmelCase__)

      SCREAMING_SNAKE_CASE    ,   SCREAMING_SNAKE_CASE    ,   SCREAMING_SNAKE_CASE				    =		self.get_dummy_inputs()

      SCREAMING_SNAKE_CASE				    =		sd_pipe(**lowerCAmelCase__).images
      SCREAMING_SNAKE_CASE				    =		original_images[0, -3:, -3:, -1]

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

      SCREAMING_SNAKE_CASE				    =		sd_pipe(**lowerCAmelCase__).images
      SCREAMING_SNAKE_CASE				    =		lora_images[0, -3:, -3:, -1]

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





     def     __UpperCamelCase						(		self					:	Tuple)							->	Tuple:

      """simple docstring"""
      SCREAMING_SNAKE_CASE    ,   SCREAMING_SNAKE_CASE				    =		self.get_dummy_components()
      SCREAMING_SNAKE_CASE				    =		StableDiffusionPipeline(**lowerCAmelCase__)
      SCREAMING_SNAKE_CASE				    =		sd_pipe.to(lowerCAmelCase__)
      sd_pipe.set_progress_bar_config(disable=lowerCAmelCase__)

      SCREAMING_SNAKE_CASE    ,   SCREAMING_SNAKE_CASE    ,   SCREAMING_SNAKE_CASE				    =		self.get_dummy_inputs()

      SCREAMING_SNAKE_CASE				    =		sd_pipe(**lowerCAmelCase__).images
      SCREAMING_SNAKE_CASE				    =		original_images[0, -3:, -3:, -1]

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

      SCREAMING_SNAKE_CASE				    =		sd_pipe(**lowerCAmelCase__).images
      SCREAMING_SNAKE_CASE				    =		lora_images[0, -3:, -3:, -1]

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





     def     __UpperCamelCase						(		self					:	List[str])							->	List[str]:

      """simple docstring"""
      SCREAMING_SNAKE_CASE    ,   SCREAMING_SNAKE_CASE				    =		self.get_dummy_components()
      SCREAMING_SNAKE_CASE				    =		lora_components['unet_lora_attn_procs']
      SCREAMING_SNAKE_CASE				    =		StableDiffusionPipeline(**lowerCAmelCase__)
      SCREAMING_SNAKE_CASE				    =		sd_pipe.to(lowerCAmelCase__)
      sd_pipe.set_progress_bar_config(disable=lowerCAmelCase__)

      SCREAMING_SNAKE_CASE    ,   SCREAMING_SNAKE_CASE    ,   SCREAMING_SNAKE_CASE				    =		self.get_dummy_inputs()

      SCREAMING_SNAKE_CASE				    =		sd_pipe(**lowerCAmelCase__).images
      SCREAMING_SNAKE_CASE				    =		original_images[0, -3:, -3:, -1]

      with tempfile.TemporaryDirectory() as tmpdirname:
       SCREAMING_SNAKE_CASE				    =		sd_pipe.unet
       unet.set_attn_processor(lowerCAmelCase__)
       unet.save_attn_procs(lowerCAmelCase__)
       self.assertTrue(os.path.isfile(os.path.join(lowerCAmelCase__  ,  'pytorch_lora_weights.bin')))
       sd_pipe.load_lora_weights(lowerCAmelCase__)

      SCREAMING_SNAKE_CASE				    =		sd_pipe(**lowerCAmelCase__).images
      SCREAMING_SNAKE_CASE				    =		lora_images[0, -3:, -3:, -1]

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





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

      """simple docstring"""
      SCREAMING_SNAKE_CASE    ,   SCREAMING_SNAKE_CASE				    =		self.get_dummy_components()
      SCREAMING_SNAKE_CASE				    =		StableDiffusionPipeline(**lowerCAmelCase__)

      SCREAMING_SNAKE_CASE				    =		self.get_dummy_tokens()

      # inference without lora
      SCREAMING_SNAKE_CASE				    =		pipe.text_encoder(**lowerCAmelCase__)[0]
      assert outputs_without_lora.shape == (1, 7_7, 3_2)

      # create lora_attn_procs with zeroed out up.weights
      SCREAMING_SNAKE_CASE				    =		create_text_encoder_lora_attn_procs(pipe.text_encoder)
      set_lora_up_weights(lowerCAmelCase__  ,  randn_weight=lowerCAmelCase__)

      # monkey patch
      pipe._modify_text_encoder(lowerCAmelCase__)

      # 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				    =		pipe.text_encoder(**lowerCAmelCase__)[0]
      assert outputs_with_lora.shape == (1, 7_7, 3_2)

      assert torch.allclose(
          lowerCAmelCase__  ,  lowerCAmelCase__), "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				    =		create_text_encoder_lora_attn_procs(pipe.text_encoder)
      set_lora_up_weights(lowerCAmelCase__  ,  randn_weight=lowerCAmelCase__)

      # monkey patch
      pipe._modify_text_encoder(lowerCAmelCase__)

      # 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				    =		pipe.text_encoder(**lowerCAmelCase__)[0]
      assert outputs_with_lora.shape == (1, 7_7, 3_2)

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





     def     __UpperCamelCase						(		self					:	Optional[int])							->	Optional[int]:

      """simple docstring"""
      SCREAMING_SNAKE_CASE    ,   SCREAMING_SNAKE_CASE				    =		self.get_dummy_components()
      SCREAMING_SNAKE_CASE				    =		StableDiffusionPipeline(**lowerCAmelCase__)

      SCREAMING_SNAKE_CASE				    =		self.get_dummy_tokens()

      # inference without lora
      SCREAMING_SNAKE_CASE				    =		pipe.text_encoder(**lowerCAmelCase__)[0]
      assert outputs_without_lora.shape == (1, 7_7, 3_2)

      # create lora_attn_procs with randn up.weights
      SCREAMING_SNAKE_CASE				    =		create_text_encoder_lora_attn_procs(pipe.text_encoder)
      set_lora_up_weights(lowerCAmelCase__  ,  randn_weight=lowerCAmelCase__)

      # monkey patch
      pipe._modify_text_encoder(lowerCAmelCase__)

      # 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				    =		pipe.text_encoder(**lowerCAmelCase__)[0]
      assert outputs_with_lora.shape == (1, 7_7, 3_2)

      assert not torch.allclose(
          lowerCAmelCase__  ,  lowerCAmelCase__), "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				    =		pipe.text_encoder(**lowerCAmelCase__)[0]
      assert outputs_without_lora_removed.shape == (1, 7_7, 3_2)

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





     def     __UpperCamelCase						(		self					:	Dict)							->	Any:

      """simple docstring"""
      SCREAMING_SNAKE_CASE    ,   SCREAMING_SNAKE_CASE				    =		self.get_dummy_components()
      SCREAMING_SNAKE_CASE				    =		StableDiffusionPipeline(**lowerCAmelCase__)
      SCREAMING_SNAKE_CASE				    =		sd_pipe.to(lowerCAmelCase__)
      sd_pipe.set_progress_bar_config(disable=lowerCAmelCase__)

      SCREAMING_SNAKE_CASE    ,   SCREAMING_SNAKE_CASE    ,   SCREAMING_SNAKE_CASE				    =		self.get_dummy_inputs()

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

      SCREAMING_SNAKE_CASE				    =		sd_pipe(**lowerCAmelCase__).images
      SCREAMING_SNAKE_CASE				    =		lora_images[0, -3:, -3:, -1]

      SCREAMING_SNAKE_CASE				    =		sd_pipe(**lowerCAmelCase__  ,  cross_attention_kwargs={'scale': 0.5}).images
      SCREAMING_SNAKE_CASE				    =		lora_images_with_scale[0, -3:, -3:, -1]

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





     def     __UpperCamelCase						(		self					:	str)							->	Any:

      """simple docstring"""
      with tempfile.TemporaryDirectory() as tmpdirname:
       self.create_lora_weight_file(lowerCAmelCase__)

       SCREAMING_SNAKE_CASE    ,   SCREAMING_SNAKE_CASE				    =		self.get_dummy_components()
       SCREAMING_SNAKE_CASE				    =		StableDiffusionPipeline(**lowerCAmelCase__)
       SCREAMING_SNAKE_CASE				    =		sd_pipe.to(lowerCAmelCase__)
       sd_pipe.set_progress_bar_config(disable=lowerCAmelCase__)

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

            # load LoRA weight file
       sd_pipe.load_lora_weights(lowerCAmelCase__)

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





     @unittest.skipIf(torch_device != 'cuda'  ,  'This test is supposed to run on GPU')
     def     __UpperCamelCase						(		self					:	str)							->	int:

      """simple docstring"""
      with tempfile.TemporaryDirectory() as tmpdirname:
       self.create_lora_weight_file(lowerCAmelCase__)

       SCREAMING_SNAKE_CASE    ,   SCREAMING_SNAKE_CASE				    =		self.get_dummy_components()
       SCREAMING_SNAKE_CASE				    =		StableDiffusionPipeline(**lowerCAmelCase__)
       SCREAMING_SNAKE_CASE				    =		sd_pipe.to(lowerCAmelCase__)
       sd_pipe.set_progress_bar_config(disable=lowerCAmelCase__)

       # 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(lowerCAmelCase__  ,  lowerCAmelCase__):
         self.assertIsInstance(module.processor  ,  lowerCAmelCase__)

            # load LoRA weight file
       sd_pipe.load_lora_weights(lowerCAmelCase__)

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





     @unittest.skipIf(torch_device != 'cuda'  ,  'This test is supposed to run on GPU')
     def     __UpperCamelCase						(		self					:	int)							->	Optional[int]:

      """simple docstring"""
      SCREAMING_SNAKE_CASE    ,   SCREAMING_SNAKE_CASE				    =		self.get_dummy_components()
      SCREAMING_SNAKE_CASE				    =		StableDiffusionPipeline(**lowerCAmelCase__)
      SCREAMING_SNAKE_CASE				    =		sd_pipe.to(lowerCAmelCase__)
      sd_pipe.set_progress_bar_config(disable=lowerCAmelCase__)

      SCREAMING_SNAKE_CASE    ,   SCREAMING_SNAKE_CASE    ,   SCREAMING_SNAKE_CASE				    =		self.get_dummy_inputs()

      # enable XFormers
      sd_pipe.enable_xformers_memory_efficient_attention()

      SCREAMING_SNAKE_CASE				    =		sd_pipe(**lowerCAmelCase__).images
      SCREAMING_SNAKE_CASE				    =		original_images[0, -3:, -3:, -1]

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

      SCREAMING_SNAKE_CASE				    =		sd_pipe(**lowerCAmelCase__).images
      SCREAMING_SNAKE_CASE				    =		lora_images[0, -3:, -3:, -1]

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





"""simple docstring"""






from __future__ import annotations



def     a_		(   lowerCamelCase			):
				for r in range(1   ,     lowerCamelCase			):
								UpperCAmelCase__			 =				[]
								for x in range(n - 1			):
												UpperCAmelCase__			 =				pow(lowerCamelCase   ,     lowerCamelCase   ,     lowerCamelCase			)
												if val in li:
																break
												li.append(lowerCamelCase			)
								else:
												return r
				return None


if __name__ == "__main__":
						lowerCAmelCase__    :    Any			=      int(input('Enter a prime number q: '))
						lowerCAmelCase__    :    List[str]			=      find_primitive(q)
						if a is None:
												print(F"""Cannot find the primitive for the value: {a!r}""")
						else:
												lowerCAmelCase__    :    str			=      int(input('Enter private key of A: '))
												lowerCAmelCase__    :    List[Any]			=      pow(a, a_private, q)
												lowerCAmelCase__    :    List[str]			=      int(input('Enter private key of B: '))
												lowerCAmelCase__    :    Any			=      pow(a, b_private, q)

												lowerCAmelCase__    :    Union[str, Any]			=      pow(b_public, a_private, q)
												lowerCAmelCase__    :    Tuple			=      pow(a_public, b_private, q)

												print('The key value generated by A is: ', a_secret)
												print('The key value generated by B is: ', b_secret)



