code: def get_subplots(
      rows=1,
      cols=1,
      shared_xaxes=False,
      shared_yaxes=False,
      start_cell="top-left",
      theme=None,
      base_layout=None,
      **kwargs,
  ):
      """
      Generates a subplot view for a set of figures
  
      Parameters:
      -----------
              rows : int
                      Number of rows
              cols : int
                      Number of cols
              shared_xaxes : bool
                      Assign shared x axes.
                      If True, subplots in the same grid column have one common
                      shared x-axis at the bottom of the gird.
              shared_yaxes : bool
                      Assign shared y axes.
                      If True, subplots in the same grid row have one common
                      shared y-axis on the left-hand side of the gird.
              start_cell : string
                              'bottom-left'
                              'top-left'
                      Choose the starting cell in the subplot grid used to set the
                      domains of the subplots.
              theme : string
                      Layout Theme
                              solar
                              pearl
                              white
                      see cufflinks.getThemes() for all
                      available themes
              horizontal_spacing : float
                              [0,1]
                      Space between subplot columns.
              vertical_spacing : float
                      Space between subplot rows.
              specs : list of dicts
                      Subplot specifications.
                              ex1: specs=[[{}, {}], [{'colspan': 2}, None]]
                              ex2: specs=[[{'rowspan': 2}, {}], [None, {}]]
  
                      - Indices of the outer list correspond to subplot grid rows
                        starting from the bottom. The number of rows in 'specs'
                        must be equal to 'rows'.
  
                      - Indices of the inner lists correspond to subplot grid columns
                        starting from the left. The number of columns in 'specs'
                        must be equal to 'cols'.
  
                      - Each item in the 'specs' list corresponds to one subplot
                        in a subplot grid. (N.B. The subplot grid has exactly 'rows'
                        times 'cols' cells.)
  
                      - Use None for blank a subplot cell (or to move pass a col/row span).
  
                      - Note that specs[0][0] has the specs of the 'start_cell' subplot.
  
                      - Each item in 'specs' is a dictionary.
                              The available keys are:
  
                              * is_3d (boolean, default=False): flag for 3d scenes
                              * colspan (int, default=1): number of subplot columns
                                      for this subplot to span.
                              * rowspan (int, default=1): number of subplot rows
                                      for this subplot to span.
                              * l (float, default=0.0): padding left of cell
                              * r (float, default=0.0): padding right of cell
                              * t (float, default=0.0): padding right of cell
                              * b (float, default=0.0): padding bottom of cell
  
                      - Use 'horizontal_spacing' and 'vertical_spacing' to adjust
                        the spacing in between the subplots.
  
              insets : list of dicts
                      Inset specifications.
  
                      - Each item in 'insets' is a dictionary.
                              The available keys are:
  
                              * cell (tuple, default=(1,1)): (row, col) index of the
                                      subplot cell to overlay inset axes onto.
                              * is_3d (boolean, default=False): flag for 3d scenes
                              * l (float, default=0.0): padding left of inset
                                        in fraction of cell width
                              * w (float or 'to_end', default='to_end') inset width
                                        in fraction of cell width ('to_end': to cell right edge)
                              * b (float, default=0.0): padding bottom of inset
                                        in fraction of cell height
                              * h (float or 'to_end', default='to_end') inset height
                                        in fraction of cell height ('to_end': to cell top edge)
      """
  
      if not theme:
          theme = auth.get_config_file()["theme"]
  
      layout = (
          base_layout
          if base_layout
          else getLayout(theme, **check_kwargs(kwargs, __LAYOUT_AXIS))
      )
      sp = make_subplots(
          rows=rows,
          cols=cols,
          shared_xaxes=shared_xaxes,
          shared_yaxes=shared_yaxes,
          print_grid=False,
          start_cell=start_cell,
          **kwargs,
      )
      sp, grid_ref = sp.to_dict(), sp._grid_ref
  
      for k, v in list(layout.items()):
          if "xaxis" not in k and "yaxis" not in k:
              sp["layout"].update({k: v})
  
      def update_axis(fig, layout):
          for axis, n in list(Figure(fig).axis["len"].items()):
              for _ in range(1, n + 1):
                  for k, v in list(
                      layout["{0}axis".format(axis)].items()
                  ):
                      _ = "" if _ == 1 else _
                      if (
                          k
                          not in fig["layout"][
                              "{0}axis{1}".format(axis, _)
                          ]
                      ):
                          fig["layout"]["{0}axis{1}".format(axis, _)][
                              k
                          ] = v
  
      update_axis(sp, layout)
      # 124 - zeroline on the first figure
  
      # if 'subplot_titles' in kwargs:
      # 	if 'annotations' in layout:
      # 		annotation=sp['layout']['annotations'][0]
      # 	else:
      # 		annotation=getLayout(theme,annotations=[Annotation(text='')])['annotations']
      # 	for ann in sp['layout']['annotations']:
      # 		ann.update(font=dict(color=annotation['font']['color']))
  
      # def update_items(sp_item,layout,axis):
      # 	for k,v in list(layout[axis].items()):
      # 		sp_item.update({k:v})
  
      # for k,v in list(sp['layout'].items()):
      # 	if isinstance(v,go.XAxis):
      # 		update_items(v,layout,'xaxis1')
      # 	elif isinstance(v,go.YAxis):
      # 		update_items(v,layout,'xaxis1')
  
      return sp, grid_ref
  
imports: import copy
  import numpy
  import pandas
  import plotly.offline
  import plotly.figure_factory
  from plotly.graph_objs import Figure, Scatter, Line
  from plotly.subplots import make_subplots
  from .None import themes
  from .None import auth, ta
  from .colors import normalize, to_rgba
  from .utils import check_kwargs, deep_update, dict_replace_keyword, kwargs_from_keyword, merge_dict, is_list, make_list
label_desc: Use image node_id 11 for calling a global function with example usage: get_subplots(rows, cols, shared_xaxes, shared_yaxes, start_cell, theme, base_layout) and returns: sp,  grid_ref