code: def paint(
      sampler,
      image,
      prompt,
      seed,
      scale,
      h,
      w,
      steps,
      num_samples=1,
      callback=None,
      eta=0.0,
      noise_level=None,
  ):
      device = (
          torch.device("cuda")
          if torch.cuda.is_available()
          else torch.device("cpu")
      )
      model = sampler.model
      seed_everything(seed)
      prng = np.random.RandomState(seed)
      start_code = prng.randn(num_samples, model.channels, h, w)
      start_code = torch.from_numpy(start_code).to(
          device=device, dtype=torch.float32
      )
  
      print(
          "Creating invisible watermark encoder (see https://github.com/ShieldMnt/invisible-watermark)..."
      )
      wm = "SDV2"
      wm_encoder = WatermarkEncoder()
      wm_encoder.set_watermark("bytes", wm.encode("utf-8"))
      with torch.no_grad(), torch.autocast("cuda"):
          batch = make_batch_sd(
              image, txt=prompt, device=device, num_samples=num_samples
          )
          c = model.cond_stage_model.encode(batch["txt"])
          c_cat = list()
          if isinstance(model, LatentUpscaleFinetuneDiffusion):
              for ck in model.concat_keys:
                  cc = batch[ck]
                  if exists(model.reshuffle_patch_size):
                      assert isinstance(model.reshuffle_patch_size, int)
                      cc = rearrange(
                          cc,
                          "b c (p1 h) (p2 w) -> b (p1 p2 c) h w",
                          p1=model.reshuffle_patch_size,
                          p2=model.reshuffle_patch_size,
                      )
                  c_cat.append(cc)
              c_cat = torch.cat(c_cat, dim=1)
              # cond
              cond = {"c_concat": [c_cat], "c_crossattn": [c]}
              # uncond cond
              uc_cross = model.get_unconditional_conditioning(
                  num_samples, ""
              )
              uc_full = {"c_concat": [c_cat], "c_crossattn": [uc_cross]}
          elif isinstance(model, LatentUpscaleDiffusion):
              x_augment, noise_level = make_noise_augmentation(
                  model, batch, noise_level
              )
              cond = {
                  "c_concat": [x_augment],
                  "c_crossattn": [c],
                  "c_adm": noise_level,
              }
              # uncond cond
              uc_cross = model.get_unconditional_conditioning(
                  num_samples, ""
              )
              uc_full = {
                  "c_concat": [x_augment],
                  "c_crossattn": [uc_cross],
                  "c_adm": noise_level,
              }
          else:
              raise NotImplementedError()
  
          shape = [model.channels, h, w]
          samples, intermediates = sampler.sample(
              steps,
              num_samples,
              shape,
              cond,
              verbose=False,
              eta=eta,
              unconditional_guidance_scale=scale,
              unconditional_conditioning=uc_full,
              x_T=start_code,
              callback=callback,
          )
      with torch.no_grad():
          x_samples_ddim = model.decode_first_stage(samples)
      result = torch.clamp(
          (x_samples_ddim + 1.0) / 2.0, min=0.0, max=1.0
      )
      result = result.cpu().numpy().transpose(0, 2, 3, 1) * 255
      st.text(f"upscaled image shape: {result.shape}")
      return [
          put_watermark(
              Image.fromarray(img.astype(np.uint8)), wm_encoder
          )
          for img in result
      ]
  
file_path: stablediffusion/scripts/streamlit/superresolution.py
imports: import sys
  import torch
  import numpy
  import streamlit
  from PIL import Image
  from omegaconf import OmegaConf
  from einops import repeat, rearrange
  from pytorch_lightning import seed_everything
  from imwatermark import WatermarkEncoder
  from scripts.txt2img import put_watermark
  from ldm.models.diffusion.ddim import DDIMSampler
  from ldm.models.diffusion.ddpm import LatentUpscaleDiffusion, LatentUpscaleFinetuneDiffusion
  from ldm.util import exists, instantiate_from_config
label_desc: Use image node_id 4 for calling a global function with example usage: paint(sampler, image, prompt, seed, scale, h, w, steps, num_samples, callback, eta, noise_level) and returns: unknown