class_docstr: Same as MONAI's ``list_data_collate``, except any tensors are centrally padded to match the shape of the biggest
  tensor in each dimension. This transform is useful if some of the applied transforms generate batch data of
  different sizes.
  
  This can be used on both list and dictionary data.
  Note that in the case of the dictionary data, it may add the transform information to the list of invertible transforms
  if input batch have different spatial shape, so need to call static method: `inverse` before inverting other transforms.
  
  Note that normally, a user won't explicitly use the `__call__` method. Rather this would be passed to the `DataLoader`.
  This means that `__call__` handles data as it comes out of a `DataLoader`, containing batch dimension. However, the
  `inverse` operates on dictionaries containing images of shape `C,H,W,[D]`. This asymmetry is necessary so that we can
  pass the inverse through multiprocessing.
  
  Args:
      method: padding method (see :py:class:`monai.transforms.SpatialPad`)
      mode: padding mode (see :py:class:`monai.transforms.SpatialPad`)
      kwargs: other arguments for the `np.pad` or `torch.pad` function.
          note that `np.pad` treats channel dimension as the first dimension.
docstr: Args:
      batch: batch of data to pad-collate
docstr_tok: ["Args",":","batch",":","batch","of","data","to","pad-collate"]
code: def __call__(self, batch: Any):
      """
      Args:
          batch: batch of data to pad-collate
      """
      # data is either list of dicts or list of lists
      is_list_of_dicts = isinstance(batch[0], dict)
      # loop over items inside of each element in a batch
      batch_item = (
          tuple(batch[0].keys())
          if is_list_of_dicts
          else range(len(batch[0]))
      )
      for key_or_idx in batch_item:
          # calculate max size of each dimension
          max_shapes = []
          for elem in batch:
              if not isinstance(
                  elem[key_or_idx], (torch.Tensor, np.ndarray)
              ):
                  break
              max_shapes.append(elem[key_or_idx].shape[1:])
          # len > 0 if objects were arrays, else skip as no padding to be done
          if not max_shapes:
              continue
          max_shape = np.array(max_shapes).max(axis=0)
          # If all same size, skip
          if np.all(np.array(max_shapes).min(axis=0) == max_shape):
              continue
  
          # Use `SpatialPad` to match sizes, Default params are central padding, padding with 0's
          padder = SpatialPad(
              spatial_size=max_shape,
              method=self.method,
              mode=self.mode,
              **self.kwargs,
          )
          for idx, batch_i in enumerate(batch):
              orig_size = batch_i[key_or_idx].shape[1:]
              padded = padder(batch_i[key_or_idx])
              batch = replace_element(padded, batch, idx, key_or_idx)
  
              # If we have a dictionary of data, append to list
              # padder transform info is re-added with self.push_transform to ensure one info dict per transform.
              if is_list_of_dicts:
                  self.push_transform(
                      batch[idx],
                      key_or_idx,
                      orig_size=orig_size,
                      extra_info=self.pop_transform(
                          batch[idx], key_or_idx, check=False
                      ),
                  )
  
      # After padding, use default list collator
      return list_data_collate(batch)
  
file_path: MONAI/monai/transforms/croppad/batch.py
imports: from __future__ import annotations
  from collections.abc import Hashable, Mapping
  from typing import Any
  import numpy
  import torch
  from monai.data.meta_tensor import MetaTensor
  from monai.data.utils import list_data_collate
  from monai.transforms.croppad.array import CenterSpatialCrop, SpatialPad
  from monai.transforms.inverse import InvertibleTransform
  from monai.utils.enums import Method, PytorchPadMode, TraceKeys
label_desc: Use image node_id 2 for calling the PadListDataCollate obj's underlying member method code with example usage: obj.__call__(batch) and returns: list_data_collate