



'''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 _lowercase   (  __A       ):



 '''simple docstring'''



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







def _lowercase   (  __A       ):



 '''simple docstring'''



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







def _lowercase   (  __A       ):



 '''simple docstring'''



 __UpperCamelCase				      =  create_text_encoder_lora_attn_procs(__A       )
 __UpperCamelCase				      =  AttnProcsLayers(__A       )
 return text_encoder_lora_layers







def _lowercase   (  __A							,__A=False       ):



 '''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"""       ):
    __UpperCamelCase				      =  (
        torch.randn_like(layer_module.up.weight       )
        if randn_weight
        else torch.zeros_like(layer_module.up.weight       )
    )
    __UpperCamelCase				      =  torch.nn.Parameter(__A       )






class        UpperCAmelCase__  (    unittest.TestCase):



 def    __lowerCamelCase				(  self			)  ->							str:
  torch.manual_seed(0			)
  __UpperCamelCase				      =  UNetaDConditionModel(
      block_out_channels=(3_2, 6_4)		,	layers_per_block=2		,	sample_size=3_2		,	in_channels=4		,	out_channels=4		,	down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""")		,	up_block_types=("""CrossAttnUpBlock2D""", """UpBlock2D""")		,	cross_attention_dim=3_2		,	)
  __UpperCamelCase				      =  DDIMScheduler(
      beta_start=0.00_085		,	beta_end=0.012		,	beta_schedule="""scaled_linear"""		,	clip_sample=lowercase		,	set_alpha_to_one=lowercase		,	steps_offset=1		,	)
  torch.manual_seed(0			)
  __UpperCamelCase				      =  AutoencoderKL(
      block_out_channels=[3_2, 6_4]		,	in_channels=3		,	out_channels=3		,	down_block_types=["""DownEncoderBlock2D""", """DownEncoderBlock2D"""]		,	up_block_types=["""UpDecoderBlock2D""", """UpDecoderBlock2D"""]		,	latent_channels=4		,	)
  __UpperCamelCase				      =  CLIPTextConfig(
      bos_token_id=0		,	eos_token_id=2		,	hidden_size=3_2		,	intermediate_size=3_7		,	layer_norm_eps=1E-05		,	num_attention_heads=4		,	num_hidden_layers=5		,	pad_token_id=1		,	vocab_size=1_0_0_0		,	)
  __UpperCamelCase				      =  CLIPTextModel(lowercase			)
  __UpperCamelCase				      =  CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""			)

  __UpperCamelCase      ,		__UpperCamelCase				      =  create_unet_lora_layers(lowercase			)
  __UpperCamelCase				      =  create_text_encoder_lora_layers(lowercase			)

  __UpperCamelCase				      =  {
      """unet""": unet,
      """scheduler""": scheduler,
      """vae""": vae,
      """text_encoder""": text_encoder,
      """tokenizer""": tokenizer,
      """safety_checker""": None,
      """feature_extractor""": None,
  }
  __UpperCamelCase				      =  {
      """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			)  ->							Any:
  __UpperCamelCase				      =  1
  __UpperCamelCase				      =  1_0
  __UpperCamelCase				      =  4
  __UpperCamelCase				      =  (3_2, 3_2)

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

  __UpperCamelCase				      =  {
      """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			)  ->							Any:
  __UpperCamelCase				      =  7_7

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

  __UpperCamelCase				      =  {}
  __UpperCamelCase				      =  inputs
  return prepared_inputs



 def    __lowerCamelCase				(  self		,	lowercase			)  ->							Union[str, Any]:
  __UpperCamelCase      ,		__UpperCamelCase				      =  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			)  ->							Dict:
  __UpperCamelCase      ,		__UpperCamelCase				      =  self.get_dummy_components()
  __UpperCamelCase				      =  StableDiffusionPipeline(**lowercase			)
  __UpperCamelCase				      =  sd_pipe.to(lowercase			)
  sd_pipe.set_progress_bar_config(disable=lowercase			)

  __UpperCamelCase      ,		__UpperCamelCase      ,		__UpperCamelCase				      =  self.get_dummy_inputs()

  __UpperCamelCase				      =  sd_pipe(**lowercase			).images
  __UpperCamelCase				      =  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			)

  __UpperCamelCase				      =  sd_pipe(**lowercase			).images
  __UpperCamelCase				      =  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			)  ->							Optional[Any]:
  __UpperCamelCase      ,		__UpperCamelCase				      =  self.get_dummy_components()
  __UpperCamelCase				      =  StableDiffusionPipeline(**lowercase			)
  __UpperCamelCase				      =  sd_pipe.to(lowercase			)
  sd_pipe.set_progress_bar_config(disable=lowercase			)

  __UpperCamelCase      ,		__UpperCamelCase      ,		__UpperCamelCase				      =  self.get_dummy_inputs()

  __UpperCamelCase				      =  sd_pipe(**lowercase			).images
  __UpperCamelCase				      =  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			)

  __UpperCamelCase				      =  sd_pipe(**lowercase			).images
  __UpperCamelCase				      =  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			)  ->							Dict:
  __UpperCamelCase      ,		__UpperCamelCase				      =  self.get_dummy_components()
  __UpperCamelCase				      =  lora_components["""unet_lora_attn_procs"""]
  __UpperCamelCase				      =  StableDiffusionPipeline(**lowercase			)
  __UpperCamelCase				      =  sd_pipe.to(lowercase			)
  sd_pipe.set_progress_bar_config(disable=lowercase			)

  __UpperCamelCase      ,		__UpperCamelCase      ,		__UpperCamelCase				      =  self.get_dummy_inputs()

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

  with tempfile.TemporaryDirectory() as tmpdirname:
   __UpperCamelCase				      =  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			)

  __UpperCamelCase				      =  sd_pipe(**lowercase			).images
  __UpperCamelCase				      =  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			)  ->							str:
  __UpperCamelCase      ,		__UpperCamelCase				      =  self.get_dummy_components()
  __UpperCamelCase				      =  StableDiffusionPipeline(**lowercase			)

  __UpperCamelCase				      =  self.get_dummy_tokens()

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

  # create lora_attn_procs with zeroed out up.weights
  __UpperCamelCase				      =  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
  __UpperCamelCase				      =  pipe.text_encoder(**lowercase			)[0]
  assert outputs_with_lora.shape == (1, 7_7, 3_2)

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

  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			)  ->							Optional[Any]:
  __UpperCamelCase      ,		__UpperCamelCase				      =  self.get_dummy_components()
  __UpperCamelCase				      =  StableDiffusionPipeline(**lowercase			)

  __UpperCamelCase				      =  self.get_dummy_tokens()

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

  # create lora_attn_procs with randn up.weights
  __UpperCamelCase				      =  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
  __UpperCamelCase				      =  pipe.text_encoder(**lowercase			)[0]
  assert outputs_with_lora.shape == (1, 7_7, 3_2)

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

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



 def    __lowerCamelCase				(  self			)  ->							int:
  __UpperCamelCase      ,		__UpperCamelCase				      =  self.get_dummy_components()
  __UpperCamelCase				      =  StableDiffusionPipeline(**lowercase			)
  __UpperCamelCase				      =  sd_pipe.to(lowercase			)
  sd_pipe.set_progress_bar_config(disable=lowercase			)

  __UpperCamelCase      ,		__UpperCamelCase      ,		__UpperCamelCase				      =  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			)

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

  __UpperCamelCase				      =  sd_pipe(**lowercase		,	cross_attention_kwargs={"""scale""": 0.5}			).images
  __UpperCamelCase				      =  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			)  ->							Union[str, Any]:



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

   __UpperCamelCase      ,		__UpperCamelCase				      =  self.get_dummy_components()
   __UpperCamelCase				      =  StableDiffusionPipeline(**lowercase			)
   __UpperCamelCase				      =  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			):
     __UpperCamelCase				      =  (
         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			)  ->							int:



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

   __UpperCamelCase      ,		__UpperCamelCase				      =  self.get_dummy_components()
   __UpperCamelCase				      =  StableDiffusionPipeline(**lowercase			)
   __UpperCamelCase				      =  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			)  ->							str:
  __UpperCamelCase      ,		__UpperCamelCase				      =  self.get_dummy_components()
  __UpperCamelCase				      =  StableDiffusionPipeline(**lowercase			)
  __UpperCamelCase				      =  sd_pipe.to(lowercase			)
  sd_pipe.set_progress_bar_config(disable=lowercase			)

  __UpperCamelCase      ,		__UpperCamelCase      ,		__UpperCamelCase				      =  self.get_dummy_inputs()

  # enable XFormers
  sd_pipe.enable_xformers_memory_efficient_attention()

  __UpperCamelCase				      =  sd_pipe(**lowercase			).images
  __UpperCamelCase				      =  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			)

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

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










