code: def sample(
      self,
      S,
      batch_size,
      shape,
      conditioning=None,
      callback=None,
      normals_sequence=None,
      img_callback=None,
      quantize_x0=False,
      eta=0.0,
      mask=None,
      x0=None,
      temperature=1.0,
      noise_dropout=0.0,
      score_corrector=None,
      corrector_kwargs=None,
      verbose=True,
      x_T=None,
      log_every_t=100,
      unconditional_guidance_scale=1.0,
      unconditional_conditioning=None,
      # this has to come in the same format as the conditioning, # e.g. as encoded tokens, ...
      **kwargs,
  ):
      if conditioning is not None:
          if isinstance(conditioning, dict):
              ctmp = conditioning[list(conditioning.keys())[0]]
              while isinstance(ctmp, list):
                  ctmp = ctmp[0]
              cbs = ctmp.shape[0]
              if cbs != batch_size:
                  print(
                      f"Warning: Got {cbs} conditionings but batch-size is {batch_size}"
                  )
  
          elif isinstance(conditioning, list):
              for ctmp in conditioning:
                  if ctmp.shape[0] != batch_size:
                      print(
                          f"Warning: Got {cbs} conditionings but batch-size is {batch_size}"
                      )
  
          else:
              if conditioning.shape[0] != batch_size:
                  print(
                      f"Warning: Got {conditioning.shape[0]} conditionings but batch-size is {batch_size}"
                  )
  
      # sampling
      C, H, W = shape
      size = (batch_size, C, H, W)
      # print(f'Data shape for UniPC sampling is {size}')
  
      device = self.model.betas.device
      if x_T is None:
          img = torch.randn(size, device=device)
      else:
          img = x_T
  
      ns = NoiseScheduleVP(
          "discrete", alphas_cumprod=self.alphas_cumprod
      )
  
      # SD 1.X is "noise", SD 2.X is "v"
      model_type = (
          "v" if self.model.parameterization == "v" else "noise"
      )
  
      model_fn = model_wrapper(
          lambda x, t, c: self.model.apply_model(x, t, c),
          ns,
          model_type=model_type,
          guidance_type="classifier-free",
          # condition=conditioning,
          # unconditional_condition=unconditional_conditioning,
          guidance_scale=unconditional_guidance_scale,
      )
  
      uni_pc = UniPC(
          model_fn,
          ns,
          predict_x0=True,
          thresholding=False,
          variant=shared.opts.uni_pc_variant,
          condition=conditioning,
          unconditional_condition=unconditional_conditioning,
          before_sample=self.before_sample,
          after_sample=self.after_sample,
          after_update=self.after_update,
      )
      x = uni_pc.sample(
          img,
          steps=S,
          skip_type=shared.opts.uni_pc_skip_type,
          method="multistep",
          order=shared.opts.uni_pc_order,
          lower_order_final=shared.opts.uni_pc_lower_order_final,
      )
  
      return x.to(device), None
  
file_path: stable-diffusion-webui/modules/models/diffusion/uni_pc/sampler.py
imports: import torch
  from .uni_pc import NoiseScheduleVP, model_wrapper, UniPC
  from modules import shared, devices
label_desc: Use image node_id 4 for calling the UniPCSampler obj's underlying member method code with example usage: obj.sample(S, batch_size, shape, conditioning, callback, normals_sequence, img_callback, quantize_x0, eta, mask, x0, temperature, noise_dropout, score_corrector, corrector_kwargs, verbose, x_T, log_every_t, unconditional_guidance_scale, unconditional_conditioning) and returns: x,  None