code: def subplots(
      figures,
      shape=None,
      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
      This is a wrapper for plotly.subplots.make_subplots
  
      Parameters:
      -----------
              figures : [Figures]
                      List of Plotly Figures
              shape : (rows,cols)
                      Tuple indicating the size of rows and columns
                      If omitted then the layout is automatically set
              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 grid.
              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 grid.
              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
              base_layout : layout (dict)
                      Layout to be used as base where the subplots will be
                      added
              subplot_titles : list(string)
                      List of strings that contains the titles of each
                      plot.
              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 isinstance(figures, list):
          figures = [figures]
  
      if shape:
          rows, cols = shape
          if len(figures) > rows * cols:
              raise Exception(
                  "Invalid shape for the number of figures given"
              )
      else:
          if len(figures) == 1:
              cols = 1
              rows = 1
          elif shared_xaxes:
              cols = 1
              rows = len(figures)
          elif shared_yaxes:
              cols = len(figures)
              rows = 1
          else:
              cols = 2
              rows = len(figures) // 2 + len(figures) % 2
      sp, grid_ref = get_subplots(
          rows=rows,
          cols=cols,
          shared_xaxes=shared_xaxes,
          shared_yaxes=shared_yaxes,
          start_cell=start_cell,
          theme=theme,
          base_layout=base_layout,
          **kwargs,
      )
      list_ref = (col for row in grid_ref for col in row)
      for i in range(len(figures)):
          while True:
              lr = next(list_ref)
              if lr is not None:
                  break
          for _ in figures[i]["data"]:
              for axe in lr:
                  _.update(axe.trace_kwargs)
              sp["data"].append(_)
      # Remove extra plots
      for k in list(sp["layout"].keys()):
          try:
              if int(k[-1]) > len(figures):
                  del sp["layout"][k]
          except:
              pass
  
      # Check for non-cartesian plots
      data = sp["data"]
      layout = sp["layout"]
      for d in data:
          if d["type"] == "pie":
              d["domain"] = {}
              d["domain"]["x"] = layout[
                  "xaxis{0}".format(d["xaxis"][1:])
              ]["domain"]
              d["domain"]["y"] = layout[
                  "yaxis{0}".format(d["yaxis"][1:])
              ]["domain"]
      return sp
  
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 10 for calling a global function with example usage: subplots(figures, shape, shared_xaxes, shared_yaxes, start_cell, theme, base_layout) and returns: sp