'''simple docstring'''



a__						:			str										=			[chr(i) for i in range(3_2, 1_2_6)]
a__						:			List[Any]										=			list(range(len(alphabets)))
a__						:			Union[str, Any]										=			list(range(len(alphabets)))
a__						:			Dict										=			list(range(len(alphabets)))
a__						:			Union[str, Any]										=			list(reversed(range(len(alphabets))))
a__						:			List[str]										=			[]
a__						:			int										=			0







def _lowercase   (  ):



 '''simple docstring'''



 global gear_one_pos
 global gear_two_pos
 global gear_three_pos
 __UpperCamelCase				      =  gear_one[0]
 gear_one.append(__A       )
 del gear_one[0]
 gear_one_pos += 1
 if gear_one_pos % int(len(__A       )       ) == 0:
  __UpperCamelCase				      =  gear_two[0]
  gear_two.append(__A       )
  del gear_two[0]
  gear_two_pos += 1
  if gear_two_pos % int(len(__A       )       ) == 0:
   __UpperCamelCase				      =  gear_three[0]
   gear_three.append(__A       )
   del gear_three[0]
   gear_three_pos += 1







def _lowercase   (  __A       ):



 '''simple docstring'''



 __UpperCamelCase				      =  alphabets.index(__A       )
 __UpperCamelCase				      =  gear_one[target]
 __UpperCamelCase				      =  gear_two[target]
 __UpperCamelCase				      =  gear_three[target]
 __UpperCamelCase				      =  reflector[target]
 __UpperCamelCase				      =  gear_three.index(__A       )
 __UpperCamelCase				      =  gear_two.index(__A       )
 __UpperCamelCase				      =  gear_one.index(__A       )
 code.append(alphabets[target]       )
 rotator()


if __name__ == "__main__":
 a__						:			Any										=			list(input('Type your message:\n'))
 while True:
  try:
   a__						:			List[Any]										=			int(input('Please set token:(must be only digits)\n'))
   break
  except Exception as error:
   print(error)
 for _ in range(token):
  rotator()
 for j in decode:
  engine(j)
 print('\n' + ''.join(code))
 print(
     f'''\nYour Token is {token} please write it down.\nIf you want to decode '''
     'this message again you should input same digits as token!'
 )





