code: def prepare_mask_and_masked_image(image, mask, height, width):
      r"""
      Prepares a pair (mask, image) to be consumed by the Kandinsky inpaint 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``.
          height (`int`, *optional*, defaults to 512):
              The height in pixels of the generated image.
          width (`int`, *optional*, defaults to 512):
              The width in pixels of the generated image.
  
  
      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, image) as ``torch.Tensor`` with 4
              dimensions: ``batch x channels x height x width``.
      """
  
      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):
              raise TypeError(
                  f"`image` is a torch.Tensor but `mask` (type: {type(mask)} is not"
              )
  
          # Batch single image
          if image.ndim == 3:
              assert (
                  image.shape[0] == 3
              ), "Image outside a batch should be of shape (3, H, W)"
              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, (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=Image.BICUBIC,
                      reducing_gap=1,
                  )
                  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
          )
  
          # preprocess mask
          if isinstance(mask, (PIL.Image.Image, np.ndarray)):
              mask = [mask]
  
          if isinstance(mask, list) and isinstance(
              mask[0], PIL.Image.Image
          ):
              mask = [
                  i.resize((width, height), resample=PIL.Image.LANCZOS)
                  for i in mask
              ]
              mask = np.concatenate(
                  [
                      np.array(m.convert("L"))[None, None, :]
                      for m in mask
                  ],
                  axis=0,
              )
              mask = mask.astype(np.float32) / 255.0
          elif isinstance(mask, list) and isinstance(
              mask[0], np.ndarray
          ):
              mask = np.concatenate(
                  [m[None, None, :] for m in mask], axis=0
              )
  
          mask[mask < 0.5] = 0
          mask[mask >= 0.5] = 1
          mask = torch.from_numpy(mask)
  
      mask = 1 - mask
  
      return mask, image
  
imports: from copy import deepcopy
  from typing import Callable, Dict, List, Optional, Union
  import numpy
  import PIL.Image
  import torch
  import torch.nn.functional
  from packaging import version
  from PIL import Image
  from ...None import __version__
  from ...models import UNet2DConditionModel, VQModel
  from ...schedulers import DDPMScheduler
  from ...utils import deprecate, logging
  from ...utils.torch_utils import randn_tensor
  from ..pipeline_utils import DiffusionPipeline, ImagePipelineOutput
label_desc: Use image node_id 3 for calling a global function with example usage: prepare_mask_and_masked_image(image, mask, height, width) and returns: mask,  image