

'''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      (				SCREAMING_SNAKE_CASE_					:     nn.Module   )							->       int:
      """simple docstring"""

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


def  __lowerCamelCase      (				SCREAMING_SNAKE_CASE_					:     nn.Module   )							->       str:
      """simple docstring"""

      SCREAMING_SNAKE_CASE_				:      Dict					=	{}
      SCREAMING_SNAKE_CASE_				:      List[Any]					=	(
          LoRAAttnProcessor2_0 if hasattr(SCREAMING_SNAKE_CASE_  ,  "scaled_dot_product_attention"   ) else LoRAAttnProcessor
      )
      for name, module in text_encoder.named_modules():
            if name.endswith(SCREAMING_SNAKE_CASE_   ):
                  SCREAMING_SNAKE_CASE_				:      Dict					=	lora_attn_processor_class(
                      hidden_size=module.out_proj.out_features  ,  cross_attention_dim=SCREAMING_SNAKE_CASE_   )
      return text_lora_attn_procs


def  __lowerCamelCase      (				SCREAMING_SNAKE_CASE_					:     nn.Module   )							->       Dict:
      """simple docstring"""

      SCREAMING_SNAKE_CASE_				:      Any					=	create_text_encoder_lora_attn_procs(SCREAMING_SNAKE_CASE_   )
      SCREAMING_SNAKE_CASE_				:      Tuple					=	AttnProcsLayers(SCREAMING_SNAKE_CASE_   )
      return text_encoder_lora_layers


def  __lowerCamelCase      (				SCREAMING_SNAKE_CASE_					:     Optional[Any]  ,  SCREAMING_SNAKE_CASE_					:     int=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_				:      Optional[Any]					=	(
                            torch.randn_like(layer_module.up.weight   )
                            if randn_weight
                            else torch.zeros_like(layer_module.up.weight   )
                        )
                        SCREAMING_SNAKE_CASE_				:      Optional[int]					=	torch.nn.Parameter(SCREAMING_SNAKE_CASE_   )





class      SCREAMING_SNAKE_CASE__      (    unittest.TestCase				):




    def   __lowerCamelCase				( self      ):






          """simple docstring"""






          torch.manual_seed(0      )
          SCREAMING_SNAKE_CASE_				:      int					=	UNetaDConditionModel(
              block_out_channels=(32, 64)    ,					layers_per_block=2    ,					sample_size=32    ,					in_channels=4    ,					out_channels=4    ,					down_block_types=("DownBlock2D", "CrossAttnDownBlock2D")    ,					up_block_types=("CrossAttnUpBlock2D", "UpBlock2D")    ,					cross_attention_dim=32    ,					)
          SCREAMING_SNAKE_CASE_				:      List[Any]					=	DDIMScheduler(
              beta_start=0.00085    ,					beta_end=0.012    ,					beta_schedule="scaled_linear"    ,					clip_sample=lowercase__    ,					set_alpha_to_one=lowercase__    ,					steps_offset=1    ,					)
          torch.manual_seed(0      )
          SCREAMING_SNAKE_CASE_				:      Optional[Any]					=	AutoencoderKL(
              block_out_channels=[32, 64]    ,					in_channels=3    ,					out_channels=3    ,					down_block_types=["DownEncoderBlock2D", "DownEncoderBlock2D"]    ,					up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D"]    ,					latent_channels=4    ,					)
          SCREAMING_SNAKE_CASE_				:      List[str]					=	CLIPTextConfig(
              bos_token_id=0    ,					eos_token_id=2    ,					hidden_size=32    ,					intermediate_size=37    ,					layer_norm_eps=1e-05    ,					num_attention_heads=4    ,					num_hidden_layers=5    ,					pad_token_id=1    ,					vocab_size=1000    ,					)
          SCREAMING_SNAKE_CASE_				:      Dict					=	CLIPTextModel(lowercase__      )
          SCREAMING_SNAKE_CASE_				:      List[str]					=	CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"      )

          SCREAMING_SNAKE_CASE_,						SCREAMING_SNAKE_CASE_				:      List[str]					=	create_unet_lora_layers(lowercase__      )
          SCREAMING_SNAKE_CASE_				:      List[str]					=	create_text_encoder_lora_layers(lowercase__      )

          SCREAMING_SNAKE_CASE_				:      int					=	{
              "unet": unet,
              "scheduler": scheduler,
              "vae": vae,
              "text_encoder": text_encoder,
              "tokenizer": tokenizer,
              "safety_checker": None,
              "feature_extractor": None,
          }
          SCREAMING_SNAKE_CASE_				:      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   __lowerCamelCase				( self      ):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_				:      Optional[int]					=	1
          SCREAMING_SNAKE_CASE_				:      int					=	10
          SCREAMING_SNAKE_CASE_				:      Tuple					=	4
          SCREAMING_SNAKE_CASE_				:      Optional[int]					=	(32, 32)

          SCREAMING_SNAKE_CASE_				:      List[Any]					=	torch.manual_seed(0      )
          SCREAMING_SNAKE_CASE_				:      str					=	floats_tensor((batch_size, num_channels) + sizes      )
          SCREAMING_SNAKE_CASE_				:      List[str]					=	torch.randint(1    ,					lowercase__    ,					size=(batch_size, sequence_length)    ,					generator=lowercase__      )

          SCREAMING_SNAKE_CASE_				:      Union[str, 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   __lowerCamelCase				( self      ):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_				:      str					=	77

          SCREAMING_SNAKE_CASE_				:      List[str]					=	torch.randint(2    ,					56    ,					size=(1, max_seq_length)    ,					generator=torch.manual_seed(0      )      )

          SCREAMING_SNAKE_CASE_				:      Any					=	{}
          SCREAMING_SNAKE_CASE_				:      str					=	inputs
          return prepared_inputs




    def   __lowerCamelCase				( self    ,					lowercase__      ):






          """simple docstring"""






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




    def   __lowerCamelCase				( self      ):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_,						SCREAMING_SNAKE_CASE_				:      Tuple					=	self.get_dummy_components()
          SCREAMING_SNAKE_CASE_				:      Optional[int]					=	StableDiffusionPipeline(**lowercase__      )
          SCREAMING_SNAKE_CASE_				:      Any					=	sd_pipe.to(lowercase__      )
          sd_pipe.set_progress_bar_config(disable=lowercase__      )

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

          SCREAMING_SNAKE_CASE_				:      Tuple					=	sd_pipe(**lowercase__      ).images
          SCREAMING_SNAKE_CASE_				:      Union[str, Any]					=	original_images[0, -3:, -3:, -1]

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

          SCREAMING_SNAKE_CASE_				:      Dict					=	sd_pipe(**lowercase__      ).images
          SCREAMING_SNAKE_CASE_				:      Optional[Any]					=	lora_images[0, -3:, -3:, -1]

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




    def   __lowerCamelCase				( self      ):






          """simple docstring"""






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

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

          SCREAMING_SNAKE_CASE_				:      str					=	sd_pipe(**lowercase__      ).images
          SCREAMING_SNAKE_CASE_				:      Union[str, Any]					=	original_images[0, -3:, -3:, -1]

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

          SCREAMING_SNAKE_CASE_				:      Tuple					=	sd_pipe(**lowercase__      ).images
          SCREAMING_SNAKE_CASE_				:      int					=	lora_images[0, -3:, -3:, -1]

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




    def   __lowerCamelCase				( self      ):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_,						SCREAMING_SNAKE_CASE_				:      Union[str, Any]					=	self.get_dummy_components()
          SCREAMING_SNAKE_CASE_				:      str					=	lora_components["unet_lora_attn_procs"]
          SCREAMING_SNAKE_CASE_				:      Optional[Any]					=	StableDiffusionPipeline(**lowercase__      )
          SCREAMING_SNAKE_CASE_				:      Optional[Any]					=	sd_pipe.to(lowercase__      )
          sd_pipe.set_progress_bar_config(disable=lowercase__      )

          SCREAMING_SNAKE_CASE_,						SCREAMING_SNAKE_CASE_,						SCREAMING_SNAKE_CASE_				:      Dict					=	self.get_dummy_inputs()

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

          with tempfile.TemporaryDirectory() as tmpdirname:
                SCREAMING_SNAKE_CASE_				:      str					=	sd_pipe.unet
                unet.set_attn_processor(lowercase__      )
                unet.save_attn_procs(lowercase__      )
                self.assertTrue(os.path.isfile(os.path.join(lowercase__    ,					"pytorch_lora_weights.bin"      )      )      )
                sd_pipe.load_lora_weights(lowercase__      )

          SCREAMING_SNAKE_CASE_				:      Optional[Any]					=	sd_pipe(**lowercase__      ).images
          SCREAMING_SNAKE_CASE_				:      Union[str, Any]					=	lora_images[0, -3:, -3:, -1]

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




    def   __lowerCamelCase				( self      ):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_,						SCREAMING_SNAKE_CASE_				:      Tuple					=	self.get_dummy_components()
          SCREAMING_SNAKE_CASE_				:      Optional[Any]					=	StableDiffusionPipeline(**lowercase__      )

          SCREAMING_SNAKE_CASE_				:      Dict					=	self.get_dummy_tokens()

          # inference without lora
          SCREAMING_SNAKE_CASE_				:      Union[str, Any]					=	pipe.text_encoder(**lowercase__      )[0]
          assert outputs_without_lora.shape == (1, 77, 32)

          # create lora_attn_procs with zeroed out up.weights
          SCREAMING_SNAKE_CASE_				:      List[Any]					=	create_text_encoder_lora_attn_procs(pipe.text_encoder      )
          set_lora_up_weights(lowercase__    ,					randn_weight=lowercase__      )

          # monkey patch
          pipe._modify_text_encoder(lowercase__      )

          # 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_				:      Union[str, Any]					=	pipe.text_encoder(**lowercase__      )[0]
          assert outputs_with_lora.shape == (1, 77, 32)

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

          # monkey patch
          pipe._modify_text_encoder(lowercase__      )

          # 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_				:      List[str]					=	pipe.text_encoder(**lowercase__      )[0]
          assert outputs_with_lora.shape == (1, 77, 32)

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




    def   __lowerCamelCase				( self      ):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_,						SCREAMING_SNAKE_CASE_				:      str					=	self.get_dummy_components()
          SCREAMING_SNAKE_CASE_				:      Any					=	StableDiffusionPipeline(**lowercase__      )

          SCREAMING_SNAKE_CASE_				:      str					=	self.get_dummy_tokens()

          # inference without lora
          SCREAMING_SNAKE_CASE_				:      List[str]					=	pipe.text_encoder(**lowercase__      )[0]
          assert outputs_without_lora.shape == (1, 77, 32)

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

          # monkey patch
          pipe._modify_text_encoder(lowercase__      )

          # 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_				:      str					=	pipe.text_encoder(**lowercase__      )[0]
          assert outputs_with_lora.shape == (1, 77, 32)

          assert not torch.allclose(
              lowercase__    ,					lowercase__      ), "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_				:      Union[str, Any]					=	pipe.text_encoder(**lowercase__      )[0]
          assert outputs_without_lora_removed.shape == (1, 77, 32)

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




    def   __lowerCamelCase				( self      ):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_,						SCREAMING_SNAKE_CASE_				:      str					=	self.get_dummy_components()
          SCREAMING_SNAKE_CASE_				:      str					=	StableDiffusionPipeline(**lowercase__      )
          SCREAMING_SNAKE_CASE_				:      int					=	sd_pipe.to(lowercase__      )
          sd_pipe.set_progress_bar_config(disable=lowercase__      )

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

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

          SCREAMING_SNAKE_CASE_				:      Optional[Any]					=	sd_pipe(**lowercase__      ).images
          SCREAMING_SNAKE_CASE_				:      List[str]					=	lora_images[0, -3:, -3:, -1]

          SCREAMING_SNAKE_CASE_				:      List[Any]					=	sd_pipe(**lowercase__    ,					cross_attention_kwargs={"scale": 0.5}      ).images
          SCREAMING_SNAKE_CASE_				:      int					=	lora_images_with_scale[0, -3:, -3:, -1]

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




    def   __lowerCamelCase				( self      ):






          """simple docstring"""






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

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

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

            # load LoRA weight file
                sd_pipe.load_lora_weights(lowercase__      )

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




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






          """simple docstring"""






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

                SCREAMING_SNAKE_CASE_,						SCREAMING_SNAKE_CASE_				:      Tuple					=	self.get_dummy_components()
                SCREAMING_SNAKE_CASE_				:      Optional[int]					=	StableDiffusionPipeline(**lowercase__      )
                SCREAMING_SNAKE_CASE_				:      str					=	sd_pipe.to(lowercase__      )
                sd_pipe.set_progress_bar_config(disable=lowercase__      )

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

            # load LoRA weight file
                sd_pipe.load_lora_weights(lowercase__      )

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







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






          """simple docstring"""






          SCREAMING_SNAKE_CASE_,						SCREAMING_SNAKE_CASE_				:      int					=	self.get_dummy_components()
          SCREAMING_SNAKE_CASE_				:      str					=	StableDiffusionPipeline(**lowercase__      )
          SCREAMING_SNAKE_CASE_				:      Optional[Any]					=	sd_pipe.to(lowercase__      )
          sd_pipe.set_progress_bar_config(disable=lowercase__      )

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

          # enable XFormers
          sd_pipe.enable_xformers_memory_efficient_attention()

          SCREAMING_SNAKE_CASE_				:      Union[str, Any]					=	sd_pipe(**lowercase__      ).images
          SCREAMING_SNAKE_CASE_				:      Dict					=	original_images[0, -3:, -3:, -1]

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

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

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




'''simple docstring'''






import requests
from bsa import BeautifulSoup


def  __lowerCamelCase      (				SCREAMING_SNAKE_CASE_					:     int  ,  SCREAMING_SNAKE_CASE_					:     str   )							->       str:
      """simple docstring"""

      SCREAMING_SNAKE_CASE_				:      List[str]					=	(
          "https://www.horoscope.com/us/horoscopes/general/"
          F"horoscope-general-daily-{day}.aspx?sign={zodiac_sign}"
      )
      SCREAMING_SNAKE_CASE_				:      Dict					=	BeautifulSoup(requests.get(SCREAMING_SNAKE_CASE_   ).content  ,  "html.parser"   )
      return soup.find("div"  ,  class_="main-horoscope"   ).p.text


if __name__ == "__main__":
      print('Daily Horoscope. \n')
      print(
          'enter your Zodiac sign number:\n',
          '1. Aries\n',
          '2. Taurus\n',
          '3. Gemini\n',
          '4. Cancer\n',
          '5. Leo\n',
          '6. Virgo\n',
          '7. Libra\n',
          '8. Scorpio\n',
          '9. Sagittarius\n',
          '10. Capricorn\n',
          '11. Aquarius\n',
          '12. Pisces\n',
      )
      snake_case_					  =	int(input('number> ').strip())
      print('choose some day:\n', 'yesterday\n', 'today\n', 'tomorrow\n')
      snake_case_					  =	input('enter the day> ')
      snake_case_					  =	horoscope(zodiac_sign, day)
      print(horoscope_text)

