



"""simple docstring"""





import string
def        a__     (				lowerCAmelCase__				):



      for key in range(len(string.ascii_uppercase				)				):
            UpperCAmelCase_      			=							""
            for symbol in message:
                  if symbol in string.ascii_uppercase:
                        UpperCAmelCase_      			=							string.ascii_uppercase.find(lowerCAmelCase__				)
                        UpperCAmelCase_      			=							num - key
                        if num < 0:
                              UpperCAmelCase_      			=							num + len(string.ascii_uppercase				)
                        UpperCAmelCase_      			=							translated + string.ascii_uppercase[num]
                  else:
                        UpperCAmelCase_      			=							translated + symbol
            print(f"""Decryption using Key #{key}: {translated}"""				)
def        a__     (				):
      UpperCAmelCase_      			=							input("Encrypted message: "				)
      UpperCAmelCase_      			=							message.upper()
      decrypt(lowerCAmelCase__				)


if __name__ == "__main__":
  import doctest

  doctest.testmod()
  main()









"""simple docstring"""





import argparse
import io

import requests
import torch
from omegaconf import OmegaConf

from diffusers import AutoencoderKL
from diffusers.pipelines.stable_diffusion.convert_from_ckpt import (
    assign_to_checkpoint,
    conv_attn_to_linear,
    create_vae_diffusers_config,
    renew_vae_attention_paths,
    renew_vae_resnet_paths,
)
def        a__     (				lowerCAmelCase__     ,      lowerCAmelCase__				):
      UpperCAmelCase_      			=							checkpoint

      UpperCAmelCase_      			=							{}

      UpperCAmelCase_      			=							vae_state_dict["encoder.conv_in.weight"]
      UpperCAmelCase_      			=							vae_state_dict["encoder.conv_in.bias"]
      UpperCAmelCase_      			=							vae_state_dict["encoder.conv_out.weight"]
      UpperCAmelCase_      			=							vae_state_dict["encoder.conv_out.bias"]
      UpperCAmelCase_      			=							vae_state_dict["encoder.norm_out.weight"]
      UpperCAmelCase_      			=							vae_state_dict["encoder.norm_out.bias"]

      UpperCAmelCase_      			=							vae_state_dict["decoder.conv_in.weight"]
      UpperCAmelCase_      			=							vae_state_dict["decoder.conv_in.bias"]
      UpperCAmelCase_      			=							vae_state_dict["decoder.conv_out.weight"]
      UpperCAmelCase_      			=							vae_state_dict["decoder.conv_out.bias"]
      UpperCAmelCase_      			=							vae_state_dict["decoder.norm_out.weight"]
      UpperCAmelCase_      			=							vae_state_dict["decoder.norm_out.bias"]

      UpperCAmelCase_      			=							vae_state_dict["quant_conv.weight"]
      UpperCAmelCase_      			=							vae_state_dict["quant_conv.bias"]
      UpperCAmelCase_      			=							vae_state_dict["post_quant_conv.weight"]
      UpperCAmelCase_      			=							vae_state_dict["post_quant_conv.bias"]

      # Retrieves the keys for the encoder down blocks only
      UpperCAmelCase_      			=							len({".".join(layer.split("."				)[:3]				) for layer in vae_state_dict if "encoder.down" in layer}				)
      UpperCAmelCase_      			=							{
          layer_id: [key for key in vae_state_dict if f"""down.{layer_id}""" in key] for layer_id in range(lowerCAmelCase__				)
      }

      # Retrieves the keys for the decoder up blocks only
      UpperCAmelCase_      			=							len({".".join(layer.split("."				)[:3]				) for layer in vae_state_dict if "decoder.up" in layer}				)
      UpperCAmelCase_      			=							{
          layer_id: [key for key in vae_state_dict if f"""up.{layer_id}""" in key] for layer_id in range(lowerCAmelCase__				)
      }

      for i in range(lowerCAmelCase__				):
            UpperCAmelCase_      			=							[key for key in down_blocks[i] if f"""down.{i}""" in key and f"""down.{i}.downsample""" not in key]

            if f"""encoder.down.{i}.downsample.conv.weight""" in vae_state_dict:
                  UpperCAmelCase_      			=							vae_state_dict.pop(
                      f"""encoder.down.{i}.downsample.conv.weight"""				)
                  UpperCAmelCase_      			=							vae_state_dict.pop(
                      f"""encoder.down.{i}.downsample.conv.bias"""				)

            UpperCAmelCase_      			=							renew_vae_resnet_paths(lowerCAmelCase__				)
            UpperCAmelCase_      			=							{"old": f"""down.{i}.block""", "new": f"""down_blocks.{i}.resnets"""}
            assign_to_checkpoint(lowerCAmelCase__     ,      lowerCAmelCase__     ,      lowerCAmelCase__     ,      additional_replacements=[meta_path]     ,      config=lowerCAmelCase__				)

      UpperCAmelCase_      			=							[key for key in vae_state_dict if "encoder.mid.block" in key]
      UpperCAmelCase_      			=							2
      for i in range(1     ,      num_mid_res_blocks + 1				):
            UpperCAmelCase_      			=							[key for key in mid_resnets if f"""encoder.mid.block_{i}""" in key]

            UpperCAmelCase_      			=							renew_vae_resnet_paths(lowerCAmelCase__				)
            UpperCAmelCase_      			=							{"old": f"""mid.block_{i}""", "new": f"""mid_block.resnets.{i - 1}"""}
            assign_to_checkpoint(lowerCAmelCase__     ,      lowerCAmelCase__     ,      lowerCAmelCase__     ,      additional_replacements=[meta_path]     ,      config=lowerCAmelCase__				)

      UpperCAmelCase_      			=							[key for key in vae_state_dict if "encoder.mid.attn" in key]
      UpperCAmelCase_      			=							renew_vae_attention_paths(lowerCAmelCase__				)
      UpperCAmelCase_      			=							{"old": "mid.attn_1", "new": "mid_block.attentions.0"}
      assign_to_checkpoint(lowerCAmelCase__     ,      lowerCAmelCase__     ,      lowerCAmelCase__     ,      additional_replacements=[meta_path]     ,      config=lowerCAmelCase__				)
      conv_attn_to_linear(lowerCAmelCase__				)

      for i in range(lowerCAmelCase__				):
            UpperCAmelCase_      			=							num_up_blocks - 1 - i
            UpperCAmelCase_      			=							[
                key for key in up_blocks[block_id] if f"""up.{block_id}""" in key and f"""up.{block_id}.upsample""" not in key
            ]

            if f"""decoder.up.{block_id}.upsample.conv.weight""" in vae_state_dict:
                  UpperCAmelCase_      			=							vae_state_dict[
                      f"""decoder.up.{block_id}.upsample.conv.weight"""
                  ]
                  UpperCAmelCase_      			=							vae_state_dict[
                      f"""decoder.up.{block_id}.upsample.conv.bias"""
                  ]

            UpperCAmelCase_      			=							renew_vae_resnet_paths(lowerCAmelCase__				)
            UpperCAmelCase_      			=							{"old": f"""up.{block_id}.block""", "new": f"""up_blocks.{i}.resnets"""}
            assign_to_checkpoint(lowerCAmelCase__     ,      lowerCAmelCase__     ,      lowerCAmelCase__     ,      additional_replacements=[meta_path]     ,      config=lowerCAmelCase__				)

      UpperCAmelCase_      			=							[key for key in vae_state_dict if "decoder.mid.block" in key]
      UpperCAmelCase_      			=							2
      for i in range(1     ,      num_mid_res_blocks + 1				):
            UpperCAmelCase_      			=							[key for key in mid_resnets if f"""decoder.mid.block_{i}""" in key]

            UpperCAmelCase_      			=							renew_vae_resnet_paths(lowerCAmelCase__				)
            UpperCAmelCase_      			=							{"old": f"""mid.block_{i}""", "new": f"""mid_block.resnets.{i - 1}"""}
            assign_to_checkpoint(lowerCAmelCase__     ,      lowerCAmelCase__     ,      lowerCAmelCase__     ,      additional_replacements=[meta_path]     ,      config=lowerCAmelCase__				)

      UpperCAmelCase_      			=							[key for key in vae_state_dict if "decoder.mid.attn" in key]
      UpperCAmelCase_      			=							renew_vae_attention_paths(lowerCAmelCase__				)
      UpperCAmelCase_      			=							{"old": "mid.attn_1", "new": "mid_block.attentions.0"}
      assign_to_checkpoint(lowerCAmelCase__     ,      lowerCAmelCase__     ,      lowerCAmelCase__     ,      additional_replacements=[meta_path]     ,      config=lowerCAmelCase__				)
      conv_attn_to_linear(lowerCAmelCase__				)
      return new_checkpoint
