docstr: Plot all the views contained in the AdjointLayout Object using axes
  appropriate to the layout configuration. All the axes are
  supplied by LayoutPlot - the purpose of the call is to
  invoke subplots with correct options and styles and hide any
  empty axes as necessary.
code: def _create_subplots(
      self, layout, positions, layout_dimensions, ranges, num=0
  ):
      """
      Plot all the views contained in the AdjointLayout Object using axes
      appropriate to the layout configuration. All the axes are
      supplied by LayoutPlot - the purpose of the call is to
      invoke subplots with correct options and styles and hide any
      empty axes as necessary.
      """
      subplots = {}
      adjoint_clone = layout.clone(shared_data=False, id=layout.id)
      main_plot = None
      for pos in positions:
          # Pos will be one of 'main', 'top' or 'right' or None
          element = layout.get(pos, None)
          if element is None or not element.traverse(
              lambda x: x, [Element, Empty]
          ):
              continue
          if not displayable(element):
              element = collate(element)
  
          subplot_opts = dict(adjoined=main_plot)
          # Options common for any subplot
          vtype = (
              element.type
              if isinstance(element, HoloMap)
              else element.__class__
          )
          plot_type = Store.registry[self.renderer.backend].get(
              vtype, None
          )
          plotopts = self.lookup_options(element, "plot").options
          side_opts = {}
          if pos != "main":
              plot_type = AdjointLayoutPlot.registry.get(
                  vtype, plot_type
              )
              if pos == "right":
                  yaxis = (
                      "right-bare"
                      if plot_type and "bare" in plot_type.yaxis
                      else "right"
                  )
                  width = plot_type.width if plot_type else 0
                  side_opts = dict(
                      height=main_plot.height,
                      yaxis=yaxis,
                      width=width,
                      invert_axes=True,
                      labelled=["y"],
                      xticks=1,
                      xaxis=main_plot.xaxis,
                  )
              else:
                  xaxis = (
                      "top-bare"
                      if plot_type and "bare" in plot_type.xaxis
                      else "top"
                  )
                  height = plot_type.height if plot_type else 0
                  side_opts = dict(
                      width=main_plot.width,
                      xaxis=xaxis,
                      height=height,
                      labelled=["x"],
                      yticks=1,
                      yaxis=main_plot.yaxis,
                  )
  
          # Override the plotopts as required
          # Customize plotopts depending on position.
          plotopts = dict(side_opts, **plotopts)
          plotopts.update(subplot_opts)
  
          if vtype is Empty:
              adjoint_clone[pos] = element
              subplots[pos] = None
              continue
          elif plot_type is None:
              self.param.warning(
                  "Bokeh plotting class for %s type not found, object "
                  " will not be rendered." % vtype.__name__
              )
              continue
          num = num if len(self.coords) > 1 else 0
          subplot = plot_type(
              element,
              keys=self.keys,
              dimensions=self.dimensions,
              layout_dimensions=layout_dimensions,
              ranges=ranges,
              subplot=True,
              root=self.root,
              uniform=self.uniform,
              layout_num=num,
              renderer=self.renderer,
              **dict({"shared_axes": self.shared_axes}, **plotopts),
          )
          subplots[pos] = subplot
          if isinstance(plot_type, type) and issubclass(
              plot_type, GenericCompositePlot
          ):
              adjoint_clone[pos] = subplots[pos].layout
          else:
              adjoint_clone[pos] = subplots[pos].hmap
          if pos == "main":
              main_plot = subplot
  
      return subplots, adjoint_clone
  
imports: from collections import defaultdict
  from itertools import groupby
  import numpy
  import param
  from bokeh.layouts import gridplot
  from bokeh.models import Axis, ColorBar, Column, ColumnDataSource, Div, Legend, Row, Title
  from bokeh.models.layouts import TabPanel, Tabs
  from ...core import AdjointLayout, Element, Empty, GridSpace, HoloMap, Layout, NdLayout, Store
  from ...core.options import SkipRendering
  from ...core.util import _STANDARD_CALENDARS, cftime_to_timestamp, cftime_types, get_method_owner, is_param_method, unique_iterator, wrap_tuple, wrap_tuple_streams
  from ...selection import NoOpSelectionDisplay
  from ..links import Link
  from ..plot import CallbackPlot, DimensionedPlot, GenericAdjointLayoutPlot, GenericCompositePlot, GenericElementPlot, GenericLayoutPlot, GenericOverlayPlot
  from ..util import attach_streams, collate, displayable
  from .links import LinkCallback
  from .util import cds_column_replace, decode_bytes, empty_plot, filter_toolboxes, get_default, make_axis, merge_tools, select_legends, sync_legends, theme_attr_json, update_shared_sources
label_desc: Use image node_id 4 for calling the LayoutPlot obj's underlying member method code with example usage: obj._create_subplots(layout, positions, layout_dimensions, ranges, num) and returns: subplots,  adjoint_clone