code: def prepare_mask_and_masked_image(
      image, mask, height, width, return_image: bool = False
  ):
      """
      Prepares a pair (image, mask) to be consumed by the Stable Diffusion pipeline. This means that those inputs will be
      converted to ``torch.Tensor`` with shapes ``batch x channels x height x width`` where ``channels`` is ``3`` for the
      ``image`` and ``1`` for the ``mask``.
  
      The ``image`` will be converted to ``torch.float32`` and normalized to be in ``[-1, 1]``. The ``mask`` will be
      binarized (``mask > 0.5``) and cast to ``torch.float32`` too.
  
      Args:
          image (Union[np.array, PIL.Image, torch.Tensor]): The image to inpaint.
              It can be a ``PIL.Image``, or a ``height x width x 3`` ``np.array`` or a ``channels x height x width``
              ``torch.Tensor`` or a ``batch x channels x height x width`` ``torch.Tensor``.
          mask (_type_): The mask to apply to the image, i.e. regions to inpaint.
              It can be a ``PIL.Image``, or a ``height x width`` ``np.array`` or a ``1 x height x width``
              ``torch.Tensor`` or a ``batch x 1 x height x width`` ``torch.Tensor``.
  
  
      Raises:
          ValueError: ``torch.Tensor`` images should be in the ``[-1, 1]`` range. ValueError: ``torch.Tensor`` mask
          should be in the ``[0, 1]`` range. ValueError: ``mask`` and ``image`` should have the same spatial dimensions.
          TypeError: ``mask`` is a ``torch.Tensor`` but ``image`` is not
              (ot the other way around).
  
      Returns:
          tuple[torch.Tensor]: The pair (mask, masked_image) as ``torch.Tensor`` with 4
              dimensions: ``batch x channels x height x width``.
      """
  
      # checkpoint. TOD(Yiyi) - need to clean this up later
      if image is None:
          raise ValueError("`image` input cannot be undefined.")
  
      if mask is None:
          raise ValueError("`mask_image` input cannot be undefined.")
  
      if isinstance(image, torch.Tensor):
          if not isinstance(mask, torch.Tensor):
              mask = mask_pil_to_torch(mask, height, width)
  
          if image.ndim == 3:
              image = image.unsqueeze(0)
  
          # Batch and add channel dim for single mask
          if mask.ndim == 2:
              mask = mask.unsqueeze(0).unsqueeze(0)
  
          # Batch single mask or add channel dim
          if mask.ndim == 3:
              # Single batched mask, no channel dim or single mask not batched but channel dim
              if mask.shape[0] == 1:
                  mask = mask.unsqueeze(0)
  
              # Batched masks no channel dim
              else:
                  mask = mask.unsqueeze(1)
  
          assert (
              image.ndim == 4 and mask.ndim == 4
          ), "Image and Mask must have 4 dimensions"
          # assert image.shape[-2:] == mask.shape[-2:], "Image and Mask must have the same spatial dimensions"
          assert (
              image.shape[0] == mask.shape[0]
          ), "Image and Mask must have the same batch size"
  
          # Check image is in [-1, 1]
          # if image.min() < -1 or image.max() > 1:
          #    raise ValueError("Image should be in [-1, 1] range")
  
          # Check mask is in [0, 1]
          if mask.min() < 0 or mask.max() > 1:
              raise ValueError("Mask should be in [0, 1] range")
  
          # Binarize mask
          mask[mask < 0.5] = 0
          mask[mask >= 0.5] = 1
  
          # Image as float32
          image = image.to(dtype=torch.float32)
      elif isinstance(mask, torch.Tensor):
          raise TypeError(
              f"`mask` is a torch.Tensor but `image` (type: {type(image)} is not"
          )
      else:
          # preprocess image
          if isinstance(image, Union[PIL.Image.Image, np.ndarray]):
              image = [image]
          if isinstance(image, list) and isinstance(
              image[0], PIL.Image.Image
          ):
              # resize all images w.r.t passed height an width
              image = [
                  i.resize((width, height), resample=PIL.Image.LANCZOS)
                  for i in image
              ]
              image = [
                  np.array(i.convert("RGB"))[None, :] for i in image
              ]
              image = np.concatenate(image, axis=0)
          elif isinstance(image, list) and isinstance(
              image[0], np.ndarray
          ):
              image = np.concatenate(
                  [i[None, :] for i in image], axis=0
              )
  
          image = image.transpose(0, 3, 1, 2)
          image = (
              torch.from_numpy(image).to(dtype=torch.float32) / 127.5
              - 1.0
          )
  
          mask = mask_pil_to_torch(mask, height, width)
          mask[mask < 0.5] = 0
          mask[mask >= 0.5] = 1
  
      if image.shape[1] == 4:
          # images are in latent space and thus can't
          # be masked set masked_image to None
          # we assume that the checkpoint is not an inpainting
          # checkpoint. TOD(Yiyi) - need to clean this up later
          masked_image = None
      else:
          masked_image = image * (mask < 0.5)
  
      # n.b. ensure backwards compatibility as old function does not return image
      if return_image:
          return mask, masked_image, image
  
      return mask, masked_image
  
imports: import inspect
  from collections.abc import Callable
  from typing import Any, List, Optional, Union
  import numpy
  import PIL
  import torch
  import torch.nn.functional
  from transformers import CLIPTextModel, CLIPTextModelWithProjection, CLIPTokenizer
  from diffusers import DiffusionPipeline
  from diffusers.image_processor import PipelineImageInput, VaeImageProcessor
  from diffusers.loaders import FromSingleFileMixin, LoraLoaderMixin, StableDiffusionXLLoraLoaderMixin, TextualInversionLoaderMixin
  from diffusers.models import AutoencoderKL, ControlNetModel, MultiAdapter, T2IAdapter, UNet2DConditionModel
  from diffusers.models.attention_processor import AttnProcessor2_0, LoRAAttnProcessor2_0, LoRAXFormersAttnProcessor, XFormersAttnProcessor
  from diffusers.models.lora import adjust_lora_scale_text_encoder
  from diffusers.pipelines.controlnet.multicontrolnet import MultiControlNetModel
  from diffusers.pipelines.stable_diffusion_xl.pipeline_output import StableDiffusionXLPipelineOutput
  from diffusers.schedulers import KarrasDiffusionSchedulers
  from diffusers.utils import PIL_INTERPOLATION, USE_PEFT_BACKEND, logging, replace_example_docstring, scale_lora_layers, unscale_lora_layers
  from diffusers.utils.torch_utils import is_compiled_module, randn_tensor
label_desc: Use image node_id 3 for calling a global function with example usage: prepare_mask_and_masked_image(image, mask, height, width, return_image) and returns: mask,  masked_image, mask,  masked_image,  image