def        a__     (				lowerCAmelCase__     ,      lowerCAmelCase__     ,      ):
      # Only support V1
      UpperCAmelCase_      			=							requests.get(
          " https://raw.githubusercontent.com/CompVis/stable-diffusion/main/configs/stable-diffusion/v1-inference.yaml"				)
      UpperCAmelCase_      			=							io.BytesIO(r.content				)

      UpperCAmelCase_      			=							OmegaConf.load(lowerCAmelCase__				)
      UpperCAmelCase_      			=							512
      UpperCAmelCase_      			=							"cuda" if torch.cuda.is_available() else "cpu"
      if checkpoint_path.endswith("safetensors"				):
            from safetensors import safe_open

            UpperCAmelCase_      			=							{}
            with safe_open(lowerCAmelCase__     ,      framework="pt"     ,      device="cpu"				) as f:
                  for key in f.keys():
                        UpperCAmelCase_      			=							f.get_tensor(lowerCAmelCase__				)
      else:
            UpperCAmelCase_      			=							torch.load(lowerCAmelCase__     ,      map_location=lowerCAmelCase__				)["state_dict"]

      # Convert the VAE model.
      UpperCAmelCase_      			=							create_vae_diffusers_config(lowerCAmelCase__     ,      image_size=lowerCAmelCase__				)
      UpperCAmelCase_      			=							custom_convert_ldm_vae_checkpoint(lowerCAmelCase__     ,      lowerCAmelCase__				)

      UpperCAmelCase_      			=							AutoencoderKL(**lowerCAmelCase__				)
      vae.load_state_dict(lowerCAmelCase__				)
      vae.save_pretrained(lowerCAmelCase__				)


if __name__ == "__main__":
  lowerCamelCase       	=						argparse.ArgumentParser()

  parser.add_argument("""--vae_pt_path""", default=None, type=str, required=True, help="""Path to the VAE.pt to convert.""")
  parser.add_argument("""--dump_path""", default=None, type=str, required=True, help="""Path to the VAE.pt to convert.""")

  lowerCamelCase       	=						parser.parse_args()

  vae_pt_to_vae_diffuser(args.vae_pt_path, args.dump_path)




